main.c

  1. #include <reg52.h> 
  2. #include <function.h>
  3. void main()
  4. {
  5.     // 初始化
  6.     u8 TIMES = 50;    //【选择舵机】的参数——消抖时间
  7.     u8 rudderNum = 0;    //【选择舵机】返回值——舵机号
  8.     u16 gapTime = 0;    //【当前间歇时间】总秒数
  9.     u16 gapTempt = 0;
  10.     u8 gap_min = 0;        //【当前间歇时间】分钟
  11.     u8 gap_s = 0;            //【当前间歇时间】秒
  12.     u8 gapNum = 16;        //【时停按键矩阵】返回值——修改时间
  13.     u8 recard_rudderNum = 0;    // 记录上一次的值
  14.     u8 recard_gap_min = 0;
  15.     u8 recard_gap_s = 0;
  16.     int rotateCount = 0;    //【旋转按键】的按下次数
  17.     u8 parameter1 = 0;    //【数码管显示】参数1
  18.     u8 parameter2 = 0;    //【数码管显示】参数2
  19.     u8 mode_digitalTube = 0;        //【数码管显示】模式
  20.     u8 flickerNum = 2;    //【数码管显示】逻辑切换的闪烁次数
  21.     u8 controlNum = 0;    //敲定【确认键】or【选择键】
  22.     u8 tempRudderNum = 0;
  23.     u8 angle = 0;
  24.     u8 angleSign = 0;
  25.     Init();
  27.     while(1)
  28.     {
  29.         // 选择舵机
  30.         tempRudderNum = SelectKEY_Scan(TIMES);
  31.         if(tempRudderNum != 0)
  32.             rudderNum = tempRudderNum;
  34.         // 时停按键矩阵
  35.         if(rudderNum <= 8 && rudderNum >= 1 && mode_digitalTube == 0)
  36.             gapNum = TimeGapKEY_Scan(TIMES);
  37.         if(gapNum <= 15 && gapNum >= 0)
  38.         {
  39.             gapTempt = gapTime + CountTime(gapNum);
  40.             if( gapTempt >= 0 && gapTempt <= 1800)    // 单次[0, 30]min以内
  41.                 gapTime += CountTime(gapNum);
  42.             // 计算时间
  43.             gap_min = gapTime/60;
  44.             gap_s = gapTime%60;
  45.             // 优先显示分钟逻辑
  46.             if(gap_min >= 10)
  47.                 gap_s /= 10;
  48.         }//if
  50.         // 旋转角度
  51.         if(RotateKEY_Scan(TIMES) == 1 && mode_digitalTube == 1)
  52.         {
  53.             rotateCount++;
  54.             // 计算（参数1-正负）（参数2-十位的数值）的逻辑
  55.             if(rotateCount/7 != 0)
  56.             {
  57.                 rotateCount = -6;
  58.             }
  59.             if(rotateCount < 0)
  60.             {
  61.                 angleSign = 1;
  62.                 angle = -1*rotateCount;
  63.             }
  64.             else
  65.             {
  66.                 angleSign = 0;
  67.                 angle = rotateCount;
  68.             }
  69.         }//if        
  72.         // 确认键 <-> 1 和 复位键 <-> 2
  73.         controlNum = ControlKEY_Scan(TIMES);
  74.         if(controlNum != 0)
  75.         {
  76.             if(mode_digitalTube == 1)
  77.             {
  78.                 mode_digitalTube = 0;
  80.             }
  81.             else 
  82.             {
  83.                 mode_digitalTube = 1;
  84.                 parameter1 = angleSign;
  85.                 parameter2 = angle;
  86.             }
  88.             switch(controlNum)
  89.             {
  90.                 case 1:
  91.                     {
  92.                         //实现数据保存
  93.                         Save_InputData(rudderNum, gapTime,angle, angleSign);
  95.                     }break;
  96.                 case 2:
  97.                     {
  98.                         //实现数据恢复默认
  99.                         Reset_InputData(rudderNum);
  101.                     }break;
  102.             }//switch
  103.         }//if
  105.         if(mode_digitalTube == 0)
  106.         {
  107.             parameter1 = gap_min;
  108.             parameter2 = gap_s;
  109.         }
  110.         if(mode_digitalTube == 1)
  111.         {
  112.             parameter1 = angleSign;
  113.             parameter2 = angle;
  114.         }
  115.         Display_DigitalTube(rudderNum, parameter1, parameter2, mode_digitalTube);            
  118.     }//while
  119. }

