[关闭]
@rg070836rg 2017-05-09T10:18:31.000000Z 字数 7568 阅读 1180

同步文档

同步

http://www.linuxidc.com/Linux/2016-05/131096.htm

  1. {   "extensionName": "Demo2",
  2.     "description": "A Demo Extension for Arduino",
  3.     "version": "1.1",
  4.     "author": "Seeed Studio(support@seed.com)",
  5.     "homepage": "seeed.com",
  6.     "sort":0,
  7.     "javascriptURL":"js/demo.js",
  8.   "firmware":"1.0",
  9.   "extensionPort":0,
  10.     "blockSpecs": [
  11.         ["h","Demo Program","runArduino"],
  12.         [
  13.             "w",
  14.             "digitalWrite( %n , %d.digital )",
  15.             "digitalWrite",
  16.             "13",
  17.             "HIGH",
  18.             {
  19.                 "setup":"pinMode({0},OUTPUT); \n",
  20.                 "inc":"",
  21.                 "def":"",
  22.                 "work":"digitalWrite({0},{1});\n",
  23.                 "loop":""
  24.             }
  25.         ],
  26.         [
  27.             "w",
  28.             "blink",
  29.             "blink",
  30.             {
  31.                 "setup":"",
  32.                 "inc":"#include \"demo.h\"",
  33.                 "def":"DemoClass demo; \n",
  34.                 "work":"demo.blink(); \n",
  35.                 "loop":""
  36.             }
  37.         ]
  38.     ],
  39.     "menus": {
  40.         "digital":["HIGH","LOW"]
  41.     },
  42.     "values":{
  43.         "HIGH":1,
  44.         "LOW":0
  45.     },
  46.     "translators":{
  47.         "zh_CN":{
  48.             "Demo Program":"演示程序",
  49.             "HIGH":"高电平",
  50.             "LOW":"低电平",
  51.             "digitalWrite( %n , %d.digital )":"数字口输出( %n ,%d.digital )",
  52.       "blink":"闪烁"
  53.         }
  54.     }
  55. }
  1. /*
  2.    This program is for this robot http://www.thingiverse.com/thing:1912377   
  3. */
  4. #include <Arduino.h>
  5. #include <Servo.h>
  6. #include "Oscillator.h"
  7. #include <SoftwareSerial.h>
  10. //comment out below line if you don't use HC_SR04 sensor
  11. #define __HC_SR04__
  13. #ifdef __HC_SR04__
  14. #define HC_SR04_TRIGGER_PIN 10
  15. #define HC_SR04_ECHO_PIN 11
  16. #define MIN_DISTANCE 10
  17. #define MAX_DISTANCE MIN_DISTANCE + 10
  18. #endif
  20. #define SERVO_START_PIN 2
  21. #define TIMEOUT 1000
  23. #define FORWARD 'f'
  24. #define LEFT 'l'
  25. #define STAND 's'
  26. #define RIGHT 'r'
  27. #define BACKWARD 'b'
  28. #define RIGHT_FRONT 'c'
  31. // servo ID
  32. #define FRONT_RIGHT_0 0
  33. #define FRONT_RIGHT_1 1
  34. #define BACK_RIGHT_0  2
  35. #define BACK_RIGHT_1  3
  36. #define BACK_LEFT_0   4
  37. #define BACK_LEFT_1   5
  38. #define FRONT_LEFT_0  6
  39. #define FRONT_LEFT_1  7
  41. typedef struct {
  42.   int index;
  43.   int degree;
  44.   int delay;
  45. } angle_t;
  47. angle_t *forward = (angle_t []) {
  48.   {FRONT_RIGHT_0, 140, 0},
  49.   {FRONT_RIGHT_1, 60, 0},
  50.   {BACK_RIGHT_0, 40, 0},
  51.   {BACK_RIGHT_1, 90, 0},
  52.   {BACK_LEFT_0, 150, 0},
  53.   {BACK_LEFT_1, 60, 0},
  54.   {FRONT_LEFT_0, 55, 0},
  55.   {FRONT_LEFT_1, 90, 200},
  56.   {BACK_LEFT_0, 80, 0},
  57.   {FRONT_LEFT_0, 100, 200},
  58.   {FRONT_RIGHT_1, 90, 0},
  59.   {BACK_RIGHT_1, 120, 0},
  60.   {BACK_LEFT_1, 110, 0},
  61.   {FRONT_LEFT_1, 120, 200},
  62.   {FRONT_RIGHT_0, 80, 0},
  63.   {BACK_RIGHT_0, 100, 0},
  64.   {BACK_RIGHT_1, 90, 0},
  65.   {BACK_LEFT_0, 125, 0},
  66.   {FRONT_LEFT_0, 55, 200},
  67.   { -1, -1, -1}
  68. };
  70. angle_t *backward = (angle_t []) {
  71.   {BACK_LEFT_0, 140, 0},
  72.   {BACK_LEFT_1, 60, 0},
  73.   {FRONT_LEFT_0, 40, 0},
  74.   {FRONT_LEFT_1, 90, 0},
  75.   {FRONT_RIGHT_0, 150, 0},
  76.   {FRONT_RIGHT_1, 60, 0},
  77.   {BACK_RIGHT_0, 55, 0},
  78.   {BACK_RIGHT_1, 90, 200},
  79.   {FRONT_RIGHT_0, 80, 0},
  80.   {BACK_RIGHT_0, 100, 200},
  81.   {BACK_LEFT_1, 90, 0},
  82.   {FRONT_LEFT_1, 120, 0},
  83.   {FRONT_RIGHT_1, 110, 0},
  84.   {BACK_RIGHT_1, 120, 200},
  85.   {BACK_LEFT_0, 80, 0},
  86.   {FRONT_LEFT_0, 100, 0},
  87.   {FRONT_LEFT_1, 90, 0},
  88.   {FRONT_RIGHT_0, 125, 0},
  89.   {BACK_RIGHT_0, 55, 200},
  90.   { -1, -1, -1}
  91. };
  93. #define LEG_UP 50
  94. #define LEG_DN 90
  95. #define LEG_CLOSE 50  // move inward
  96. #define LEG_OPEN 150  // move outward
  97. #define LEG_TURN 125
  98. #define INV(x) (180-x)
  100. angle_t *right = (angle_t []) {
  101.   {FRONT_RIGHT_1, LEG_UP, 0},
  102.   {BACK_LEFT_1,   LEG_UP, 100},
  103.   {FRONT_RIGHT_0, LEG_CLOSE, 0},
  104.   {BACK_LEFT_0,   LEG_CLOSE, 100},
  105.   //
  106.   {FRONT_RIGHT_1, LEG_DN, 0},
  107.   {BACK_LEFT_1,   LEG_DN, 100},
  108.   {BACK_RIGHT_1, LEG_OPEN, 0},
  109.   {FRONT_LEFT_1, LEG_OPEN, 100},
  110.   //
  111.   {FRONT_RIGHT_0, LEG_TURN,  0},
  112.   {BACK_LEFT_0,   LEG_TURN,  100},
  113.   {BACK_RIGHT_1,  LEG_DN,   0},
  114.   {FRONT_LEFT_1,  LEG_DN,   100},
  115.   { -1, -1, -1}
  116. };
  118. angle_t *left = (angle_t []) {
  119.   {FRONT_LEFT_1, INV(LEG_UP), 0},
  120.   {BACK_RIGHT_1, INV(LEG_UP), 100},
  121.   {FRONT_LEFT_0, INV(LEG_CLOSE), 0},
  122.   {BACK_RIGHT_0, INV(LEG_CLOSE), 100},
  123.   //
  124.   {FRONT_LEFT_1, INV(LEG_DN), 0},
  125.   {BACK_RIGHT_1, INV(LEG_DN), 100},
  126.   {BACK_LEFT_1, INV(LEG_OPEN), 0},
  127.   {FRONT_RIGHT_1, INV(LEG_OPEN), 100},
  128.   //
  129.   {FRONT_LEFT_0, INV(LEG_TURN),  0},
  130.   {BACK_RIGHT_0, INV(LEG_TURN),  100},
  131.   {BACK_LEFT_1,  INV(LEG_DN),   0},
  132.   {FRONT_RIGHT_1, INV(LEG_DN),   100},
  133.   { -1, -1, -1}
  134. };
  138. angle_t *stand = (angle_t []) {
  139.   {FRONT_RIGHT_0, 125, 0},
  140.   {FRONT_RIGHT_1, 90, 0},
  141.   {BACK_RIGHT_0, 55, 0},
  142.   {BACK_RIGHT_1, 90, 0},
  143.   {BACK_LEFT_0, 125, 0},
  144.   {BACK_LEFT_1, 90, 0},
  145.   {FRONT_LEFT_0, 55, 0},
  146.   {FRONT_LEFT_1, 90, 150},
  147.   { -1, -1, -1}
  148. };
  151. char movements[] = {FORWARD, LEFT, STAND, RIGHT, BACKWARD};
  152. Oscillator servos[8];
  153. unsigned long cur_time, prev_time;
  154. char action;
  155. char prev_action;
  156. boolean auto_mode = false;
  158. SoftwareSerial mySerial(12, 13); // RX, TX
  160. void locomotion(angle_t angles[]);
  162. void setup() {
  163.   int i;
  164.   for (i = 0; i < 8; i++) {
  165.     servos[i].attach(i + SERVO_START_PIN);
  166.   }
  167.   Serial.begin(57600);
  168.   Serial.println("Shit Type AT commands!");
  170.   // The HC-06 defaults to 9600 according to the datasheet.
  171.   mySerial.begin(9600);
  173. #ifdef __HC_SR04__
  174.   pinMode(HC_SR04_TRIGGER_PIN, OUTPUT);
  175.   pinMode(HC_SR04_ECHO_PIN, INPUT);
  176. #endif
  177.   //
  178. //  pinMode(MODE_PIN, INPUT);
  179.   // auto_mode = digitalRead(MODE_PIN);
  180.   if (auto_mode) {
  181.     analogWrite(A0, 0);
  182.     prev_action = action = FORWARD;
  183.   } else {
  184.     prev_action = action = STAND;
  185.     analogWrite(A0, 128);
  186.   }
  187.   //
  188.   locomotion(stand);
  189.   randomSeed(analogRead(A7));
  190.   cur_time = prev_time = millis();
  191.   delay(3000);
  192. }
  193. void checkAutoMode() {
  194.   if (mySerial.available () > 0) {
  195.     action = mySerial.read ();
  196.     if (action==RIGHT_FRONT) {
  197.       auto_mode = !auto_mode;
  198.     }
  199.   }
  200. }
  201. void do_action() {
  202.     long receivedNumber = 0;
  203.     boolean negative = false;
  204.     byte channel = 0;
  206.     switch (action) {
  207.       case '>':
  208.         //        if (negative)
  209.         //          do(-receivedNumber, channel);
  210.         //        else
  211.         //          do(receivedNumber, channel);
  212.         break;
  213.       case  '<':  // fall through to start a new number
  214.         receivedNumber = 0;
  215.         negative = false;
  216.         channel = 0;
  217.         break;
  218.       case GO:
  219. #ifdef __HC_SR04__
  220.         action = detect_obstacle(action);
  221.         if (action == BACKWARD) {
  222.           goto __backward;
  223.         } else if (action == STAND) {
  224.           goto __stand;
  225.         }
  226. #endif
  227.       case FORWARD:
  228.         if (action != prev_action) {
  229.           prev_action = action;
  230.           locomotion(stand);
  231.         }
  232.         locomotion(forward);
  233.         break;
  235.       case BACKWARD: // Go BACK
  236. __backward:
  237.         if (action != prev_action) {
  238.           prev_action = action;
  239.           locomotion(stand);
  240.         }
  241.         locomotion(backward);
  242.         break;
  243.       case RIGHT:
  244.         if (action != prev_action) {
  245.           prev_action = action;
  246.           locomotion(stand);
  247.         }
  248.         locomotion(right);
  249.         break;
  250.       case RIGHT_FRONT:
  251.           auto_mode = !auto_mode;
  252. //        locomotion(stand);
  253. //        locomotion(right);
  254. //        locomotion(stand);
  255. //        locomotion(forward);
  256. //        locomotion(stand);
  257.         break;
  258.       case RIGHT_BACK:
  259.         locomotion(stand);
  260.         locomotion(right);
  261.         locomotion(stand);
  262.         locomotion(backward);
  263.         locomotion(stand);
  264.         break;
  265.       case LEFT:
  266.         if (action != prev_action) {
  267.           prev_action = action;
  268.           locomotion(stand);
  269.         }
  270.         locomotion(left);
  271.         break;
  272.       case LEFT_FRONT:
  273.           Serial.print("auto_mode=");
  274.           Serial.println(auto_mode ? "true" : "false");
  275. //        locomotion(stand);
  276. //        locomotion(left);
  277. //        locomotion(stand);
  278. //        locomotion(forward);
  279. //        locomotion(stand);
  280.         break;
  281.       case LEFT_BACK:
  282.         locomotion(stand);
  283.         locomotion(left);
  284.         locomotion(stand);
  285.         locomotion(backward);
  286.         locomotion(stand);
  287.         break;
  288.       case STAND:
  289. __stand:
  290.         locomotion(stand);
  291.         break;
  292.       case 'x':
  293.         channel = 1;
  294.         break;
  295.       case 'y':
  296.         channel = 2;
  297.         break;
  298.       case '0' ... '9':
  299.         receivedNumber *= 10;
  300.         receivedNumber += action - '0';
  301.         break;
  302.       case '-':
  303.         negative = true;
  304.         break;
  305.     } // end of switch  
  306. }
  307. void loop() {
  308.   //locomotion(forward);return;
  309.   if (auto_mode) {
  310.     checkAutoMode();
  311.     cur_time = millis();
  312.     if (cur_time - prev_time >= TIMEOUT) {
  313.       prev_time = cur_time;
  314.       checkAutoMode ();
  315.       action = movements[(int)random(0, 5)];
  316.       #ifdef __HC_SR04__
  317.           action = detect_obstacle(action);
  318.       #endif
  319.           do_action();
  320.     }
  322.   } else {
  323.     if (mySerial.available () > 0) {
  324.       action = mySerial.read ();
  325.       Serial.println(action);
  326.       do_action();
  327.       locomotion(stand);
  328.     }
  329.   }
  330. }
  334. void locomotion(angle_t angles[]) {
  335.   int i = 0;
  336.   while (1) {
  337.     if (angles[i].degree == -1 ||
  338.         angles[i].index == -1 ||
  339.         angles[i].delay == -1) {
  340.       break;
  341.     }
  342.     servos[angles[i].index].SetPosition(angles[i].degree);
  343.     if (angles[i].delay > 0) delay(angles[i].delay);
  344.     i++;
  345.   }
  346.   //delay(1000);
  347. }
  350. #ifdef __HC_SR04__
  351. char detect_obstacle(char action) {
  352.   char i = action;
  353.   long cm = distance_measure();
  354.   if (cm < MIN_DISTANCE) {
  355.     i = STAND;
  356.   } else if (cm >= MIN_DISTANCE && cm <= MAX_DISTANCE) {
  357.     i = BACKWARD;
  358.   }
  359.   return i;
  360. }
  362. long distance_measure()
  363. {
  364.   // establish variables for duration of the ping,
  365.   // and the distance result in inches and centimeters:
  366.   long duration, cm;
  368.   // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  369.   // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  371.   digitalWrite(HC_SR04_TRIGGER_PIN, LOW);
  372.   delayMicroseconds(2);
  373.   digitalWrite(HC_SR04_TRIGGER_PIN, HIGH);
  374.   delayMicroseconds(5);
  375.   digitalWrite(HC_SR04_TRIGGER_PIN, LOW);
  377.   // The same pin is used to read the signal from the PING))): a HIGH
  378.   // pulse whose duration is the time (in microseconds) from the sending
  379.   // of the ping to the reception of its echo off of an object.
  380.   duration = pulseIn(HC_SR04_ECHO_PIN, HIGH);
  382.   // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  383.   // The ping travels out and back, so to find the distance of the
  384.   // object we take half of the distance travelled.
  385.   cm =  duration / 29 / 2;
  386.   //Serial.print(cm);
  387.   //Serial.println("cm");
  388.   // delay(100);
  389.   return cm;
  390. }
  391. #endif
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注