kaktus

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

odpowiedź "kaktus"

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

captcha