原创一个让人头痛而又有趣的软件bug

 2020-6-11 22:56  13204 89 14 分类: MCU/ 嵌入式文集: C语言

这是我前几天遇到的bug，RS485协议程序我已经做过无数次了，有无数个成功的先例。当开始做这个小程序的时候，我认为对我而言这只是小菜一碟，我挥挥手就可以把它搞定。

但是事情出乎我的意料，程序工作不正常！

先把有bug的代码贴出来：（代码很长，如果看起来眼睛脑壳痛，请直接跳过源代码，看后面的文字说明就好了，贴出代码是为了让人能感受到debug有时候是一件让人多么痛苦的事情）

void RS485_Poll(void)
{
uint8_t byte;
static uint8_t index = 0,len = 0;
static uint16_t check;
uint8_t i;
if(!BSP_RxFifoOut(&byte))
{
if(s_u8BusIdleFlag == 1)
{
if((s_u8RetryCount > 0) && (s_u16DelaySendPack_Timer_1ms == 0))
{
s_u8CollisionDetecting = 1;
s_u8DataVerifyIndex = 0;
len = s_u8OutPack[PROTOCOL_STATE_LEN] + 2;
for(i = 0;i < len;i++)
{
BSP_USART1Tx(s_u8OutPack[i]);
}
s_u8BusIdleFlag = 0;
s_u8Tick_64us = 32;
}
}
}
else
{
s_u8BusIdleFlag = 0;
s_u8Tick_64us = 32;
if(s_u8CollisionDetecting == 1)
{
if(byte == s_u8OutPack[s_u8DataVerifyIndex++])
{
if(s_u8DataVerifyIndex == s_u8OutPack[PROTOCOL_STATE_LEN] + 2)
{
s_u8CollisionDetecting = 0;
s_u8RetryCount = 0;
}
}
else
{
s_u8CollisionDetecting = 0;
if(s_u8RetryCount > 0)
{
s_u8RetryCount--;
s_u16DelaySendPack_Timer_1ms = GetPeseudoRandom();
}
}
}
else
{
switch(s_ProtocolState)
{
case PROTOCOL_STATE_HEAD0:
if(byte == 0xAA)
{
s_ProtocolState = PROTOCOL_STATE_HEAD1;
s_u8Reset_Timer_1ms = 0;
index = 0;
s_u8InPack[index++] = byte;
}
break;
case PROTOCOL_STATE_HEAD1:
if(byte == 0xAA)
{
s_ProtocolState = PROTOCOL_STATE_LEN;
s_u8InPack[index++] = byte;
}
else
{
s_ProtocolState = PROTOCOL_STATE_HEAD0;
}
break;
case PROTOCOL_STATE_LEN:
s_u8InPack[index++] = byte;
len = byte;
if((len <= (MAX_PACK_LEN - 2))
&& (len >= (MIN_PACK_LEN - 2)))
{
s_ProtocolState = PROTOCOL_STATE_SRC_NET;
}
else
{
s_ProtocolState = PROTOCOL_STATE_HEAD0;
}
break;
case PROTOCOL_STATE_SRC_NET:
s_u8InPack[index++] = byte;
s_u8SrcNet = byte;
s_ProtocolState = PROTOCOL_STATE_SRC_DEV;
break;
case PROTOCOL_STATE_SRC_DEV:
s_u8InPack[index++] = byte;
s_u8SrcDev = byte;
s_ProtocolState = PROTOCOL_STATE_SRC_TYPE_H;
break;
case PROTOCOL_STATE_SRC_TYPE_H:
s_u8InPack[index++] = byte;
s_u16SrcType = ((uint16_t)byte)<<8;
s_ProtocolState = PROTOCOL_STATE_SRC_TYPE_L;
break;
case PROTOCOL_STATE_SRC_TYPE_L:
s_u8InPack[index++] = byte;
s_u16SrcType |= byte;
s_ProtocolState = PROTOCOL_STATE_CMD_H;
break;
case PROTOCOL_STATE_CMD_H:
s_u8InPack[index++] = byte;
s_u16Command = ((uint16_t)byte)<<8;
s_ProtocolState = PROTOCOL_STATE_CMD_L;
break;
case PROTOCOL_STATE_CMD_L:
s_u8InPack[index++] |= byte;
s_u16Command |= byte;
s_ProtocolState = PROTOCOL_STATE_DST_NET;
break;
case PROTOCOL_STATE_DST_NET:
s_u8InPack[index++] = byte;
s_u8DstNet = byte;
s_ProtocolState = PROTOCOL_STATE_DST_DEV;
break;
case PROTOCOL_STATE_DST_DEV:
s_u8InPack[index++] = byte;
s_u8DstDev = byte;
if(len > MIN_PACK_LEN)
{
s_ProtocolState = PROTOCOL_STATE_DAT;
}
else
{
s_ProtocolState = PROTOCOL_STATE_CRC_H;
}
break;
case PROTOCOL_STATE_DAT:
s_u8InPack[index++] = byte;
if(index >= len)
{
s_ProtocolState = PROTOCOL_STATE_CRC_H;
}
break;
case PROTOCOL_STATE_CRC_H:
s_u8InPack[index++] = byte;
check = ((uint16_t)byte)<<8;
s_ProtocolState = PROTOCOL_STATE_CRC_L;
break;
case PROTOCOL_STATE_CRC_L:
s_u8InPack[index++] = byte;
check |= byte;
if(check == CalcCRC16(s_u8InPack + 2,len - 2))
{
CommandHandle();
}
s_ProtocolState = PROTOCOL_STATE_HEAD0;
break;
default:
break;
}
}
}
}
static void CommandHandle(void)
{
if(((s_u8DstNet == s_u8LocalNet) && (s_u8DstDev == s_u8LocalDev))
|| ((s_u8DstNet == 0xff) && (s_u8DstDev == 0xff)))
{
if(s_u16Command == 0xE3E0)
{
if((((s_u8InPack[PROTOCOL_STATE_DAT + 2] == 0) || (s_u8InPack[PROTOCOL_STATE_LEN] == 13))
&&(s_u8InPack[PROTOCOL_STATE_DAT] < 0x11))
|| (s_u8InPack[PROTOCOL_STATE_DAT + 2] == 1))
{
if(s_u8InPack[PROTOCOL_STATE_DAT + 1] == 0)
{
Message_FifoIn(MSG_SERIAL_STOP);
}
else if(s_u8InPack[PROTOCOL_STATE_DAT + 1] == 1)
{
Message_FifoIn(MSG_SERIAL_OPEN);
}
else if(s_u8InPack[PROTOCOL_STATE_DAT + 1] == 2)
{
Message_FifoIn(MSG_SERIAL_CLOSE);
}
}
else if((((s_u8InPack[PROTOCOL_STATE_DAT + 2] == 0) || (s_u8InPack[PROTOCOL_STATE_LEN] == 13))
&&(s_u8InPack[PROTOCOL_STATE_DAT] >= 0x11))
|| (s_u8InPack[PROTOCOL_STATE_DAT + 2] == 2))
{
if(s_u8InPack[PROTOCOL_STATE_DAT + 1] <= 0)
{
s_u8TargetPercent = s_u8InPack[PROTOCOL_STATE_DAT + 1];
Message_FifoIn(MSG_SERIAL_TP);
}
}
if(!((s_u8LocalNet == 0xff) && (s_u8LocalDev == 0xff)))
{
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xE3;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xE1; // 注释掉此行后，可以连续接收命令
BuildInPack();
SendInPack();
}
}
else if(s_u16Command == 0xE3E2)
{
if((((s_u8InPack[PROTOCOL_STATE_DAT + 2] == 0) || (s_u8InPack[PROTOCOL_STATE_LEN] == 13))
&&(s_u8InPack[PROTOCOL_STATE_DAT] < 0x11))
|| (s_u8InPack[PROTOCOL_STATE_DAT + 2] == 1))
{
s_u8InPack[PROTOCOL_STATE_DAT + 1] = GetCurtainControlState();
}
else if((((s_u8InPack[PROTOCOL_STATE_DAT + 2] == 0) || (s_u8InPack[PROTOCOL_STATE_LEN] == 13))
&&(s_u8InPack[PROTOCOL_STATE_DAT] >= 0x11))
|| (s_u8InPack[PROTOCOL_STATE_DAT + 2] == 2))
{
s_u8InPack[PROTOCOL_STATE_DAT + 1] = Curtain_GetPercent();
}
if(!((s_u8LocalNet == 0xff) && (s_u8LocalDev == 0xff)))
{
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xE3;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xE3;
BuildInPack();
SendInPack();
}
}
else if(s_u16Command == 0xF001)
{
if(CurtainController_IsProgState())
{
uint8_t i;
for(i = 0;i < 8;i++)
{
s_u8Mac[i] = s_u8InPack[PROTOCOL_STATE_DAT + i];
eeprom_write_byte(EEPROM_HDL_MAC + i,s_u8Mac[i]);
}
s_u8InPack[PROTOCOL_STATE_DAT] = 0xF8;
Message_FifoIn(MSG_SERIAL_LEAVE_LEARN);
}
else
{
s_u8InPack[PROTOCOL_STATE_DAT] = 0xF5;
}
s_u8InPack[PROTOCOL_STATE_LEN] = 12;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xF0;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x02;
BuildInPack();
SendInPack();
}
else if(s_u16Command == 0xF003)
{
uint8_t i;
for(i = 0;i < 8;i++)
{
s_u8InPack[PROTOCOL_STATE_DAT + i] = s_u8Mac[i];
}
s_u8InPack[PROTOCOL_STATE_DAT + i++] = s_u8LocalNet;
s_u8InPack[PROTOCOL_STATE_DAT + i++] = s_u8LocalDev;
s_u8InPack[PROTOCOL_STATE_DAT + i++] = 0x02;
s_u8InPack[PROTOCOL_STATE_DAT + i++] = 0xC1;
s_u8InPack[PROTOCOL_STATE_LEN] = 23;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xF0;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x04;
BuildInPack();
SendInPack();
}
else if(s_u16Command == 0x000E)
{
uint8_t i;
for(i = 0;i < 20;i++)
{
s_u8InPack[PROTOCOL_STATE_DAT + i] = s_u8Remark[i];
}
s_u8InPack[PROTOCOL_STATE_LEN] = 31;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0x00;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x0F;
BuildInPack();
SendInPack();
}
else if(s_u16Command == 0x0010)
{
if((s_u8LocalNet == s_u8InPack[PROTOCOL_STATE_DST_NET]) && (s_u8LocalDev == s_u8InPack[PROTOCOL_STATE_DST_DEV]))
{
uint8_t i;
for(i = 0;i < 20;i++)
{
s_u8Remark[i] = s_u8InPack[PROTOCOL_STATE_DAT + i];
eeprom_write_byte(EEPROM_HDL_REMARK + i,s_u8Mac[i]);
}
s_u8InPack[PROTOCOL_STATE_LEN] = 12;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0x00;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x11;
BuildInPack();
SendInPack();
}
}
else if(s_u16Command == 0xE5F5)
{
if(CurtainController_IsProgState())
{
s_u8InPack[PROTOCOL_STATE_DAT + 0] = s_u8LocalNet;
s_u8InPack[PROTOCOL_STATE_DAT + 1] = s_u8LocalDev;
s_u8InPack[PROTOCOL_STATE_LEN] = 13;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xE5;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xF6;
BuildInPack();
SendInPack();
Message_FifoIn(MSG_SERIAL_LEAVE_LEARN);
}
}
else if(s_u16Command == 0xE5F7)
{
if(CurtainController_IsProgState())
{
s_u8LocalNet = s_u8InPack[PROTOCOL_STATE_DAT + 0];
s_u8LocalDev = s_u8InPack[PROTOCOL_STATE_DAT + 1];
eeprom_write_byte(EEPROM_HDL_NET,s_u8LocalNet);
eeprom_write_byte(EEPROM_HDL_DEV,s_u8LocalDev);
s_u8InPack[PROTOCOL_STATE_LEN] = 13;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xE5;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xF8;
BuildInPack();
SendInPack();
Message_FifoIn(MSG_SERIAL_LEAVE_LEARN);
}
}
else if(s_u16Command == 0xE8F8)
{
if(CurtainController_IsProgState())
{
/* s_u8InPack[PROTOCOL_STATE_DAT] = 0xF8;
s_u8InPack[PROTOCOL_STATE_LEN] = 12;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xE8;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xF9;
BuildInPack();
SendInPack(); */
eeprom_write_byte(EEPROM_PROTOCOL_TYPE,PROTOCOL_TYPE_RAEX_485);
SerialProtocol_init();
Message_FifoIn(MSG_SERIAL_LEAVE_LEARN);
}
}
else if(s_u16Command == 0xFE05)
{
uint8_t i;
uint8_t flag = 1;
for(i = 0;i < 8;i++)
{
if(s_u8InPack[PROTOCOL_STATE_DAT + i] != s_u8Mac[i])
{
flag = 0;
}
}
if(flag == 1)
{
s_u8InPack[PROTOCOL_STATE_LEN] = 12;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xFE;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x06;
s_u8InPack[PROTOCOL_STATE_DAT] = 0xF8;
BuildInPack();
SendInPack();
}
}
else if(s_u16Command == 0xF005)
{
uint8_t i;
uint8_t flag = 1;
for(i = 0;i < 8;i++)
{
if(s_u8InPack[PROTOCOL_STATE_DAT + i] != s_u8Mac[i])
{
flag = 0;
}
}
if(flag == 1)
{
s_u8LocalNet = s_u8InPack[PROTOCOL_STATE_DAT + 8];
s_u8LocalDev = s_u8InPack[PROTOCOL_STATE_DAT + 9];
eeprom_write_byte(EEPROM_HDL_NET,s_u8LocalNet);
eeprom_write_byte(EEPROM_HDL_DEV,s_u8LocalDev);
s_u8InPack[PROTOCOL_STATE_DAT] = 0xF8;
s_u8InPack[PROTOCOL_STATE_LEN] = 12;
s_u8InPack[PROTOCOL_STATE_CMD_H] = 0xF0;
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0x06;
BuildInPack();
SendInPack();
}
}
}
}

