termometr

z foreste, 1 rok temu, napisane w C++, wyświetlone 28 razy. [paste_expire] 1 sekunda.
URL https://codetab.e3x.pl/view/27f5dcf1 Udostępnij
Pobierz wklejkę lub Pokaż surowy tekst
  1. //TODO 1 Dokończyć monitor bateri
  2. //TODO 2 Pytanie o imię użytkownika i zapamiętanie jego
  3. //TODO 3 Wyłaczenie alarmu przyciskiem
  4. //TODO 4 Dodanie obslugi LCD
  5. #include "mbed.h"
  6. #include "MPL3115A2.h"
  7. #include "Terminal.h"
  8. #include "eeprom.h"
  9. #include "cstdlib"
  10. #include "string"
  11.  
  12. #define EEPROM_ADDR 0x00   // I2c EEPROM address is 0x00
  13.  
  14. #define SDA PTE25            // I2C SDA pin
  15. #define SCL PTE24           // I2C SCL pin
  16. int32_t eeprom_size, addr;
  17. Terminal pc(PTA2, PTA1);  // tx, rx
  18. I2C i2c(PTE0, PTE1);        // sda, scl
  19. EEPROM brain(SDA, SCL, EEPROM_ADDR, EEPROM::T24C08);
  20. MPL3115A2 sensor(&i2c, &pc);
  21. int temperature_live_state;
  22. static int read_user_temp;
  23. int val = 0;
  24. int val2 = 0;
  25. int val3 = 0;
  26. int *temp_data = &read_user_temp;
  27. Timer licznik, licznik2, licznik3, licznik4;
  28. char buffer[20];
  29. char dane[4];
  30. float  check_battery;
  31. int lock  = 0;  
  32. int menu_select_option = 0;
  33. int menu_select= 0;
  34.  
  35.  
  36. //DigitalOut myled1(PTA12);     // Sanity check to make sure the program is working.
  37. DigitalOut buzzer(PTB16);      // Sanity check to make sure the program is working.
  38. DigitalOut Red(PTB18, 1);
  39. DigitalOut Blue(PTD1, 1);
  40. DigitalOut Green(PTB19, 1);
  41. DigitalOut testing(PTB17, 1);
  42. AnalogIn batery(PTC2);
  43. DigitalIn key_menu(PTD4);
  44.  
  45.  
  46. float monitor_batery()
  47. {
  48.         check_battery = batery.read();
  49.         float resume;
  50.         return resume = (check_battery * 4.1);
  51. }
  52.  
  53. void monitor_batery_light()
  54. {
  55.         if ((monitor_batery() <= 4.10) && (monitor_batery() >= 3.74))
  56.         {
  57.                 Green = 0;
  58.         }
  59.         else if ((monitor_batery() <= 3.74) && (monitor_batery() >= 3.38))
  60.         {
  61.                 Green = 0;
  62.                 Red      = 0;
  63.         }
  64.         else if (monitor_batery() <= 3.38)
  65.         {
  66.                 Red = 0;
  67.                 Green = 1;
  68.         }
  69. }
  70.  
  71. void key_menu_main()
  72. {
  73.        
  74.         if (key_menu == 0)
  75.         {
  76.                
  77.                 licznik3.start();
  78.                 if (licznik3.read_ms() >= 200)
  79.                 {
  80.                         menu_select_option = 1;
  81.                         val3 = 1;
  82.                 }
  83.                 if (licznik3.read_ms() >= 1500)
  84.                 {
  85.                         menu_select_option = 2;
  86.                         val3 = 1;
  87.                 }
  88.                 if (licznik3.read_ms() >= 3200)
  89.                 {
  90.                         menu_select_option = 0;
  91.                         licznik3.reset();
  92.                 }
  93.         }
  94.         else
  95.         {
  96.                 val3 = 0;
  97.                 licznik3.stop();
  98.                 licznik3.reset();
  99.         }
  100.  
  101. }
  102.  
  103. void menu_main()
  104. {
  105.         if (( val3 == 0) && (menu_select_option == 1))
  106.         {
  107.                 val2 = 1;
  108.         }
  109.         if ((val3 == 0) && (menu_select_option == 2))
  110.         {
  111.                 licznik4.start();
  112.                 monitor_batery_light();
  113.                 if (licznik4.read() >= 5)
  114.                 {
  115.                         menu_select_option = 0;
  116.                         Red = 1; Green = 1;
  117.                         licznik4.stop();
  118.                         licznik4.reset();
  119.                 }
  120.         }
  121. }
  122. void refresh_buffer()
  123. {
  124.         for (int y = 0; y < sizeof(buffer); y++)
  125.                 buffer[y] = 0;
  126.         for (int z = 0; z < sizeof(dane); z++)
  127.                 dane[z] = 0;
  128. }              
  129.  
  130. void serials()
  131. {
  132.         if (pc.readable())
  133.         {
  134.                 pc.scanf("%s", buffer);
  135.         }
  136. }
  137.  
  138. void signaller()
  139. {
  140.         licznik.start();
  141.        
  142.         if (licznik.read_ms() >= 1000)
  143.         {
  144.                 buzzer = !buzzer;
  145.                 licznik.reset();
  146.         }
  147.        
  148. }
  149.  
  150. void alarm_power(float voltage_limit_definition)
  151. {
  152.         if (monitor_batery() <= voltage_limit_definition)
  153.         {
  154.                 if (lock <= 4)
  155.                 {
  156.                         licznik2.start();
  157.                                
  158.                         if (licznik2.read_ms() >= 1500)
  159.                         {
  160.                                        
  161.                                 buzzer = !buzzer;
  162.                                 licznik2.reset();
  163.                                        
  164.                         }
  165.                         lock++;
  166.                 }
  167.         }
  168.         if (voltage_limit_definition <= monitor_batery())
  169.         {
  170.                 lock = 0;
  171.                 licznik2.stop();
  172.                 licznik2.reset();
  173.         }
  174. }
  175.  
  176. void alarm_temp(string  & temp_read_input)
  177. {
  178.         string str = temp_read_input;
  179.         temperature_live_state = atoi(str.c_str());
  180.         if (val2 == 0)
  181.         {
  182.                 if (temperature_live_state >= *temp_data)
  183.                 {
  184.                         signaller();
  185.                 }
  186.         }
  187.         if (*temp_data - temperature_live_state == 1)
  188.         {
  189.                 val2 = 0;
  190.         }
  191.         if (*temp_data > temperature_live_state)
  192.         {
  193.                 buzzer = 0;
  194.                 licznik.stop();
  195.                 licznik.reset();
  196.         }
  197.        
  198. }
  199.  
  200. void screen()
  201. {
  202.         pc.foreground(0xFFFF00);
  203.         pc.hideCursor();
  204. }
  205. void intro()
  206. {
  207.         pc.locate(15, 5);
  208.         pc.printf(" ** inteligentny Termometr   ** ");
  209.         pc.locate(15, 6);
  210.         pc.printf("Created by Foreste");
  211. }
  212. void labels()
  213. {
  214.         pc.locate(10, 7);
  215.         pc.printf("Temperatura");
  216.         pc.locate(25, 7);
  217.         pc.printf("Cisnienie");
  218.         pc.locate(38, 7);
  219.         pc.printf("otrzezenie wysokiej temp");
  220.         pc.locate(65, 7);
  221.         pc.printf("Bateria");
  222. }
  223. void input_add_user_define_temperature()
  224. {
  225.         int tempint;
  226.         refresh_buffer();
  227.        
  228.         screen();
  229.         intro();
  230.         pc.locate(1, 7);
  231.         pc.printf("Wpisz wartość temperatury ,po której termometr bedzie sygnalizował przekroczenie");
  232.        
  233.         if (pc.readable())
  234.         {
  235.                 pc.scanf("%s", dane);
  236.                
  237.         }      
  238.        
  239.        
  240.         for (int   z = 0; z < 4; z++)
  241.         {
  242.                
  243.                 if (isdigit(dane[z]))//sprawdzanie czy znak jest liczbą
  244.                 {
  245.        
  246.                         tempint = atoi(dane);  //kowertowanie tablicy typu char na zmienną int
  247.                                
  248.                 }
  249.         }
  250.        
  251.                  
  252.         *temp_data = tempint;
  253.         if ((*temp_data >= 1) && (*temp_data <= 99))
  254.         {
  255.                
  256.                 if ((*temp_data >= 12) && (*temp_data <= 40))
  257.                 {
  258.                         pc.cls();
  259.                         screen();
  260.                         intro();
  261.                         brain.write(eeprom_size = 8, (int32_t) *temp_data);
  262.                         pc.locate(20, 7);
  263.                         pc.printf("Zapisalem podaną temperature przekroczenia");
  264.                         wait(5);
  265.                         val = 1;
  266.                         refresh_buffer();
  267.                         pc.cls();
  268.                                
  269.                 }
  270.                 else
  271.                 {
  272.                         pc.cls();
  273.                         screen();
  274.                         intro();
  275.                         pc.locate(20, 7);
  276.                         pc.printf("Wpisano niepoprawne dane. Dopuszczalny zakres: od 12 do 40");
  277.                         wait(5);
  278.                         pc.cls();
  279.                        
  280.                 }
  281.         }
  282. }
  283.  
  284.        
  285. void rs232_menu()
  286. {
  287.        
  288.         if (strcmp(buffer, "reset") == 0)
  289.         {
  290.                 NVIC_SystemReset();
  291.         }
  292.         else if (strcmp(buffer, "alarm") == 0)
  293.         {
  294.                 pc.cls();
  295.                 while (val <= 0)
  296.                 {
  297.                         input_add_user_define_temperature();
  298.                 }
  299.         }
  300.        
  301. }
  302.  
  303. int main() {
  304.         int lock  = 0; 
  305.         pc.baud(9600);    
  306.         pc.cls();
  307.         sensor.init();
  308.         screen();
  309.         intro();
  310.         wait(5);
  311.         Temperature t;
  312.         Pressure p;                                                                                                                                    
  313.         sensor.setOffsetTemperature(20);
  314.         sensor.setOffsetPressure(-32);
  315.         brain.read((uint32_t)(eeprom_size = 8), (int32_t&) *temp_data);
  316.        
  317.         while (read_user_temp <= 0)
  318.         {
  319.                 while (val <= 0)
  320.                 {
  321.                         input_add_user_define_temperature();
  322.                 }              
  323.         }
  324.         pc.cls();
  325.        
  326.        
  327.         while (1)
  328.         {
  329.                 val = 0;
  330.                
  331.                 sensor.readTemperature(&t);
  332.                 sensor.setModeStandby();
  333.                 sensor.setModeBarometer();
  334.                 sensor.setModeActive();
  335.                 sensor.readPressure(&p);
  336.                
  337.                 screen();
  338.                 intro();
  339.                 labels();
  340.                 string temp_cache = t.print();
  341.                 pc.locate(10, 9);
  342.                 pc.printf("%s C", t.print());
  343.                 pc.locate(25, 9);
  344.                 pc.printf("%s Hpa", p.print());
  345.                 pc.locate(45, 9);
  346.                 pc.printf("%d", *temp_data);
  347.                 pc.locate(65, 9);
  348.                 pc.printf("%1.2fV", monitor_batery());
  349.                 pc.locate(65, 12);
  350.                 alarm_temp(temp_cache);
  351.                 serials();
  352.                 alarm_power(3.38);
  353.                 rs232_menu();
  354.                 key_menu_main();
  355.                 menu_main();
  356.                 sensor.setModeStandby();
  357.                 sensor.setModeAltimeter();
  358.                 sensor.setModeActive();
  359.                
  360.         }
  361. }

odpowiedź "termometr"

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

captcha