robot

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

odpowiedź "robot"

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

captcha