第一个函数void RS485_Poll(void)是用来解析数据包的，第二个函数static void CommandHandle(void)是用来处理数据包里面的命令的。
当我用串口工具向mcu发送控制命令的时候，总是第一个命令可以正常响应，随后的命令都不能正常响应。反复检查源代码，没有发现错误。这种代码我编写过无数此了，我想即使首次运行能不能通过，我也能极快找出bug，半小时之内一定能拿下这段代码的调试。好久没有遇到过让人头痛的bug了，我以为这个bug三五分钟也可以搞定。
我带着满满的信心，查看源代码。第一遍，看不出问题原因出自哪里。第二遍，更仔细的看，还是看不出来。第三、第四、第五......还是看不出来。
怎么办呢？一下子有点束手无策，我应该怎么办才能定位bug在哪里？
是不是数据包接收出错了？最有可能出错的就是crc校验吧？带着这个疑问，我注释掉void RS485_Poll(void)函数中对CommandHandle(）函数的调用，并且在CommandHandle(）函数原来的地方插入BSP_ToggleLed()。发现数据包接收没有任何错误。
到这里，又开始觉得束手无策了！
经过许久的煎熬后，不知道什么原因，我认为可以试试把应答数据包的代码注释掉再看看有没有什么线索。想到了就干，立马注释掉tatic void CommandHandle(void)中发送应答数据包对应的代码，再测试发现每次发送命令都可以正常执行了！如获至宝！我想应该离成功不远了，心情瞬间愉快了许多。
再逐行减少注释代码的函数，最后发现问题“位于”下面一行代码：
s_u8InPack[PROTOCOL_STATE_CMD_L] = 0xE1; // 注释掉此行后，可以连续接收命令
根据以往的调试经验，一旦定位了错误在哪一行，改正这一行里面的错误，debug就通过。
可是翻来覆去的看这一行代码，却看不出一丁点的问题来！
调试再次进入胶着状态，漫长的调试让我的大脑极度疲劳，我感觉思维已经停止了，头脑一片空白，就这样束手无策了N久，才想到试试把接收到的数据包原封不动的返回到串口助手，看看能不能发现这行代码是如何影响程序的正确执行的。
想到就干，void RS485_Poll(void)函数中对调用函数CommandHandle(）之后插入如下返回接收到的数据包的代码：

for(i = 0;i < pack_len;i++)
{
Bsp_uart_send_byte(s_u8InPack[i]);
}

发现第一次返回的数据包和串口助手发出的数据包相同，随后返回的数据包的s_u8InPack[PROTOCOL_STATE_CMD_L] 错误。
再次查看，void RS485_Poll(void)函数中写入s_u8InPack[PROTOCOL_STATE_CMD_L]那一行语句：

case PROTOCOL_STATE_CMD_L:
s_u8InPack[index++] |= byte;
s_u16Command |= byte;
s_ProtocolState = PROTOCOL_STATE_DST_NET;
break;

发现代码录入出错了！正确的代码应该是“s_u8InPack[index++] = byte;”但错写成了“s_u8InPack[index++] |= byte；”至此终于找到了问题的“根源”！

|= 与=之间的差别再加上调试过程中一些凑巧，产生了bug位于其他代码段的假象，从而导致了一个初看起来让人无比困惑的bug！为了找出这个bug，我从中午11点开始，午休也不休息，直忙到下午两点。

这真的是挺折磨人的，要不是对编程有浓厚的兴趣，我想肯定无法正确找到原因。这个过程虽然折磨人，但是对困难的挑战，和挑战成功，却让人从中找到莫名的满足感。回顾整个过程，又觉得饶有趣味。

其中有两点很值得深思：如何才能避免类似的录入错误，如何才能更快速的定位类似的错误？

作者： Qeecoda，来源：面包板社区

链接： https://mbb.eet-china.com/blog/uid-me-1099225.html

写原创有奖励！2024面包板原创奖励正在进行中

上一篇：电子产品常见故障现象、原因分析及改进措施（一）
下一篇：实用可靠的干接点消抖滤波算法

PARTNER CONTENT

换一换> 更多>

新蓝牙6.0协议扩展应用范围

Silicon Labs（芯科科技）蓝牙产品经理Parker Dorris 2024-12-16

概伦电子：以开放心态共绘EDA产业新蓝图

概伦电子 2024-12-30

SK海力士开发出适用于AI数据中心的高容量固态硬盘‘PS1012 U.2’

SK海力士 2024-12-18

SK海力士将在CES2025亮相‘全方位面向AI的存储器供应商’的新蓝图

SK海力士 2025-01-03

新一代MCU向着边缘AI和实时控制发展

赵明灿 2024-12-11

文章评论（16条评论）

登录后参与讨论

海州.王 2020-12-31 09:30

很多if（）else（），逻辑上面看得人头疼。

回复

Qeecoda 2020-7-6 08:46

追忆流年寻梦少年: 这种问题是比较烦；
但对于解决问题、发现bug，过程可以优化，一般串口调试的第一步就是原发原收，或者是自发自收，看发送、接收情况，这样子就可以快速定位收端 ...

我也是认为要遵循类似的思路，如果推理分析和凭经验都不能快速定位问题，就要把程序分拆成多个基本环节的组合，充分验证每个环节都是正确的，这样可确保“万无一失“？

回复

追忆流年寻梦少年 2020-6-30 13:34

这种问题是比较烦；
但对于解决问题、发现bug，过程可以优化，一般串口调试的第一步就是原发原收，或者是自发自收，看发送、接收情况，这样子就可以快速定位收端代码异常；然后根据收端的数据，再进一步设计发送0000,1111,1234等，根据接收数据异常分析，再进一步定位代码。
当然，这一般都是事后的总结，发现前面浪费了时间，可以优化的。

回复