function.c

  1. #include <reg52.h> 
  2. #include <function.h> 
  4. u8 messageIndex = 0;    //【保存数据】s数组的索引
  6. u8 MESSAGE[];
  7. void Init()
  8. {
  9.     P2 = 0x00;
  10.     P3 &= 0x0f;
  11.     KEY_RO = 0;
  12.     KEY_OK = 0;
  13. }
  15. u8 code KEY_TABLE[] =
  16. {
  17.     0xEE, 0xDE, 0xBE, 0x7E,
  18.     0xED, 0xDD, 0xBD, 0x7D,
  19.     0xEB, 0xDB, 0xBB, 0x7B,
  20.     0xE7, 0xD7, 0xB7, 0x77
  21. };
  22. u8 code LedChar[10]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
  23. u8 code LedBuff[4]={0xFF, 0xFF, 0xFF, 0xFF};//初始化数码管显示缓存区
  24. // 输入数据的声明
  25. struct servoMotorData inputData[8];
  26. void Delay_ms(u16 x)
  27. {
  28.     u16 i,j;
  29.     if(x==1000)
  30.     {
  31.         for(i=0;i<19601;i++)//延时1s
  32.         {
  33.             for(j=5;j>0;j--);
  34.         }
  35.     }
  36.     else while(x--)for(j=115;j>0;j--);
  37. }
  38. // 扫描选择舵机的按键 返回舵机编号
  39. u8 SelectKEY_Scan(u8 TIMES)
  40. {
  41.     static u8 key_up = 1;
  42.     if(key_up == 1 && (KEY_S0 == 1||KEY_S1 == 1||KEY_S2 == 1||KEY_S3 == 1||KEY_S4 == 1
  43.         ||KEY_S5 == 1 ||KEY_S6== 1||KEY_S7 == 1))
  44.     {
  45.         Delay_ms(TIMES);
  46.         if(KEY_S0 == 1) return 1;
  47.         else if(KEY_S1 == 1) return 2;
  48.         else if(KEY_S2 == 1) return 3;
  49.         else if(KEY_S3 == 1) return 4;
  50.         else if(KEY_S4 == 1) return 5;
  51.         else if(KEY_S5 == 1) return 6;
  52.         else if(KEY_S6 == 1) return 7;
  53.         else if(KEY_S7 == 1) return 8;
  54.     }
  55.     else if(KEY_S0 == 0&&KEY_S1 == 0 &&KEY_S2 == 0&& KEY_S3 == 0 &&KEY_S4 == 0&& 
  56.         KEY_S5 == 0&& KEY_S6== 0&& KEY_S7 == 0) //检测到松开
  57.         key_up = 1;
  58.     return 0;    //无按键按下;
  59. }
  61. // 时停按键矩阵 返回按键编号
  62. u8 TimeGapKEY_Scan(u8 TIMES)
  63. {
  64.     u8 temp, key, key_num;
  65.     static u8 key_up = 1;
  67.     P1 = 0Xf0;        // 行低列高
  68.     // 若高四位不全为1，说明有按键按下
  69.     if((P1&0xf0) != 0Xf0 && key_up == 1)    
  70.     {
  71.         Delay_ms(TIMES);                // 消抖
  72.         key_up = 0;
  73.         if((P1&0xf0) != 0Xf0)
  74.         {
  75.             temp = P1;
  76.             // 列检测
  77.             P1 = 0x0f;
  78.             key = temp|P1;
  79.             for(key_num = 0; key_num < 16; key_num++)
  80.                 if(key == KEY_TABLE[key_num])
  81.                     break;
  83.             return key_num;
  85.             }//if
  86.      }//if
  87.         else if((P1&0xf0) == 0Xf0)
  88.             key_up = 1;
  89.         return 16;     //无键按下，返回16
  90. }
  92. // 根据按键编号间隔计算时间
  93. int CountTime(u8 gapNum)
  94. {
  95.     int addTime = 0;
  97.     // 加权
  98.     switch(gapNum/4)
  99.     {
  100.         case 0: addTime = 60; break;
  101.         case 1: addTime = -60; break;
  102.         case 2: addTime = 1; break;
  103.         case 3: addTime = -1; break;
  104.     }    
  105.     // 赋值
  106.     switch(gapNum%4)
  107.     {
  108.         case 0: addTime *= 20; break;
  109.         case 1: addTime *= 10; break;
  110.         case 2: addTime *= 5; break;
  111.         case 3: addTime *= 1; break;
  112.     }            
  113.     return addTime;
  114. }
  115. // 数码管显示 mode:（0-间隔时间模式）（1-旋转角度模式）
  116. void Display_DigitalTube(u8 rudderNum, u8 parameter1, u8 parameter2, u8 mode_digitalTube)
  117. {
  118.         // 先做舵机选择位的显示，再做其他
  119.         P3 &= 0x0f;        // 先将高四位置0，在修改高四位的值
  120.         P3 |= 0x10;
  121.         P0 = LedChar[rudderNum];
  122.         Delay_ms(1);
  123.     // 间隔时间模式
  124.     if(mode_digitalTube == 0)
  125.     {
  126.         if(parameter1 < 10 && parameter2 < 10)    //a 1.01
  127.         {        
  128.             P3 &= 0x0f;
  129.             P3 |= 0x20;
  130.             P0 = LedChar[parameter1]&0x7f;    //&0x7f —— 点亮小数点
  131.             Delay_ms(1);    
  133.             P3 &= 0x0f;
  134.             P3 |= 0x40;
  135.             P0 = LedChar[0];
  136.             Delay_ms(1);    
  137.         }
  138.         else if(parameter1 < 10 && parameter2 >= 10) //a1.11 
  139.         {        
  140.             P3 &= 0x0f;
  141.             P3 |= 0x20;
  142.             P0 = LedChar[parameter1]&0x7f;
  143.             Delay_ms(1);
  145.             P3 &= 0x0f;
  146.             P3 |= 0x40;
  147.             P0 = LedChar[parameter2/10];
  148.             Delay_ms(1);
  149.         }
  150.         else    //a11.1
  151.         {
  153.             P3 &= 0x0f;
  154.             P3 |= 0x20;
  155.             P0 = LedChar[parameter1/10];
  156.             Delay_ms(1);
  158.             P3 &= 0x0f;
  159.             P3 |= 0x40    ;
  160.             P0 = LedChar[parameter1%10]&0x7f;
  161.             Delay_ms(1);            
  162.         }
  163.         // 秒钟的个位代码相同
  164.         P3 &= 0x0f;
  165.         P3 |= 0x80;
  166.         P0 = LedChar[parameter2%10];
  167.         Delay_ms(1);
  168.     }    
  169.     // 旋转角度模式
  170.     else
  171.     {
  172.         // 正：舵机号 角度 负：舵机号-角度
  173.         P3 &= 0x0f;        
  174.         P3 |= 0x20;
  175.         if(parameter1 == 1)
  176.             P0 = 0xbf; //显示负号
  177.         if(parameter1 == 0)
  178.             P0 = 0xff;
  179.         Delay_ms(1);
  181.         P3 &= 0x0f;        // 显示角度
  182.         P3 |= 0x40;
  183.         P0 = LedChar[parameter2];
  184.         Delay_ms(1);    
  186.         P3 &= 0x0f;        // 显示0
  187.         P3 |= 0x80;
  188.         P0 = LedChar[0];
  189.         Delay_ms(1);
  190.     }
  191. }
  192. // 旋转按键
  193. u8 RotateKEY_Scan(u8 TIMES)
  194. {
  195.     static u8 key_up = 1;
  197.     if(KEY_RO == 1 && key_up == 1)
  198.     {
  199.         Delay_ms(TIMES);
  200.         key_up = 0;
  201.         if(KEY_RO == 1)
  202.             return 1;
  203.     }
  204.     else if(KEY_RO == 0)
  205.         key_up = 1;
  206.     return 0;    //无按键按下;
  207. }
  208. // 数码管闪烁反馈
  209. void Flicker_DigitalTube(u8 rudderNum, u8 parameter1, u8 parameter2, u8 mode_digitalTube, u8 flickerNum)
  210. {
  211.     for(; flickerNum > 0; flickerNum--)
  212.     {
  213.         Display_DigitalTube(rudderNum, parameter1, parameter2, mode_digitalTube);                
  214.         // 四个依次灭掉
  215.         P3 &= 0x0f;
  216.         P3 |= 0x80;
  217.         P0 = 0xff;
  218.         Delay_ms(1);
  219.         P3 &= 0x0f;
  220.         P3 |= 0x40;
  221.         P0 = 0xff;
  222.         Delay_ms(1);
  223.         P3 &= 0x0f;
  224.         P3 |= 0x20;
  225.         P0 = 0xff;
  226.         Delay_ms(1);
  227.         P3 &= 0x0f;
  228.         P3 |= 0x10;
  229.         P0 = 0xff;
  230.         Delay_ms(1);
  231.     }
  232. }
  233. // 确认键和复位键的扫描
  234. u8 ControlKEY_Scan(u8 TIMES)
  235. {
  236.     static u16 times;
  237.     static key_up = 1;
  238.     if((KEY_RE == 1 || KEY_OK == 1) && key_up == 1)
  239.     {
  240.         times++;    //记录进入高电平的时间
  241.         if(times >= TIMES)    //抖动时间已经过去
  242.         {
  243.             times = 0;
  244.             if(KEY_OK == 1) return 1;
  245.             else if(KEY_RE == 1) return 0;
  246.         }
  247.     }
  248.     return 0;    //无按键按下;
  249. }
  250. // 输入数据的保存——核心是依次修改该舵机下的角度和间隔时间
  251. void Save_InputData(u8 rudderNum, u16 gapTime, u8 rotateCount, u8 rotateSign)
  252. {
  253.     u8 num;
  254.     if(rudderNum < 0 || rudderNum >8) return;
  255.     num = rudderNum - 1;
  256.     // 角度和间隔时间的赋值
  257.     if(inputData[num].gapIndex >= 0 && inputData[num].gapIndex < 4)
  258.         inputData[num].gapTime[inputData[num].gapIndex++] = gapTime;
  259.   if(inputData[num].rotateIndex >= 0 && inputData[num].rotateIndex < 3)
  260.     {
  261.         // 此处旋转角度不做乘10处理，再另一个单片机上确定真实数据
  262.         inputData[num].rotateAngle[inputData[num].rotateIndex++] = rotateCount;
  263.         if(rotateSign == 1)
  264.             inputData[num].rotateAngle[inputData[num].rotateIndex] *= -1;    
  265.     }
  266. }
  267. // 数据复位——核心是一一重置该舵机下的角度和间隔时间
  268. void Reset_InputData(u8 rudderNum)
  269. {
  270.     u8 num, i;
  271.     if(rudderNum < 0 || rudderNum >8) return;
  272.     num = rudderNum - 1;    
  273.     // 角度和间隔时间的复位
  274.     for(i = 0; i < inputData[num].gapIndex; i++)
  275.         inputData[num].gapTime[i] = 0;
  276.     for(i = 0; i < inputData[num].rotateIndex; i++)
  277.         inputData[num].rotateAngle[i] = 0;
  278.     inputData[num].gapIndex = 0;
  279.     inputData[num].rotateIndex = 0;
  280. }
  281. void SendData()
  282. {
  283.     // 数据写入数组
  284.     u16 writeIndex = 0;
  285.     u8 structIndex = 0;
  286.     u8 temp_gapIndex = 0;
  287.     u8 temp_rotateIndex = 0;
  288.     u8 servoMotorNum = 'A' - 1;    //表示1号舵机
  289.     u8 i = 0;    
  290.     /* 写入数据格式
  291.     A rotateIndex gapTime[] rotateAngle[] 
  292.     B……
  293.     */
  294.     for(; structIndex < 8; structIndex++)
  295.     {
  296.         // 写入舵机号(A~H)
  297.         servoMotorNum++;
  298.         MESSAGE[writeIndex++] = servoMotorNum;
  299.         // 如果此舵机没有数据可写，跳过
  300.         temp_rotateIndex = inputData[structIndex].rotateIndex;
  301.         if(temp_rotateIndex == 0)
  302.         {            
  303.             structIndex++;
  304.             continue;
  305.         }
  306.         else
  307.         {
  308.             /*
  309.             此舵机无需旋转时，仅保存舵机字母
  310.             若需旋转，第二位表示选择角度个数
  311.             timeNum = rotateNum + 1;
  312.             */
  313.             MESSAGE[writeIndex++] = temp_rotateIndex;
  314.         }
  315.         // 写入时间
  316.         temp_gapIndex = inputData[structIndex].gapIndex;
  317.         for(; temp_gapIndex > 0; temp_gapIndex--)
  318.         {
  319.             i = 0;
  320.             MESSAGE[writeIndex++] = inputData[structIndex].gapTime[i];
  321.             i++;
  322.         }
  323.         // 写入角度
  324.         temp_rotateIndex = inputData[structIndex].rotateIndex;
  325.         for(; temp_rotateIndex > 0; temp_rotateIndex--)
  326.         {
  327.             i = 0;
  328.             MESSAGE[writeIndex++] = inputData[structIndex].rotateAngle[i];
  329.             i++;
  330.         }        
  331.     }    
  332.     // 串口初始化
  333.     SCON = 0x50;//设置串行口工作方式1，接收控制打开
  334.     TMOD |= 0x20;//定时器1设置工作方式2
  335.     TH1 = 0xFD;//设置波特率为9600，数据位8,停止位1，无校验位，晶振频率11.0592M
  336.     TL1 = 0xFD;
  337.     TR1 = 1;//启动定时器1    
  338.     // 发送数据
  339.     messageIndex = 0;
  340.     while(MESSAGE[messageIndex] != '\0')
  341.     {
  342.             SBUF = MESSAGE[messageIndex];//将一个字符放入串行数据缓冲器SBUF
  343.             while(!TI);//等待发送中断标志为1
  344.             TI = 0;//清除发送中断标志
  345.             messageIndex++;//准备下一个字符
  346.     }
  347.     Delay_ms(500);//延时
  348. }

