设为首页收藏本站
首页 > 论坛 > Arduino

[项目]蛋痛创意：为了对抗邪恶的喵星人 精华

wb9999cn | 学徒 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2014-12-1 23:05:14 [显示全部楼层]
19233浏览
29回复
0收藏
查看: 19233|回复: 29

[项目] 蛋痛创意：为了对抗邪恶的喵星人

[复制链接]
    最近，实在是被家里的喵星人欺负的忍无可忍了，决心奋起反击！！
    蛋痛创意：为了对抗邪恶的喵星人图1
    要对抗喵星人的暴政，那当然是请老虎出马！
蛋痛创意：为了对抗邪恶的喵星人图2

    不知道这是什么东东的，请去看《狂怒》---（斑竹，这个不是广告吧？）
    初步的想定是：
    Plan A：用电脑遥控这只车子，实现3个进档，3个退档，3个转向档以及它们的组合而成的48种运动模式，炮塔和炮管可以转动，可以打BB弹驱逐猫咪。硬件部分使用的是成品，主要是实现控制改造。
    Plan B：将老虎接入到家庭WIFI网络，这样，我就可以在安全屋里操作它了，嘿嘿嘿嘿，老虎上加装数传摄像机，包括航向摄像机和并列摄像机，当然，后面那只就是用来开炮滴。
    Plan C：在家里的公共区域安装摄像机，编制视频搜索算法，主动识别喵星人并操作老虎赶来镇压，哈哈哈哈哈哈哈哈......我得意的笑
    目前进度：
    老虎的机械部分已经修理完毕，车体和炮塔都可以动作了。
    切除了老虎体内的电池舱，为改装大电池和控制板做好了准备。
蛋痛创意：为了对抗邪恶的喵星人图3

    uno和298的联调已经完成，目前通过无线串口已经可以发送指令到298的输出了。
蛋痛创意：为了对抗邪恶的喵星人图4

    下一个节点：
    焊接线路，车体组装，预计本周完成。
    一切被喵星人压榨的弟兄，联合起来，发出我们自己的怒吼吧:lol
[size=11.8181819915771px]



回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-2 20:23:24

