robot

z foreste, 11 miesiące temu, napisane w C++, wyświetlone 105 razy. [paste_expire] 1 sekunda.
URL https://codetab.e3x.pl/view/4b6a616d 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(PA_12);
  147. bumper *right_back_bumper = new bumper(PA_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.         template<typename x>
  157.         void light(x *LED, int state_low, int state_hight, float check)
  158.         {
  159.                 if (flashcell->monitor() <= check)
  160.                 {
  161.                         (*LED)->state(state_hight);
  162.                        
  163.                
  164.                 }
  165.                 else
  166.                 {
  167.                         (*LED)->state(state_low);
  168.                
  169.                
  170.                 }
  171.         }
  172.         template<typename x, typename y>
  173.         void collision_sensor(x  *object, y *object2)
  174.                  
  175.         {
  176.                
  177.                         if ((*object)->detect() == 1)
  178.                 {
  179.                         lock = false;
  180.                         coun3.start();
  181.                         (*object2)->cramp(off, off);
  182.                         (*object2)->manoeuvre(-0.6, -0.3);
  183.                         if (coun3.read() >= 5)
  184.                         {
  185.                                  (*object)->reset();
  186.                                 lock = true;
  187.                                 coun3.stop();
  188.                                 coun3.reset();
  189.                                 (*object2)->cramp(on, on);
  190.                                 (*object2)->manoeuvre(0.0, 0.0);
  191.                         }
  192.                 }
  193.        
  194.  
  195.         }
  196.         void bip()
  197.         {
  198.                 count.start();
  199.                 if (count.read_ms() >= 500)
  200.                 {
  201.                         Led_back_left->toggle();
  202.                         Buzzer->toggle();
  203.                         count.stop();
  204.                         count.reset();
  205.                 }
  206.         }
  207.         void demo(int steper, int cycle)
  208.         {
  209.                 Led_front_right->state(off);
  210.                 Led_front_left->state(off);
  211.                 Led_back_right->state(off);
  212.                 Led_back_left->state(off);
  213.                 wait_ms(100);
  214.                 while (cycle >=0)
  215.                 {
  216.                
  217.                 Led_front_right->state(on);
  218.                 wait_ms(steper);
  219.                 Led_front_right->state(off);
  220.                 Led_front_left->state(on);
  221.                 wait_ms(steper);
  222.                 Led_front_left->state(off);
  223.                 Led_back_right->state(on);
  224.                 wait_ms(steper);
  225.                 Led_back_right->state(off);
  226.                 Led_back_left->state(on);
  227.                 wait_ms(steper);
  228.                 Led_back_left->state(off);
  229.                         --cycle;
  230.                         }
  231.         }
  232. private:
  233. };
  234.  
  235.  
  236.  
  237.  
  238. void dist(int distance)
  239.        
  240. {  
  241.         /*
  242.         if (lock == true)
  243.         {
  244.                
  245.                 if ((distance <= 30) && (distance >= 0))
  246.                 {
  247.                         engine.SetBrake(ArduinoMotorShield::MOTOR_A, 1);
  248.                         engine.SetBrake(ArduinoMotorShield::MOTOR_B, 1);
  249.                         bips();
  250.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.0);
  251.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.0);
  252.                         count2.start();
  253.                         if (count2.read_ms() >= 3000)
  254.                         {
  255.                                 engine.SetBrake(ArduinoMotorShield::MOTOR_A, 0);
  256.                                 engine.SetBrake(ArduinoMotorShield::MOTOR_B, 0);
  257.                                 engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, -0.6);
  258.                                 engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, -0.6);
  259.                                 if (count2.read_ms() >= 5000)
  260.                                 {
  261.                                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, -0.6);
  262.                                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.6);
  263.                                 }
  264.                        
  265.                                 if ((count2.read_ms() >= 7000) && (distance <= 50))
  266.                                 {
  267.                                         count2.stop();
  268.                                         count2.reset();
  269.                                 }
  270.                         }
  271.                 }
  272.                 else    if (distance <= 50)
  273.                 {
  274.                
  275.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.2);
  276.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.2);
  277.                 }
  278.                 else if (distance <= 60)
  279.                 {
  280.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.3);
  281.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.3);
  282.                 }
  283.                 else if (distance <= 70)
  284.                 {
  285.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.4);
  286.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.4);
  287.                 }
  288.                 else if (distance <= 80)
  289.                 {
  290.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.5);
  291.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.5);
  292.                 }
  293.                 else if (distance <= 90)
  294.                 {
  295.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.6);
  296.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.6);
  297.                 }
  298.                 else if (distance <= 100)
  299.                 {
  300.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.7);
  301.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.7);
  302.                 }
  303.        
  304.                 else
  305.                 {
  306.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_A, 0.8);
  307.                         engine.SetMotorPower(ArduinoMotorShield::MOTOR_B, 0.8);
  308.                         engine.SetBrake(ArduinoMotorShield::MOTOR_A, 0);
  309.                         engine.SetBrake(ArduinoMotorShield::MOTOR_B, 0);
  310.                 }
  311.                 */
  312.                 Bluetooth.printf("Distance %d mm\r\n", distance);
  313.  
  314. }
  315.  
  316. ultrasonic sensor(PB_13, PB_14, .1, 1, &dist);
  317.  
  318.  
  319.  
  320.  
  321. int main()
  322. {
  323.        
  324.         right_front_bumper->init(front_right, &push::pushing);
  325.         left_front_bumper->init(front_left, &push::pushing);
  326.         right_back_bumper->init(front_right, &push::pushing);
  327.         left_back_bumper->init(front_left, &push::pushing);
  328.         master *boss = new master;
  329.        
  330.        
  331.        
  332.        
  333.         //right_bumper.init(&right_sensor_push);
  334.         //main boss;
  335.         boss->demo(300, 2);
  336.        
  337.         for (;;)
  338.         {
  339.                 boss->collision_sensor(&front_left, &engine);
  340.                 boss->collision_sensor(&front_right, &engine);
  341.                 boss->collision_sensor(&back_left, &engine);
  342.                 boss->collision_sensor(&back_right, &engine);
  343.                 boss->light(&Led_front_left,off,on,0.3f);
  344.                 boss->light(&Led_front_right, off, on, 0.3f);
  345.                 boss->light(&Led_back_left, off, on, 0.3f);
  346.                 boss->light(&Led_back_right, off, on, 0.3f);
  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