function.h

  1. #ifndef __FUNCTION_H__
  2. #define __FUNCTION_H__  
  3. typedef unsigned char  u8;//对数据类型进行声明定义
  4. typedef unsigned int  u16;
  5. typedef unsigned long u32;
  6. // 数码管段选-直接对P0口操作
  7. // 时停按键矩阵-直接对P1口操作
  8. // 定义与选择舵机按键连接的位
  9. sbit KEY_S0 = P2^0;
  10. sbit KEY_S1 = P2^1;
  11. sbit KEY_S2 = P2^2;
  12. sbit KEY_S3 = P2^3;
  13. sbit KEY_S4 = P2^4;
  14. sbit KEY_S5 = P2^5;
  15. sbit KEY_S6 = P2^6;
  16. sbit KEY_S7 = P2^7;
  18. // 数码管位选+其他按键+数据传输
  19. sbit KEY_RO = P3^2;
  20. sbit KEY_OK = P3^3;
  21. sbit KEY_RE = P3^0;
  22. sbit DigitalTube_w = P3^4;
  23. sbit DigitalTube_x = P3^5;
  24. sbit DigitalTube_y = P3^6;
  25. sbit DigitalTube_z = P3^7;
  26. extern u8 MESSAGE[];
  27. //数码管状态值初始化     
  28. extern u8 code LedChar[10];
  29. extern u8 code LedBuff[4];
  30. //舵机结构体
  31. extern struct servoMotorData inputData[8];
  32. struct servoMotorData
  33. {
  34.     u16 gapTime[4];
  35.     u8 gapIndex;        // 记录舵机间歇时间数组的索引
  36.     char rotateAngle[3]; 
  37.     u8 rotateIndex; // 记录舵机旋转角度数组的索引
  38. };    
  40. // 声明在 function.c 中定义的函数
  41. void Init();
  42. void Delay_ms(u16);
  43. u8 SelectKEY_Scan(u8);
  44. u8 TimeGapKEY_Scan(u8);
  45. int CountTime(u8);
  46. void Display_DigitalTube(u8, u8, u8, u8);
  47. u8 RotateKEY_Scan(u8);
  48. void Flicker_DigitalTube(u8, u8, u8, u8, u8);
  49. u8 ControlKEY_Scan(u8);
  50. void Save_InputData(u8, u16, u8, u8);
  51. void Reset_InputData(u8);
  52. void SendData();
  53. #endif