formato de serie cadena hex
introducción
La comunicación en serie se refiere en general a un conjunto de datos de simulación de procesos y un proceso de transmisión de datos, en general, vamos a enviar una serie de instrucciones para la próxima tripulación
68 05 00 84 01 02 03En este ejemplo, sabemos que somos convertidos en pantalla de caracteres carácter hexadecimal para las letras indicación ASCII correspondientes, pero en el proceso que se puede utilizar la cadena representa directamente un personaje que queremos escribir, a continuación, después de recibir conversión serie código ASCII correspondiente a los datos de proceso,
Aquí hay algunas funciones de conversión común
Formato de datos
En nuestra descripción
se da primero 
o referencia Wikipedia ACII de descripción detallada
en este documento, estamos usando "abc123", como una cadena de caracteres en el que cada pantalla representada
- Se refiere a una cadena de la cadena "abc 123" que puede ser capaz de jugar a cabo la representación de caracteres ASCII, ya que no podemos romper parte del carácter o caracteres no se muestran, sólo los comandos de control para la cadena str defectuoso = " abc123 "
- Char cadena array [] UCHAR [] se refiere a un conjunto de datos en el CPP, tipo de almacenamiento de carbón o una UCHAR carácter, podemos utilizar una representación digital de -128 a 127 o 0-255, nosotros consideramos que una serie de facilitar UCHAR procesamiento posterior uchar buffer = {} 97,98,99,49,50,51
- Char * UCHAR * puntero de cadena es un tipo de puntero, por lo general apunta a la dirección de los primeros datos de cadena de caracteres, porque creemos que para muchas funciones en el proceso de 0x00 '\ 0' está terminado, el tiempo de proceso lo más posible la longitud de la UCHAR entrante * buffer = buffer
- la conversión de los valores de cadena hexagonal en una matriz de cadenas dentro de los dos valores hexadecimales, a continuación, utilizar la división de espacio puede ser comandos fácilmente de entrada, por ejemplo, cadena de comando = "61 62 63 31 32 33"
Adecuados tales ventajas y desventajas, por ejemplo, se envían a la máquina inferior utilizando un comando de control en un control Modbus convencional, típicamente en la entrada en serie directamente, entonces enviado a hex, pero si necesitan probar los datos correspondientes de acuerdo con los dos segmentos, llenos txt texto, cada línea de datos se lee, y luego ser capaz de convertir los datos a entradas analógicas y flujo binario ascii salidas
68 13 00 85 11 12 21 22 31 32 00 00 01 00 00 02 00 00 03 88 FF 01 02 03 04 05 0Fla conversión del formato de datos
la conversión de datos 1. UCHAR y el byte de datos Char
datos de tipo char -128-127, UCHAR 0-255 datos de tipo son un byte, char tipo de datos de la primera bit de signo, los siguientes habrá de 127 (01111111) se convierte en 1 -128 (1000 0000 ) la transformación, entonces no va a transformar desde -1 (1111 1111) a 0 (0000, 0000), y se puede buscar el detalle char 溢出con 数据补码contenido relacionado,
Por lo tanto uchar interconversión -char puede considerarse en dos partes
UCHAR de [0, 127] == char [0127]
ucahr la [128, 255] == char [ -128, -1]
// uchar 数据转换 char >127 c1-256
char Utils_String::UChar2Char(uchar c1)
{
return static_cast<char>(c1 > 127 ? c1 - 256 : c1);
}
// char 类型转换 uchar <0 -- c1 +256
uchar Utils_String::Char2UChar(char c1)
{
return static_cast<uchar>((c1 < 0 ? 256 + c1 : c1));
}2. conversión hex y digitales
caracteres Hex Hex representan generalmente, por conveniencia, ya mostramos, a su vez representada por un número hexadecimal de 16 caracteres se suministra 0-9 AF 0-15, aquí no tener en cuenta las letras mayúsculas, minúsculas a mayúsculas AF equivalente af,
Dado que el tipo de datos entre uchar 0-256, se puede expresar exactamente dos caracteres hexadecimales para representar, prefijo 0x indica caracteres hexadecimales, representa octal 0o 0d indica decimal [0255] == [0x00, 0xFF,]
hemos establecido una conversión entre caracteres 0-f y 0-15, hay dos modos de conversión a es obligatoria si se determina la conversión, el otro es el uso de una cierta disposición de la mesa de optimización de código proceso
Y a los códigos hexadecimales num interconversión
/**
* @fn int Utils_String::Hex2Num(const char ch)
*
* @brief 根据 各种情况 转换字母 一位字母 大于 48 的 +9 然后取后4位的值
* *
*
* @author IRIS_Chen
* @date 2019/12/16
*
* @param ch The ch
*
* @return An int
*/
int Utils_String::Hex2Num(const char ch)
{
//int res = (ch & '@' ? ch + 9 : ch) & 0x0F;
//LInfo("ch:{},res:{}", ch, res);
return (ch & '@' ? ch + 9 : ch) & 0x0F;
}
/**
* @fn char Utils_String::Num2Hex(int num, bool Up )
*
* @brief 将 0-15 转换成 0-F
*
* @author IRIS_Chen
* @date 2019/12/18
*
* @param num Number of
* @param Up True to up
*
* @return The total number of 2 hexadecimal
*/
char Utils_String::Num2Hex(int num, bool Up /* = true */)
{
char res;
if (num >= 10 && num <= 15)
{
res = num - 10 + (Up ? 'A' : 'a');
}
else
res = num + '0';
return res;
}Y a los códigos hexadecimales num interconversión
2 y uchar conversión hex
/**
* @fn uchar Utils_String::Hex2Uchar(const std::string & str)
*
* @brief Hexadecimal 2 uchar 将两个 hex 字符 转换成 0-256
*
* @author IRIS_Chen
* @date 2019/12/18
*
* @param str The string 默认初始两位字符 FF == 255 00 = 0 0D = 14
*
* @return An uchar
*/
uchar Utils_String::Hex2Uchar(const std::string & str)
{
uchar res = 0;
for (const auto &s:str)
{
res = (res << 4) + Hex2Num(s);
}
return res;
}
/**
* @fn std::string Utils_String::Num2Hex(uchar num, bool Up)
*
* @brief Number 2 hexadecimal 得到的结果只有 小写
*
* @author IRIS_Chen
* @date 2019/12/18
*
* @param num Number of
* @param Up True to up
*
* @return The total number of 2 hexadecimal
*/
std::string Utils_String::Num2Hex(uchar num, bool Up)
{
std::map<int, char> t_base = {
{ 8,'o' },
{ 10,'d' },
{ 16,'x' } };
if (!t_base.count(base))
return "";
// 使用 sprintf 格式化输出, 将数字 转换成相应的进制值
std::string format = "%0" + std::to_string(width) + t_base.find(base)->second;
char *buf = new char[20];
sprintf(buf, format.c_str(), num);
std::string res=std::string(buf);
// 转换大小写
return Up ? StringUpper(res) : StringLowwer (res);
}3. cadena dada en una matriz de cadenas
Debido a la rotación puntero de cadena carácter convertido nativa
puntero puede ser utilizado para procesar un nativo
/**
* @fn const uchar * Utils_String::String2Uchar(const std::string & str)
*
* @brief String 2 uchar
*
* @author IRIS_Chen
* @date 2019/12/16
*
* @param str The string
*
* @return Null if it fails, else a pointer to a const uchar
*/
const uchar * Utils_String::String2Uchar(const std::string & str)
{
return (uchar*)str.c_str();
}
/**
* @fn std::string Utils_String::Uchar2String(const uchar * buffer)
*
* @brief Uchar 2 string
*
* @author IRIS_Chen
* @date 2019/12/16
*
* @param buffer The buffer
*
* @return A std::string
*/
std::string Utils_String::Uchar2String(const uchar * buffer)
{
std::string str = (char*)buffer;
return str;
}4. hex cadena matriz de conversión de cadenas
capturar secuencialmente dos caracteres, se convierte a un valor de datos almacenado para ucahr
Conversión hexadecimal matriz de cadenas de cadena
/**
* @fn uchar * Utils_String::Hex2CharArr(uchar *&buffer, const std::string & str, bool flg_space)
*
* @brief Hexadecimal 2 character array hex 字符串 转换成 数组
*
* @author IRIS_Chen
* @date 2019/12/18
*
* @param [in,out] buffer [in,out] If non-null, the buffer
* @param str The string
* @param flg_space True to flg space hex 是否使用空格分割
*
* @return Null if it fails, else a pointer to an uchar
*/
uchar * Utils_String::Hex2CharArr(uchar *&buffer, const std::string & str, bool flg_space)
{
// 出错 只有两个值 默认不符合 操作
if (str.size() < 3) return nullptr;
// 默认够长 判断是否存在空格
if (str[2] == ' ') flg_space = true;
int step = flg_space ? 3 : 2;
buffer = new uchar[(str.size() + 1) / step +1 ];
std::string str2 = "";
for (int i = 0; i < static_cast<int>(str.size());)
{
uchar ch = Hex2Uchar(str.substr(static_cast<size_t>(i), 2));
// 根据是否有空格选择 移动
*(buffer + i/step) = ch;
i += step;
str2 += std::to_string((int)ch) + "-";
}
// LInfo("charArr:{}", str2);
return buffer;
}
/**
* @fn std::string Utils_String::CharArr2Hex(uchar * buffer, int length, int flg_space)
*
* @brief Character array 2 hexadecimal 数组 转换成 hex 字符
* * 将UCHAR 字符串依次转换成 string 字符串
*
* @author IRIS_Chen
* @date 2019/12/18
*
* @param [in,out] buffer If non-null, the buffer
* @param length The length
* @param flg_space The flg space
*
* @return A std::string
*/
std::string Utils_String::CharArr2Hex(uchar * buffer, int length, int flg_space)
{
std::string str = "";
// 读取数组中所有字符
for (int i = 0; i < length; i++)
{
str += Num2Hex(*buffer++);
// 如果开启空格的话 每两个字符 之间加入一个空格 最后一个不加
if (flg_space && i != length - 1)
str += " ";
}
return str;
}más
Probablemente tanto proceso de conversión común, hay una matriz de cadenas función de transferencia separada, que se puede utilizar sprintfcon formato valores de módulo cíclicos de salida, la violencia o para obtener un resultado final
conversión digital y la cadena puede ser un número ary
/**
* @fn std::string Utils_String::NumToString(int num, int width, int base)
*
* @brief Number to string 整型数据 前补 0 占位符显示 进制 为 8 10 16 如果超过给出的宽度 原始宽度显示
*
* @author IRIS_Chen
* @date 2019/12/3
*
* @param num Number of
* @param width The width
* @param base The base
*
* @return The total number of to string
*/
std::string Utils_String::NumToString(int num, int width, int base)
{
#if 0
// 保证 存在进制 只考虑 2 8 , 10 16 进制
static std::map<int, char> t_base = {
{ 2,'0' },
{ 8,'o' },
{ 10,'d' },
{ 16,'x' } };
if (!t_base.count(base))
return "";
// 二进制 特殊处理
if (base == 2)
{
std::string str_8 = NumToString(num, width, 8);
// 设置8进制 转2进制码表, 转换之后 去除前缀0 即可
static const std::vector<std::string> table = { "000","001","010","011","100","101","110","111" };
std::string str_2 = "";
for (auto s : str_8)
{
if(s =='0')
continue;
str_2 += table[s - '0'];
}
// 去掉前面所有的 0值 从1 开始
int pos = static_cast<int>(str_2.find_first_of('1'));
// #TODO(Schen00) 处理, 得到的长度小于width 的情况
return pos == std::string::npos ?"":str_2.substr (pos);
}
std::string format = "%0" + std::to_string(width) + t_base.find(base)->second;
char *buf = new char[20];
sprintf(buf, format.c_str(), num);
return std::string(buf);
#else
std::string res = "";
while (num)
{
res = base == 16 ? Num2Hex(num % base) : (num % base + '0') + res;
num /= base;
}
// 不足位 补0 足位 不删除
int cnt = width - res.size();
while (cnt--)
{
res = '0' + res;
}
return res;
#endif
}