robot

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

odpowiedź "robot"

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

captcha