robot

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

odpowiedź "robot"

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

captcha