本帖最后由 wb9999cn 于 2014-12-2 20:25 编辑 
  1. /***************坦克运行部分控制模型*********************

  2. 

  3. ******************车体运行命令列表***********************

  4. 

  5. 命令  前进  后退  左弯  右弯  行进档 转向档 左电机 右电机

  6. 1    接通                    一档          30%   30%

  7. 2    接通                    二档          70%   70%

  8. 3    接通                    三档          100%  100%

  9. 4          接通              一档          -30%  -30%

  10. 5          接通              二档          -70%  -70%

  11. 6          接通              三档          -100% -100%

  12. 7                接通              一档    0%    50%

  13. 8                接通              二档    0%    100%

  14. 9                接通              三档    -50%  50%

  15. 10                     接通        一档    50%   0%

  16. 11                     接通        二档    100%  0%

  17. 12                     接通        三档    50%   -50%

  18. 13  接通    接通    一档  一档  20% 50%

  19. 14  接通    接通    二档  一档  35% 65%

  20. 15  接通    接通    三档  一档  50% 80%

  21. 16  接通    接通    一档  二档  20% 60%

  22. 17  接通    接通    二档  二档  35% 75%

  23. 18  接通    接通    三档  二档  50% 90%

  24. 19  接通    接通    一档  三档  20% 70%

  25. 20  接通    接通    二档  三档  35% 85%

  26. 21  接通    接通    三档  三档  50% 100%

  27. 22  接通      接通  一档  一档  50% 20%

  28. 23  接通      接通  二档  一档  65% 35%

  29. 24  接通      接通  三档  一档  80% 50%

  30. 25  接通      接通  一档  二档  60% 20%

  31. 26  接通      接通  二档  二档  75% 35%

  32. 27  接通      接通  三档  二档  90% 50%

  33. 28  接通      接通  一档  三档  70% 20%

  34. 29  接通      接通  二档  三档  85% 35%

  35. 30  接通      接通  三档  三档  100%  50%

  36. 31    接通  接通    一档  一档  -20%  -50%

  37. 32    接通  接通    二档  一档  -35%  -65%

  38. 33    接通  接通    三档  一档  -50%  -80%

  39. 34    接通  接通    一档  二档  -20%  -60%

  40. 35    接通  接通    二档  二档  -35%  -75%

  41. 36    接通  接通    三档  二档  -50%  -90%

  42. 37    接通  接通    一档  三档  -20%  -70%

  43. 38    接通  接通    二档  三档  -35%  -85%

  44. 39    接通  接通    三档  三档  -50%  -100%

  45. 40    接通    接通  一档  一档  -50%  -20%

  46. 41    接通    接通  二档  一档  -65%  -35%

  47. 42    接通    接通  三档  一档  -80%  -50%

  48. 43    接通    接通  一档  二档  -60%  -20%

  49. 44    接通    接通  二档  二档  -75%  -35%

  50. 45    接通    接通  三档  二档  -90%  -50%

  51. 46    接通    接通  一档  三档  -70%  -20%

  52. 47    接通    接通  二档  三档  -85%  -35%

  53. 48    接通    接通  三档  三档  -100% -50%

  54. 49                              0%    0%    停车

  55. 

  56. ******************炮塔运行命令列表***********************

  57. 

  58. 命令  左转  右转  抬高  降低  转速档 方向机  高低机

  59. 51    接通                    一档  40% 

  60. 52    接通                    二档  70% 

  61. 53    接通                    三档  100%  

  62. 54         接通               一档  -40%  

  63. 55         接通               二档  -70%  

  64. 56         接通               三档  -100% 

  65. 57               接通         一档          40%

  66. 58               接通         二档          70%

  67. 59               接通         三档          100%

  68. 60                     接通   一档          -40%

  69. 61                     接通   二档          -70%

  70. 62                     接通   三档          -100%

  71. 63                                     0      0

  72. 

  73. *****************火炮运行命令列表***********************

  74. 

  75. 命令  开火档 火炮机

  76. 91    一档   0%

  77. 92    二档   50%

  78. 93    三档   100%

  79. 

  80. 

  81. 

  82. ******************变量声明****************************/

  83. 

  84. String comdata = "";   //定义字符串

  85. int mark = 0;               //定义接收数据的标识

  86. int numdata = 0;         //定义串口收到的数值

  87. 

  88. int E1 = 3;   //左驱动电机模拟口

  89. int M1 = 4;   //左驱动电机数字口

  90. 

  91. int E2 = 5;   //右驱动电机模拟口                      

  92. int M2 = 7;   //右驱动电机数字口

  93. 

  94. int E3 = 6;   //炮塔方向电机模拟口

  95. int M3 = 8;   //炮塔方向电机数字口

  96. 

  97. int E4 = 9;   //炮管高低电机模拟口                      

  98. int M4 = 12;  //炮管高低电机数字口

  99. 

  100. int E5 = 10;  //火炮驱动电机模拟口                       

  101. int M5 = 13;  //火炮驱动电机数字口

  102. 

  103. int command;   //定义命令

  104. 

  105. int drive;     //定义驾驶状态要求

  106. int oldDrive;  //定义行驶状态

  107. 

  108. int turret;     //定义炮塔状态要求

  109. int oldTurret;  //定义炮塔状态

  110. 

  111. int cannon;     //定义射击状态要求

  112. int oldCannon;  //定义射击状态

  113. 

  114. /****************程序初始化***********************/

  115. void setup()

  116. {

  117.  pinMode(E1,OUTPUT);   //设置电机驱动接口状态

  118.  pinMode(M1,OUTPUT);  //设置电机驱动接口状态

  119.  pinMode(E2,OUTPUT);  //设置电机驱动接口状态

  120.  pinMode(M2,OUTPUT);  //设置电机驱动接口状态

  121.  pinMode(E3,OUTPUT);  //设置电机驱动接口状态

  122.  pinMode(M3,OUTPUT);  //设置电机驱动接口状态

  123.  pinMode(E4,OUTPUT);  //设置电机驱动接口状态

  124.  pinMode(M4,OUTPUT);  //设置电机驱动接口状态

  125.  pinMode(E5,OUTPUT);  //设置电机驱动接口状态

  126.  pinMode(M5,OUTPUT);  //设置电机驱动接口状态

  127.  Serial.begin(9600);    //打开串口

  128. }

  129. 

  130. /****************主程序***********************/

  131. 

  132. void loop()

  133. {

  134.  /********不断循环检测串口缓存，一个个读入字符串*********/

  135.  

  136.   while (Serial.available() > 0)    //如果有串口数据

  137.   {

  138.    comdata += char(Serial.read());  //读入之后将字符串，串接到comdata上面。

  139.    delay(2);                         //延时

  140.    mark = 1;                         //标记串口读过数据

  141.   }

  142.   

  143.  /*****************将字符串转化为数值和命令**********************/  

  144.  

  145.   if(mark == 1)  //如果接收到数据

  146.   {

  147.      for(int i = 0; i < comdata.length() ; i++)    //以串口读取字符串长度循环，

  148.      {

  149.       numdata = numdata * 10 + (comdata[i] - '0');  //将字符串转化为数值

  150.      }

  151.       command = numdata;   //读取命令

  152.       Serial.print("command=");    //输出命令

  153.       Serial.println(command);      //输出命令内容

  154.       comdata = String("");           //清空comdata  

  155.       numdata = 0;                       //给numdata赋值0 

  156.       mark = 0;                             //给mark赋值0

  157.   }

  158. 

  159. /***************将命令转化为动作*****************/

  160. 

  161.   switch(command)

  162.   {

  163.     

  164.     /***************车体动作*****************/

  165.     

  166.     case 1:    //命令1    

  167.     drive = command;

  168.     if(drive != oldDrive)

  169.     {

  170.       digitalWrite(M1,LOW);   //

  171.       digitalWrite(M2,LOW);    //   

  172.       analogWrite(E1, 63);   //30%

  173.       analogWrite(E2, 63);   //30%

  174.       oldDrive = drive; //刷新行驶状态 

  175.       Serial.print("drive=");

  176.       Serial.println(drive);

  177.     }

  178.     break;

  179.     case 2:

  180.     drive = command;

  181.     if(drive != oldDrive)

  182.     {

  183.       digitalWrite(M1,LOW);   //

  184.       digitalWrite(M2,LOW);    //   

  185.       analogWrite(E1, 127);   //PWM调速

  186.       analogWrite(E2, 127);   //PWM调速

  187.       oldDrive = drive; //刷新行驶状态 

  188.       Serial.print("drive=");

  189.       Serial.println(drive);

  190.     }

  191.     break;

  192.     case 3:

  193.     drive = command;

  194.     if(drive != oldDrive)

  195.     {

  196.       digitalWrite(M1,LOW);   //

  197.       digitalWrite(M2,LOW);    //   

  198.       analogWrite(E1, 254);   //PWM调速

  199.       analogWrite(E2, 254);   //PWM调速

  200.       oldDrive = drive; //刷新行驶状态 

  201.       Serial.print("drive=");

  202.       Serial.println(drive);

  203.     }

  204.     break;

  205.     case 4:

  206.     drive = command;

  207.     if(drive != oldDrive)

  208.     {

  209.       digitalWrite(M1,HIGH);   //

  210.       digitalWrite(M2,HIGH);    //   

  211.       analogWrite(E1, 63);   //PWM调速

  212.       analogWrite(E2, 63);   //PWM调速

  213.       oldDrive = drive; //刷新行驶状态 

  214.       Serial.print("drive=");

  215.       Serial.println(drive);

  216.     }

  217.     break;

  218.     case 5:

  219.     drive = command;

  220.     if(drive != oldDrive)

  221.     {

  222.       digitalWrite(M1,HIGH);   //

  223.       digitalWrite(M2,HIGH);    //   

  224.       analogWrite(E1, 127);   //PWM调速

  225.       analogWrite(E2, 127);   //PWM调速

  226.       oldDrive = drive; //刷新行驶状态 

  227.       Serial.print("drive=");

  228.       Serial.println(drive);

  229.     }

  230.     break;

  231.     case 6:

  232.     drive = command;

  233.     if(drive != oldDrive)

  234.     {

  235.       digitalWrite(M1,HIGH);   //

  236.       digitalWrite(M2,HIGH);    //   

  237.       analogWrite(E1, 254);   //PWM调速

  238.       analogWrite(E2, 254);   //PWM调速

  239.       oldDrive = drive; //刷新行驶状态 

  240.       Serial.print("drive=");

  241.       Serial.println(drive);

  242.     }

  243.     break;

  244.     case 7:

  245.     drive = command;

  246.     if(drive != oldDrive)

  247.     {

  248.       digitalWrite(M1,LOW);   //

  249.       digitalWrite(M2,LOW);    //   

  250.       analogWrite(E1, 0);   //PWM调速

  251.       analogWrite(E2, 127);   //PWM调速

  252.       oldDrive = drive; //刷新行驶状态 

  253.       Serial.print("drive=");

  254.       Serial.println(drive);

  255.     }

  256.     break;

  257.     case 8:

  258.     drive = command;

  259.     if(drive != oldDrive)

  260.     {

  261.       digitalWrite(M1,LOW);   //

  262.       digitalWrite(M2,LOW);    //   

  263.       analogWrite(E1, 0);   //PWM调速

  264.       analogWrite(E2, 254);   //PWM调速

  265.       oldDrive = drive; //刷新行驶状态 

  266.       Serial.print("drive=");

  267.       Serial.println(drive);

  268.     }

  269.     break;

  270.     case 9:

  271.     drive = command;

  272.     if(drive != oldDrive)

  273.     {

  274.       digitalWrite(M1,HIGH);   //

  275.       digitalWrite(M2,LOW);    //   

  276.       analogWrite(E1, 127);   //PWM调速

  277.       analogWrite(E2, 127);   //PWM调速

  278.       oldDrive = drive; //刷新行驶状态 

  279.       Serial.print("drive=");

  280.       Serial.println(drive);

  281.     }

  282.     break;

  283.     case 10:

  284.     drive = command;

  285.     if(drive != oldDrive)

  286.     {

  287.       digitalWrite(M1,LOW);   //

  288.       digitalWrite(M2,LOW);    //   

  289.       analogWrite(E1, 127);   //PWM调速

  290.       analogWrite(E2, 0);   //PWM调速

  291.       oldDrive = drive; //刷新行驶状态 

  292.       Serial.print("drive=");

  293.       Serial.println(drive);

  294.     }

  295.     break;

  296.     case 11:

  297.     drive = command;

  298.     if(drive != oldDrive)

  299.     {

  300.       digitalWrite(M1,LOW);   //

  301.       digitalWrite(M2,LOW);    //   

  302.       analogWrite(E1, 254);   //PWM调速

  303.       analogWrite(E2, 0);   //PWM调速

  304.       oldDrive = drive; //刷新行驶状态 

  305.       Serial.print("drive=");

  306.       Serial.println(drive);

  307.     }

  308.     break;

  309.     case 12:

  310.     drive = command;

  311.     if(drive != oldDrive)

  312.     {

  313.       digitalWrite(M1,LOW);   //

  314.       digitalWrite(M2,HIGH);    //   

  315.       analogWrite(E1, 127);   //PWM调速

  316.       analogWrite(E2, 127);   //PWM调速

  317.       oldDrive = drive; //刷新行驶状态 

  318.       Serial.print("drive=");

  319.       Serial.println(drive);

  320.     }

  321.     break;

  322. 

  323.     case 13:

  324.     drive = command;

  325.     if(drive != oldDrive)

  326.     {

  327.       digitalWrite(M1,LOW);   //

  328.       digitalWrite(M2,LOW);    //   

  329.       analogWrite(E1, 50);   //PWM调速

  330.       analogWrite(E2, 127);   //PWM调速

  331.       oldDrive = drive; //刷新行驶状态 

  332.       Serial.print("drive=");

  333.       Serial.println(drive);

  334.     }

  335.     break;

  336. case 14:

  337.     drive = command;

  338.     if(drive != oldDrive)

  339.     {

  340.       digitalWrite(M1,LOW);   //

  341.       digitalWrite(M2,LOW);    //   

  342.       analogWrite(E1, 89);   //PWM调速

  343.       analogWrite(E2, 165);   //PWM调速

  344.       oldDrive = drive; //刷新行驶状态 

  345.       Serial.print("drive=");

  346.       Serial.println(drive);

  347.     }

  348.     break;

  349. case 15:

  350.     drive = command;

  351.     if(drive != oldDrive)

  352.     {

  353.       digitalWrite(M1,LOW);   //

  354.       digitalWrite(M2,LOW);    //   

  355.       analogWrite(E1, 127);   //PWM调速

  356.       analogWrite(E2, 204);   //PWM调速

  357.       oldDrive = drive; //刷新行驶状态 

  358.       Serial.print("drive=");

  359.       Serial.println(drive);

  360.     }

  361.     break;

  362. case 16:

  363.     drive = command;

  364.     if(drive != oldDrive)

  365.     {

  366.       digitalWrite(M1,LOW);   //

  367.       digitalWrite(M2,LOW);    //   

  368.       analogWrite(E1, 50);   //PWM调速

  369.       analogWrite(E2, 152);   //PWM调速

  370.       oldDrive = drive; //刷新行驶状态 

  371.       Serial.print("drive=");

  372.       Serial.println(drive);

  373.     }

  374.     break;

  375. case 17:

  376.     drive = command;

  377.     if(drive != oldDrive)

  378.     {

  379.       digitalWrite(M1,LOW);   //

  380.       digitalWrite(M2,LOW);    //   

  381.       analogWrite(E1, 89);   //PWM调速

  382.       analogWrite(E2, 192);   //PWM调速

  383.       oldDrive = drive; //刷新行驶状态 

  384.       Serial.print("drive=");

  385.       Serial.println(drive);

  386.     }

  387.     break;

  388. case 18:

  389.     drive = command;

  390.     if(drive != oldDrive)

  391.     {

  392.       digitalWrite(M1,LOW);   //

  393.       digitalWrite(M2,LOW);    //   

  394.       analogWrite(E1, 127);   //PWM调速

  395.       analogWrite(E2, 229);   //PWM调速

  396.       oldDrive = drive; //刷新行驶状态 

  397.       Serial.print("drive=");

  398.       Serial.println(drive);

  399.     }

  400.     break;

  401. case 19:

  402.     drive = command;

  403.     if(drive != oldDrive)

  404.     {

  405.       digitalWrite(M1,LOW);   //

  406.       digitalWrite(M2,LOW);    //   

  407.       analogWrite(E1, 50);   //PWM调速

  408.       analogWrite(E2, 178);   //PWM调速

  409.       oldDrive = drive; //刷新行驶状态 

  410.       Serial.print("drive=");

  411.       Serial.println(drive);

  412.     }

  413.     break;

  414. case 20:

  415.     drive = command;

  416.     if(drive != oldDrive)

  417.     {

  418.       digitalWrite(M1,LOW);   //

  419.       digitalWrite(M2,LOW);    //   

  420.       analogWrite(E1, 89);   //PWM调速

  421.       analogWrite(E2, 216);   //PWM调速

  422.       oldDrive = drive; //刷新行驶状态 

  423.       Serial.print("drive=");

  424.       Serial.println(drive);

  425.     }

  426.     break;

  427. case 21:

  428.     drive = command;

  429.     if(drive != oldDrive)

  430.     {

  431.       digitalWrite(M1,LOW);   //

  432.       digitalWrite(M2,LOW);    //   

  433.       analogWrite(E1, 127);   //PWM调速

  434.       analogWrite(E2, 255);   //PWM调速

  435.       oldDrive = drive; //刷新行驶状态 

  436.       Serial.print("drive=");

  437.       Serial.println(drive);

  438.     }

  439.     break;

  440. case 22:

  441.     drive = command;

  442.     if(drive != oldDrive)

  443.     {

  444.       digitalWrite(M1,LOW);   //

  445.       digitalWrite(M2,LOW);    //   

  446.       analogWrite(E1, 127);   //PWM调速

  447.       analogWrite(E2, 50);   //PWM调速

  448.       oldDrive = drive; //刷新行驶状态 

  449.       Serial.print("drive=");

  450.       Serial.println(drive);

  451.     }

  452.     break;

  453. case 23:

  454.     drive = command;

  455.     if(drive != oldDrive)

  456.     {

  457.       digitalWrite(M1,LOW);   //

  458.       digitalWrite(M2,LOW);    //   

  459.       analogWrite(E1, 165);   //PWM调速

  460.       analogWrite(E2, 89);   //PWM调速

  461.       oldDrive = drive; //刷新行驶状态 

  462.       Serial.print("drive=");

  463.       Serial.println(drive);

  464.     }

  465.     break;

  466. case 24:

  467.     drive = command;

  468.     if(drive != oldDrive)

  469.     {

  470.       digitalWrite(M1,LOW);   //

  471.       digitalWrite(M2,LOW);    //   

  472.       analogWrite(E1, 204);   //PWM调速

  473.       analogWrite(E2, 127);   //PWM调速

  474.       oldDrive = drive; //刷新行驶状态 

  475.       Serial.print("drive=");

  476.       Serial.println(drive);

  477.     }

  478.     break;

  479. case 25:

  480.     drive = command;

  481.     if(drive != oldDrive)

  482.     {

  483.       digitalWrite(M1,LOW);   //

  484.       digitalWrite(M2,LOW);    //   

  485.       analogWrite(E1, 152);   //PWM调速

  486.       analogWrite(E2, 50);   //PWM调速

  487.       oldDrive = drive; //刷新行驶状态 

  488.       Serial.print("drive=");

  489.       Serial.println(drive);

  490.     }

  491.     break;

  492. case 26:

  493.     drive = command;

  494.     if(drive != oldDrive)

  495.     {

  496.       digitalWrite(M1,LOW);   //

  497.       digitalWrite(M2,LOW);    //   

  498.       analogWrite(E1, 192);   //PWM调速

  499.       analogWrite(E2, 89);   //PWM调速

  500.       oldDrive = drive; //刷新行驶状态 

  501.       Serial.print("drive=");

  502.       Serial.println(drive);

  503.     }

  504.     break;

  505. case 27:

  506.     drive = command;

  507.     if(drive != oldDrive)

  508.     {

  509.       digitalWrite(M1,LOW);   //

  510.       digitalWrite(M2,LOW);    //   

  511.       analogWrite(E1, 229);   //PWM调速

  512.       analogWrite(E2, 127);   //PWM调速

  513.       oldDrive = drive; //刷新行驶状态 

  514.       Serial.print("drive=");

  515.       Serial.println(drive);

  516.     }

  517.     break;

  518. case 28:

  519.     drive = command;

  520.     if(drive != oldDrive)

  521.     {

  522.       digitalWrite(M1,LOW);   //

  523.       digitalWrite(M2,LOW);    //   

  524.       analogWrite(E1, 178);   //PWM调速

  525.       analogWrite(E2, 50);   //PWM调速

  526.       oldDrive = drive; //刷新行驶状态 

  527.       Serial.print("drive=");

  528.       Serial.println(drive);

  529.     }

  530.     break;

  531. case 29:

  532.     drive = command;

  533.     if(drive != oldDrive)

  534.     {

  535.       digitalWrite(M1,LOW);   //

  536.       digitalWrite(M2,LOW);    //   

  537.       analogWrite(E1, 216);   //PWM调速

  538.       analogWrite(E2, 89);   //PWM调速

  539.       oldDrive = drive; //刷新行驶状态 

  540.       Serial.print("drive=");

  541.       Serial.println(drive);

  542.     }

  543.     break;

  544. case 30:

  545.     drive = command;

  546.     if(drive != oldDrive)

  547.     {

  548.       digitalWrite(M1,LOW);   //

  549.       digitalWrite(M2,LOW);    //   

  550.       analogWrite(E1, 255);   //PWM调速

  551.       analogWrite(E2, 127);   //PWM调速

  552.       oldDrive = drive; //刷新行驶状态 

  553.       Serial.print("drive=");

  554.       Serial.println(drive);

  555.     }

  556.     break;

  557. case 31:

  558.     drive = command;

  559.     if(drive != oldDrive)

  560.     {

  561.       digitalWrite(M1,HIGH);   //

  562.       digitalWrite(M2,HIGH);    //   

  563.       analogWrite(E1, 50);   //PWM调速

  564.       analogWrite(E2, 127);   //PWM调速

  565.       oldDrive = drive; //刷新行驶状态 

  566.       Serial.print("drive=");

  567.       Serial.println(drive);

  568.     }

  569.     break;

  570. case 32:

  571.     drive = command;

  572.     if(drive != oldDrive)

  573.     {

  574.       digitalWrite(M1,HIGH);   //

  575.       digitalWrite(M2,HIGH);    //   

  576.       analogWrite(E1, 89);   //PWM调速

  577.       analogWrite(E2, 165);   //PWM调速

  578.       oldDrive = drive; //刷新行驶状态 

  579.       Serial.print("drive=");

  580.       Serial.println(drive);

  581.     }

  582.     break;

  583. case 33:

  584.     drive = command;

  585.     if(drive != oldDrive)

  586.     {

  587.       digitalWrite(M1,HIGH);   //

  588.       digitalWrite(M2,HIGH);    //   

  589.       analogWrite(E1, 127);   //PWM调速

  590.       analogWrite(E2, 204);   //PWM调速

  591.       oldDrive = drive; //刷新行驶状态 

  592.       Serial.print("drive=");

  593.       Serial.println(drive);

  594.     }

  595.     break;

  596. case 34:

  597.     drive = command;

  598.     if(drive != oldDrive)

  599.     {

  600.       digitalWrite(M1,HIGH);   //

  601.       digitalWrite(M2,HIGH);    //   

  602.       analogWrite(E1, 50);   //PWM调速

  603.       analogWrite(E2, 152);   //PWM调速

  604.       oldDrive = drive; //刷新行驶状态 

  605.       Serial.print("drive=");

  606.       Serial.println(drive);

  607.     }

  608.     break;

  609. case 35:

  610.     drive = command;

  611.     if(drive != oldDrive)

  612.     {

  613.       digitalWrite(M1,HIGH);   //

  614.       digitalWrite(M2,HIGH);    //   

  615.       analogWrite(E1, 89);   //PWM调速

  616.       analogWrite(E2, 192);   //PWM调速

  617.       oldDrive = drive; //刷新行驶状态 

  618.       Serial.print("drive=");

  619.       Serial.println(drive);

  620.     }

  621.     break;

  622. case 36:

  623.     drive = command;

  624.     if(drive != oldDrive)

  625.     {

  626.       digitalWrite(M1,HIGH);   //

  627.       digitalWrite(M2,HIGH);    //   

  628.       analogWrite(E1, 127);   //PWM调速

  629.       analogWrite(E2, 229);   //PWM调速

  630.       oldDrive = drive; //刷新行驶状态 

  631.       Serial.print("drive=");

  632.       Serial.println(drive);

  633.     }

  634.     break;

  635. case 37:

  636.     drive = command;

  637.     if(drive != oldDrive)

  638.     {

  639.       digitalWrite(M1,HIGH);   //

  640.       digitalWrite(M2,HIGH);    //   

  641.       analogWrite(E1, 50);   //PWM调速

  642.       analogWrite(E2, 178);   //PWM调速

  643.       oldDrive = drive; //刷新行驶状态 

  644.       Serial.print("drive=");

  645.       Serial.println(drive);

  646.     }

  647.     break;

  648. case 38:

  649.     drive = command;

  650.     if(drive != oldDrive)

  651.     {

  652.       digitalWrite(M1,HIGH);   //

  653.       digitalWrite(M2,HIGH);    //   

  654.       analogWrite(E1, 89);   //PWM调速

  655.       analogWrite(E2, 216);   //PWM调速

  656.       oldDrive = drive; //刷新行驶状态 

  657.       Serial.print("drive=");

  658.       Serial.println(drive);

  659.     }

  660.     break;

  661. case 39:

  662.     drive = command;

  663.     if(drive != oldDrive)

  664.     {

  665.       digitalWrite(M1,HIGH);   //

  666.       digitalWrite(M2,HIGH);    //   

  667.       analogWrite(E1, 127);   //PWM调速

  668.       analogWrite(E2, 255);   //PWM调速

  669.       oldDrive = drive; //刷新行驶状态 

  670.       Serial.print("drive=");

  671.       Serial.println(drive);

  672.     }

  673.     break;

  674. case 40:

  675.     drive = command;

  676.     if(drive != oldDrive)

  677.     {

  678.       digitalWrite(M1,HIGH);   //

  679.       digitalWrite(M2,HIGH);    //   

  680.       analogWrite(E1, 127);   //PWM调速

  681.       analogWrite(E2, 50);   //PWM调速

  682.       oldDrive = drive; //刷新行驶状态 

  683.       Serial.print("drive=");

  684.       Serial.println(drive);

  685.     }

  686.     break;

  687. case 41:

  688.     drive = command;

  689.     if(drive != oldDrive)

  690.     {

  691.       digitalWrite(M1,HIGH);   //

  692.       digitalWrite(M2,HIGH);    //   

  693.       analogWrite(E1, 165);   //PWM调速

  694.       analogWrite(E2, 89);   //PWM调速

  695.       oldDrive = drive; //刷新行驶状态 

  696.       Serial.print("drive=");

  697.       Serial.println(drive);

  698.     }

  699.     break;

  700. case 42:

  701.     drive = command;

  702.     if(drive != oldDrive)

  703.     {

  704.       digitalWrite(M1,HIGH);   //

  705.       digitalWrite(M2,HIGH);    //   

  706.       analogWrite(E1, 204);   //PWM调速

  707.       analogWrite(E2, 127);   //PWM调速

  708.       oldDrive = drive; //刷新行驶状态 

  709.       Serial.print("drive=");

  710.       Serial.println(drive);

  711.     }

  712.     break;

  713. case 43:

  714.     drive = command;

  715.     if(drive != oldDrive)

  716.     {

  717.       digitalWrite(M1,HIGH);   //

  718.       digitalWrite(M2,HIGH);    //   

  719.       analogWrite(E1, 152);   //PWM调速

  720.       analogWrite(E2, 50);   //PWM调速

  721.       oldDrive = drive; //刷新行驶状态 

  722.       Serial.print("drive=");

  723.       Serial.println(drive);

  724.     }

  725.     break;

  726. case 44:

  727.     drive = command;

  728.     if(drive != oldDrive)

  729.     {

  730.       digitalWrite(M1,HIGH);   //

  731.       digitalWrite(M2,HIGH);    //   

  732.       analogWrite(E1, 192);   //PWM调速

  733.       analogWrite(E2, 89);   //PWM调速

  734.       oldDrive = drive; //刷新行驶状态 

  735.       Serial.print("drive=");

  736.       Serial.println(drive);

  737.     }

  738.     break;

  739. case 45:

  740.     drive = command;

  741.     if(drive != oldDrive)

  742.     {

  743.       digitalWrite(M1,HIGH);   //

  744.       digitalWrite(M2,HIGH);    //   

  745.       analogWrite(E1, 229);   //PWM调速

  746.       analogWrite(E2, 127);   //PWM调速

  747.       oldDrive = drive; //刷新行驶状态 

  748.       Serial.print("drive=");

  749.       Serial.println(drive);

  750.     }

  751.     break;

  752. case 46:

  753.     drive = command;

  754.     if(drive != oldDrive)

  755.     {

  756.       digitalWrite(M1,HIGH);   //

  757.       digitalWrite(M2,HIGH);    //   

  758.       analogWrite(E1, 178);   //PWM调速

  759.       analogWrite(E2, 50);   //PWM调速

  760.       oldDrive = drive; //刷新行驶状态 

  761.       Serial.print("drive=");

  762.       Serial.println(drive);

  763.     }

  764.     break;

  765. case 47:

  766.     drive = command;

  767.     if(drive != oldDrive)

  768.     {

  769.       digitalWrite(M1,HIGH);   //

  770.       digitalWrite(M2,HIGH);    //   

  771.       analogWrite(E1, 216);   //PWM调速

  772.       analogWrite(E2, 89);   //PWM调速

  773.       oldDrive = drive; //刷新行驶状态 

  774.       Serial.print("drive=");

  775.       Serial.println(drive);

  776.     }

  777.     break;

  778. case 48:

  779.     drive = command;

  780.     if(drive != oldDrive)

  781.     {

  782.       digitalWrite(M1,HIGH);   //

  783.       digitalWrite(M2,HIGH);    //   

  784.       analogWrite(E1, 255);   //PWM调速

  785.       analogWrite(E2, 127);   //PWM调速

  786.       oldDrive = drive; //刷新行驶状态 

  787.       Serial.print("drive=");

  788.       Serial.println(drive);

  789.     }

  790.     break;

  791.  /*******??????????????????????????????????***********/   

  792.     case 49:

  793.     drive = command;

  794.     if(drive != oldDrive)

  795.     {

  796.       digitalWrite(M1,LOW);   //

  797.       digitalWrite(M2,LOW);    //   

  798.       analogWrite(E1, 0);   //PWM调速

  799.       analogWrite(E2, 0);   //PWM调速

  800.       oldDrive = drive; //刷新行驶状态 

  801.       Serial.print("drive=");

  802.       Serial.println(drive);

  803.     }

  804.     break;

  805.     

  806.     /***************炮塔动作*******************/

  807.     

  808.     case 51:

  809.     turret = command;

  810.     if(turret != oldTurret)

  811.     {

  812.       digitalWrite(M3,LOW);   //

  813.       analogWrite(E3, 63);   //PWM调速

  814.       oldTurret = turret; //刷新行驶状态 

  815.       Serial.print("turret=");

  816.       Serial.println(turret);

  817.     }

  818.     break;

  819.     case 52:

  820.     turret = command;

  821.     if(turret != oldTurret)

  822.     {

  823.       digitalWrite(M3,LOW);   //

  824.       analogWrite(E3, 127);   //PWM调速

  825.       oldTurret = turret; //刷新行驶状态 

  826.       Serial.print("turret=");

  827.       Serial.println(turret);

  828.     }

  829.     break;

  830.     case 53:

  831.     turret = command;

  832.     if(turret != oldTurret)

  833.     {

  834.       digitalWrite(M3,LOW);   //

  835.       analogWrite(E3, 254);   //PWM调速

  836.       oldTurret = turret; //刷新行驶状态 

  837.       Serial.print("turret=");

  838.       Serial.println(turret);

  839.     }

  840.     break;

  841.     case 54:

  842.     turret = command;

  843.     if(turret != oldTurret)

  844.     {

  845.       digitalWrite(M3,HIGH);   //

  846.       analogWrite(E3, 63);   //PWM调速

  847.       oldTurret = turret; //刷新行驶状态 

  848.       Serial.print("turret=");

  849.       Serial.println(turret);

  850.     }

  851.     break;

  852.     case 55:

  853.     turret = command;

  854.     if(turret != oldTurret)

  855.     {

  856.       digitalWrite(M3,HIGH);   //

  857.       analogWrite(E3, 127);   //PWM调速

  858.       oldTurret = turret; //刷新行驶状态 

  859.       Serial.print("turret=");

  860.       Serial.println(turret);

  861.     }

  862.     break;

  863.     case 56:

  864.     turret = command;

  865.     if(turret != oldTurret)

  866.     {

  867.       digitalWrite(M3,HIGH);   //

  868.       analogWrite(E3, 254);   //PWM调速

  869.       oldTurret = turret; //刷新行驶状态 

  870.       Serial.print("turret=");

  871.       Serial.println(turret);

  872.     }

  873.     break;

  874.     case 57:

  875.     turret = command;

  876.     if(turret != oldTurret)

  877.     {

  878.       digitalWrite(M4,LOW);   //

  879.       analogWrite(E4, 63);   //PWM调速

  880.       oldTurret = turret; //刷新行驶状态 

  881.       Serial.print("turret=");

  882.       Serial.println(turret);

  883.     }

  884.     break;

  885.     case 58:

  886.     turret = command;

  887.     if(turret != oldTurret)

  888.     {

  889.       digitalWrite(M4,LOW);   //

  890.       analogWrite(E4, 127);   //PWM调速

  891.       oldTurret = turret; //刷新行驶状态 

  892.       Serial.print("turret=");

  893.       Serial.println(turret);

  894.     }

  895.     break;

  896.     case 59:

  897.     turret = command;

  898.     if(turret != oldTurret)

  899.     {

  900.       digitalWrite(M4,LOW);   //

  901.       analogWrite(E4, 254);   //PWM调速

  902.       oldTurret = turret; //刷新行驶状态 

  903.       Serial.print("turret=");

  904.       Serial.println(turret);

  905.     }

  906.     break;

  907.     case 60:

  908.     turret = command;

  909.     if(turret != oldTurret)

  910.     {

  911.       digitalWrite(M4,HIGH);   //

  912.       analogWrite(E4, 63);   //PWM调速

  913.       oldTurret = turret; //刷新行驶状态 

  914.       Serial.print("turret=");

  915.       Serial.println(turret);

  916.     }

  917.     break;

  918.     case 61:

  919.     turret = command;

  920.     if(turret != oldTurret)

  921.     {

  922.       digitalWrite(M4,HIGH);   //

  923.       analogWrite(E4, 127);   //PWM调速

  924.       oldTurret = turret; //刷新行驶状态 

  925.       Serial.print("turret=");

  926.       Serial.println(turret);

  927.     }

  928.     break;

  929.     case 62:

  930.     turret = command;

  931.     if(turret != oldTurret)

  932.     {

  933.       digitalWrite(M4,HIGH);   //

  934.       analogWrite(E4, 254);   //PWM调速

  935.       oldTurret = turret; //刷新行驶状态 

  936.       Serial.print("turret=");

  937.       Serial.println(turret);

  938.     }

  939.     break;

  940.     case 63:

  941.     turret = command;

  942.     if(turret != oldTurret)

  943.     {

  944.       digitalWrite(M3,LOW);   //

  945.       digitalWrite(M4,LOW);   //

  946.       analogWrite(E3, 0);   //PWM调速

  947.       analogWrite(E4, 0);   //PWM调速

  948.       oldTurret = turret; //刷新行驶状态 

  949.       Serial.print("turret=");

  950.       Serial.println(turret);

  951.     }

  952.     break;

  953.     

  954.        /***************射击动作*******************/

  955.     case 91:

  956.     cannon = command;

  957.     if(cannon != oldCannon)

  958.     {

  959.       digitalWrite(M5,LOW);   //

  960.       analogWrite(E5, 0);   //PWM调速

  961.       oldCannon = cannon; //刷新行驶状态 

  962.       Serial.print("cannon=");

  963.       Serial.println(cannon);

  964.     }

  965.     break;

  966.     case 92:

  967.     cannon = command;

  968.     if(cannon != oldCannon)

  969.     {

  970.       digitalWrite(M5,LOW);   //

  971.       analogWrite(E5, 127);   //PWM调速

  972.       oldCannon = cannon; //刷新行驶状态 

  973.       Serial.print("cannon=");

  974.       Serial.println(cannon);

  975.     }

  976.     break;

  977.     case 93:

  978.     cannon = command;

  979.     if(cannon != oldCannon)

  980.     {

  981.       digitalWrite(M5,LOW);   //

  982.       analogWrite(E5, 254);   //PWM调速

  983.       oldCannon = cannon; //刷新行驶状态 

  984.       Serial.print("cannon=");

  985.       Serial.println(cannon);

  986.     }

  987.     break;

  988.   }

  989. }

