robot

z foreste, 4 miesiące temu, napisane w C++, wyświetlone 21 razy. [paste_expire] 1 sekunda.
URL https://codetab.e3x.pl/view/a7d5ff82 Udostępnij
Pobierz wklejkę lub Pokaż surowy tekst
  1. #include <mbed.h>
  2. #include "ArduinoMotorShield.hpp"
  3. #include "ultrasonic.h"
  4. #include "PinDetect.h"
  5.  
  6. Timer count , count2, coun3 ;
  7. Serial Bluetooth(PC_4, PC_5);
  8.  
  9. #define on 1
  10. #define off 0
  11. bool lock = true;
  12. bool lockhead = 1;
  13.  
  14.                          
  15.  
  16. class Gear
  17. {
  18. public:
  19.         void manoeuvre(float step_left, float step_right)
  20.         {
  21.                 _driver.SetMotorPower(ArduinoMotorShield::MOTOR_A, step_left);        
  22.                 _driver.SetMotorPower(ArduinoMotorShield::MOTOR_B, step_right);
  23.         }
  24.  
  25.         void cramp(int brake_left, int brake_right)
  26.         {
  27.                 _driver.SetBrake(ArduinoMotorShield::MOTOR_A, brake_left);
  28.                 _driver.SetBrake(ArduinoMotorShield::MOTOR_B, brake_right);
  29.         }
  30.        
  31.         void direction_forward()
  32.         {
  33.                 _driver.SetMotorPolarity(ArduinoMotorShield::MOTOR_A, ArduinoMotorShield::MOTOR_FORWARD);
  34.                 _driver.SetMotorPolarity(ArduinoMotorShield::MOTOR_B, ArduinoMotorShield::MOTOR_FORWARD);
  35.         }
  36.         void direction_backforward()
  37.         {
  38.                 _driver.SetMotorPolarity(ArduinoMotorShield::MOTOR_A, ArduinoMotorShield::MOTOR_BACKWARD);
  39.                 _driver.SetMotorPolarity(ArduinoMotorShield::MOTOR_B, ArduinoMotorShield::MOTOR_BACKWARD);
  40.         }
  41. private:
  42.         ArduinoMotorShield _driver;
  43. };
  44.  
  45. class bumper
  46. {
  47. public:
  48.        
  49.         bumper(PinName pin)
  50.                 : _clicker(pin)
  51.         {
  52.                
  53.         }
  54.        
  55.        
  56.         template<typename x>
  57.                 void init(x *object, void(x::*member)(void))
  58.                 {
  59.                
  60.                         _clicker.mode(PullUp);
  61.                         _clicker.attach_deasserted(object, member);
  62.                         _clicker.setSampleFrequency();
  63.                
  64.                 }
  65. private:
  66.         PinDetect  _clicker;
  67.        
  68. };
  69. class gauge
  70. {
  71.        
  72. public:
  73.         float  check_battery;
  74.         gauge(PinName pin)
  75.                 : _analog(pin)
  76.         {
  77.         }
  78.         float monitor_battery()
  79.         {
  80.                 check_battery = _analog.read();
  81.                 float resume;
  82.                 return resume = (check_battery * 11.2);
  83.         }
  84.         float monitor()
  85.         {
  86.                 return _analog.read();
  87.         }
  88. private:
  89.         AnalogIn  _analog;
  90.        
  91.        
  92. };
  93. class connector
  94. {
  95. public:
  96.         connector(PinName pin)
  97.                 : _pin(pin)
  98.         {
  99.                 _pin = 0;
  100.         }
  101.         void state(int s)
  102.         {
  103.                 _pin = s;
  104.         }
  105.         void toggle()
  106.         {
  107.                 _pin = !_pin;
  108.                
  109.         }
  110. private:
  111.         DigitalOut _pin;
  112. };
  113.  
  114.  
  115. class push
  116. {
  117. private:
  118.         int tik;
  119. public:
  120.        
  121.         void pushing()
  122.         {
  123.                 tik = 1;
  124.                  
  125.         }
  126.         int detect()
  127.         {
  128.                 return tik;
  129.         }
  130.         void reset()
  131.         {
  132.                 tik = 0;
  133.         }
  134. };
  135.  
  136.  
  137. connector  * Led_front_right = new connector(PB_15);
  138. connector * Led_front_left = new connector(PB_1);
  139. connector *Led_back_right = new connector(PB_2);
  140. connector *Led_back_left = new connector(PB_11);
  141. connector *Led_red_battery = new connector(PB_4);
  142. connector *Led_yellow_battery = new connector(PB_10);
  143. connector *Led_green_battery = new connector(PA_8);
  144. connector *Buzzer = new connector(PB_12);
  145. gauge *flashcell = new gauge(PC_3);
  146. gauge *Battery = new gauge(PA_4);
  147. Gear *engine = new Gear;
  148. bumper *left_front_bumper = new bumper(PC_6);
  149. bumper *right_front_bumper = new bumper(PC_8);
  150. bumper *left_back_bumper = new bumper(PA_12);
  151. bumper *right_back_bumper = new bumper(PA_11);
  152. push *front_right = new push;
  153. push *front_left = new push;
  154. push *back_right = new push;
  155. push *back_left = new push;
  156. class Beep
  157. {
  158. public:
  159.         template<typename t>
  160.         void bip(t *_connect, int clock)
  161.         {
  162.                 count.start();
  163.                 if (count.read_ms() >= clock)
  164.                 {
  165.                         (*_connect)->toggle();
  166.                         count.stop();
  167.                         count.reset();
  168.                 }
  169.         }
  170. };
  171. Beep *siren = new Beep;
  172. class master
  173. {
  174. public:
  175.  
  176.         template<typename x>
  177.         void light(x *LED, int state_low, int state_hight, float check)
  178.         {
  179.                 if (flashcell->monitor() <= check)
  180.                 {
  181.                         (*LED)->state(state_hight);
  182.                        
  183.                
  184.                 }
  185.                 else
  186.                 {
  187.                         (*LED)->state(state_low);
  188.                
  189.                
  190.                 }
  191.         }
  192.         template<typename x, typename y>
  193.                 void collision_sensor(x  *object, y *object2, float one_left, float one_right, float two_left, float two_right)
  194.                  
  195.         {
  196.                
  197.                         if ((*object)->detect() == 1)
  198.                 {
  199.                         lock = false;
  200.                         coun3.start();
  201.                         (*object2)->cramp(off, off);
  202.                         (*object2)->manoeuvre(one_left , one_right);
  203.                         if (coun3.read() >= 5)
  204.                         {
  205.                                  (*object)->reset();
  206.                                
  207.                                 coun3.stop();
  208.                                 coun3.reset();
  209.                                 //(*object2)->cramp(on, on);
  210.                                 (*object2)->manoeuvre(two_left, two_right);
  211.                                 lock = true;
  212.                         }
  213.                 }
  214.        
  215.  
  216.         }
  217.        
  218.         void demo(int steper, int cycle)
  219.         {
  220.                 Led_front_right->state(off);
  221.                 Led_front_left->state(off);
  222.                 Led_back_right->state(off);
  223.                 Led_back_left->state(off);
  224.                 wait_ms(100);
  225.                 while (cycle >=0)
  226.                 {
  227.                
  228.                 Led_front_right->state(on);
  229.                 wait_ms(steper);
  230.                 Led_front_right->state(off);
  231.                 Led_front_left->state(on);
  232.                 wait_ms(steper);
  233.                 Led_front_left->state(off);
  234.                 Led_back_right->state(on);
  235.                 wait_ms(steper);
  236.                 Led_back_right->state(off);
  237.                 Led_back_left->state(on);
  238.                 wait_ms(steper);
  239.                 Led_back_left->state(off);
  240.                         --cycle;
  241.                         }
  242.         }
  243.         template<typename x, typename y>
  244.         void battery_indicator()
  245.         {
  246.                 if ()
  247.                 {
  248.                        
  249.                 }else if ()
  250.                 {
  251.                        
  252.                 }else if ()
  253.                 {
  254.                        
  255.                 }
  256.         }
  257. private:
  258. };
  259.  
  260.  
  261.  
  262.  
  263. void dist(int distance)
  264.        
  265. {  
  266.         Bluetooth.printf("Distance %d mm\r\n", distance);
  267.         if (lock == true)
  268.         {
  269.                
  270.                 if ((distance <= 50) && (distance >= 0))
  271.                 {
  272.                        
  273.                         lockhead = 0;
  274.                 }
  275.                 else if(distance <= 30)
  276.                 {
  277.                         lockhead = 1;
  278.                 }
  279.                 if  (lockhead == 0)
  280.                 {
  281.                        
  282.                         count2.start();
  283.                         engine->manoeuvre(0.0, 0.0);
  284.                         if ((count2.read_ms() >= 2000)&& (distance >= 20))
  285.                         {
  286.                                 engine->manoeuvre(0.6, -0.6);
  287.                         }
  288.                         if (count2.read_ms() >= 4000)
  289.                         {
  290.                                 engine->manoeuvre(0.0, 0.0);
  291.                         }
  292.                        
  293.                         if (count2.read_ms() >= 5000)
  294.                         {
  295.                                 lockhead = 1;
  296.                                 count2.stop();
  297.                                 count2.reset();
  298.                                
  299.                         }
  300.                        
  301.                 }
  302.                 if (lockhead == 1)
  303.                 {
  304.                         if (distance <= 20)
  305.                         {
  306.                                 engine->manoeuvre(0.2, 0.2);
  307.                         }
  308.                         else if (distance <= 40)
  309.                         {
  310.                                 engine->manoeuvre(0.3, 0.3);
  311.                         }
  312.                         else if (distance <= 60)
  313.                         {
  314.                                 engine->manoeuvre(0.4, 0.4);
  315.                         }
  316.                         else if (distance <= 80)
  317.                         {
  318.                                 engine->manoeuvre(0.5, 0.5);
  319.                         }
  320.                         else if (distance >= 81)
  321.                         {
  322.                                 engine->manoeuvre(1.0, 1.0);
  323.                         }
  324.        
  325.                
  326.                         Bluetooth.printf("Distance %d mm\r\n", distance);
  327.  
  328.                 }
  329.         }
  330. }
  331.         ultrasonic sensor(PB_13, PB_14, .1, 1, &dist);
  332.  
  333.  
  334.  
  335.  
  336. int main()
  337. {
  338.         sensor.startUpdates();
  339.         right_front_bumper->init(front_right, &push::pushing);
  340.         left_front_bumper->init(front_left, &push::pushing);
  341.         right_back_bumper->init(front_right, &push::pushing);
  342.         left_back_bumper->init(front_left, &push::pushing);
  343.         master *boss = new master;
  344.        
  345.        
  346.        
  347.        
  348.         //right_bumper.init(&right_sensor_push);
  349.         //main boss;
  350.         boss->demo(300, 2);
  351.        
  352.         for (;;)
  353.         {
  354.        
  355.                 sensor.checkDistance();
  356.        
  357.                 boss->collision_sensor(&front_left, &engine, 0.6, -0.3, 0.0, 0.0);
  358.                 boss->collision_sensor(&front_right, &engine, 0.6, -0.3, 0.0, 0.0);
  359.                 boss->collision_sensor(&back_left, &engine, 0.6, -0.3, 0.0, 0.0);
  360.                 boss->collision_sensor(&back_right, &engine, 0.6, -0.3, 0.0, 0.0);
  361.                 boss->light(&Led_front_left,off,on,0.4f);
  362.                 boss->light(&Led_front_right, off, on, 0.4f);
  363.                 boss->light(&Led_back_left, off, on, 0.4f);
  364.                 boss->light(&Led_back_right, off, on, 0.4f);
  365.                 boss->battery_indicator();
  366.                 siren->bip(&Buzzer, 500);
  367.                  
  368.                
  369.                
  370.                 //Bluetooth.printf("Poziom na³adowania baterii %2d V .\n", front_right->detect());
  371.         //      wait(1);
  372.                
  373.         }
  374. }

odpowiedź "robot"

Tutaj możesz odpowiedzieć na wklejkę z góry

captcha