复制代码

车体行动部分的代码基本上写完了，不过，由于第一次写Arduino的程序，因此感觉非常累赘，估计有很多技巧和函数可以大幅度精简代码。先不管了，还是发上来供大家批判，如果有大神能指点一下精简代码的思路，不胜感激。
回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-2 20:32:11

喵王 发表于 2014-12-2 10:21
视频传输你打算怎么实现？而且是两路视频传输哦。

是哦传输全部用WIFI。

实际上，虽然目前我用的是APC220数传，但是最终我也会将坦克的控制部分放进WIFI网络的。我要实现的目标是非接触战争啊:lol

我在关上门的主卧室里面操作坦克去与占领了客厅沙发的喵星人战斗。

最终的目标是在客厅安装摄像机，通过动态目标分离的方式，直接引导坦克作战，可以完全无人操作。当然，还是要人在回路中，以防失控。这一步-----可以理解，还很远。
回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-4 23:48:06

本帖最后由 wb9999cn 于 2014-12-4 23:50 编辑

进度汇报：

    （1）坦克底甲板制作完成，材料为洞洞板，覆盖了整个坦克底部，目的是增加底板强度，bing 电池和电路板提供安装支撑。

    （2）电池和电路板固定方式已经确定，并进行了假组合，以便确认没有与坦克炮塔和火炮之间的干涉可能。原来考虑的三块电机驱动板层叠的方式放弃了，高度不够，只好在电池上面加了一层电路板。

蛋痛创意：为了对抗邪恶的喵星人图1


    下步工作安排：周末完成焊接。:victory:
回复

使用道具 举报

精彩评论(29)

Eric  初级技神

发表于 2014-12-1 23:13:57

哈哈哈,坦克相当给力啊~让喵星人更惧怕的是在你的坦克上面加一个MP3模块,然后模拟各种狗叫,哈哈哈,喵星人一定会毛孔数起来滴,哈哈哈哈
回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-1 23:20:20

俺家有汪星人的，也是喵星人的欺压对象啊.......
回复

使用道具 举报

Ricky  NPC

发表于 2014-12-2 00:09:16

有个建议，在tank上装个激光笔，然后能自由转动，照到地上，保证猫星人抓狂。。完全抓狂。哈哈
回复

使用道具 举报

michael  中级技师

发表于 2014-12-2 09:37:57

可以做个左右摇晃的东西，这样就可以引诱喵星人过来，然后再吓尿他
回复

使用道具 举报

喵王  初级技匠

发表于 2014-12-2 10:21:56

视频传输你打算怎么实现？而且是两路视频传输哦。
回复

使用道具 举报

Rockets  NPC

发表于 2014-12-2 15:34:18

用wifi摄像头实现视频传输。
回复

使用道具 举报

冰渕  中级技师

发表于 2014-12-2 17:24:31

时代变了，喵星人称霸，汪星人直接被鄙视了:L:L:L
回复

使用道具 举报

Youyou  初级技匠

发表于 2014-12-2 22:53:54

楼主，喵星人的左眼已经发绿，耳朵竖的很直，明显是要和你挑战了。
回复

使用道具 举报

heinau  高级技匠

发表于 2014-12-3 10:41:34

哈哈哈哈哈哈笑尿
喵星人这么萌你们不要黑它~~~
楼主家居然还有汪星人，每天的生活一定很嗨森（鸡飞狗跳神马的

如果能在坦克上装摄像头，第一视角看一定很销魂哈哈哈~
回复

使用道具 举报

林子大了  中级技师

发表于 2014-12-4 14:08:50

这个。。。。。
回复

使用道具 举报

mcholen  高级技师

发表于 2014-12-4 17:33:34

吓猫焉用坦克...
回复

使用道具 举报

fangrong  中级技师

发表于 2014-12-4 23:41:18

楼主，猫需要御的。要是我这的猫，你的坦克直接被啃碎了
回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-4 23:52:09

fangrong 发表于 2014-12-4 23:41
楼主，猫需要御的。要是我这的猫，你的坦克直接被啃碎了

这个......咱暂时不考虑与山猫、豹猫之类的喵星人中的战斗猫作战的问题。:L
回复

使用道具 举报

wanglei830205  初级技师

发表于 2014-12-7 10:06:04

这个坦克确实挺有创意的，楼主的武器装备看来花了不少大洋啊
回复

使用道具 举报

wb9999cn  学徒
 楼主|

发表于 2014-12-7 22:30:13

最新进度：车体已经全部搞定，目前已经可以通过串口调试器来操作它了。

发现的最新问题是电动机扭矩不够，低档下几乎没有行动能力。是不是要换电机了....琢磨算计口袋中的银票

测试战斗表明，猫咪对这个新出现的地面不明爬行物颇有些恐惧.....尤其是在它发射BB弹的时候，嘿嘿，一溜烟跑回自己小窝里躲起来了。
回复

使用道具 举报

Ash  管理员

发表于 2014-12-9 17:04:26

wb9999cn 发表于 2014-12-7 22:30
最新进度：车体已经全部搞定，目前已经可以通过串口调试器来操作它了。

发现的最新问题是电动机扭矩不够， ...

你让可怜的喵星人幼小的心灵受到了惊吓啊 从此抑郁了怎么办..
回复

使用道具 举报

kevinjeng  见习技师

发表于 2014-12-9 20:40:07

这工程量不小啊
回复

使用道具 举报

12下一页
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4

© 2013-2024 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail