termometr

z foreste, 2 lata temu, napisane w C++, wyświetlone 96 razy. [paste_expire] 1 sekunda.
URL https://codetab.e3x.pl/view/b53321d5 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 "ILI9341.h"
  7. #include "Arial12x12.h"
  8. #include "Arial24x23.h"
  9. #include "Arial43x48_numb.h"
  10. #include "MPL3115A2.h"                                                                                                                                                                                                                                      
  11. #include "Terminal.h"
  12. #include "eeprom.h"
  13. #include "stdlib.h"
  14. #include "string.h"
  15.  
  16. #define EEPROM_ADDR 0x00   // I2c EEPROM address is 0x00
  17. #define SDA PTE25            // I2C SDA pin
  18. #define SCL PTE24           // I2C SCL pin
  19. #define lcd_bus SPI_8
  20. #define lcd_bus_clock 24000000
  21. #define lcd_mosi PTA16
  22. #define lcd_miso PTA17
  23. #define lcd_sclk PTA15
  24. #define lcd_cs PTC7
  25. #define lcd_dc PTC3
  26. #define lcd_Reset PTC0
  27.  
  28. int32_t eeprom_size, addr;
  29. Terminal pc(PTA2, PTA1);  // tx, rx
  30. I2C i2c(PTE0, PTE1);        // sda, scl
  31. EEPROM brain(SDA, SCL, EEPROM_ADDR, EEPROM::T24C08);
  32. MPL3115A2 sensor(&i2c, &pc);
  33. Timer licznik, licznik2, licznik3, licznik4;
  34. static int temperature_live_state;
  35. static int read_user_temp;
  36. static int val = 0;
  37. static  int val2 = 0;
  38. static int val3 = 0;
  39. static int lock  = 0;  
  40. static int menu_select_option = 0;
  41. static int menu_select = 0;
  42. static int *temp_data = &read_user_temp;
  43.  
  44. char buffer[20];
  45. char dane[4];
  46. float  check_battery;
  47.  
  48.  
  49.  
  50. //DigitalOut myled1(PTA12);     // Sanity check to make sure the program is working.
  51. DigitalOut buzzer(PTB16);      // Sanity check to make sure the program is working.
  52. DigitalOut Red_diode(PTB18, 1);
  53. DigitalOut Blue_diode(PTD1, 1);
  54. DigitalOut Green_diode(PTB19, 1);
  55. DigitalOut testing(PTB17, 1);
  56. DigitalOut lcd_light(PTA4);
  57. AnalogIn batery(PTC2);
  58. DigitalIn key_menu(PTD4);
  59.  
  60. Temperature t;
  61. Pressure p;  
  62.  
  63. //#define lcd_lightscreen PTC4 
  64. ILI9341 lcd(lcd_bus, lcd_bus_clock, lcd_mosi, lcd_miso, lcd_sclk, lcd_cs, lcd_Reset, lcd_dc, "lcd", 240, 320);  
  65.  
  66. float monitor_batery()
  67. {
  68.         check_battery = batery.read();
  69.         float resume;
  70.         return resume = (check_battery * 4.1);
  71. }
  72.  
  73. void monitor_batery_light()
  74. {
  75.         if ((monitor_batery() <= 4.10) && (monitor_batery() >= 3.74))
  76.         {
  77.                 Green_diode = 0;
  78.         }
  79.         else if ((monitor_batery() <= 3.74) && (monitor_batery() >= 3.38))
  80.         {
  81.                 Green_diode = 0;
  82.                 Red_diode        = 0;
  83.         }
  84.         else if (monitor_batery() <= 3.38)
  85.         {
  86.                 Red_diode = 0;
  87.                 Green_diode = 1;
  88.         }
  89. }
  90.  
  91. void key_menu_main()
  92. {
  93.        
  94.         if (key_menu == 0)
  95.         {
  96.                
  97.                 licznik3.start();
  98.                 if ((licznik3.read_ms() >= 200) && (licznik3.read_ms() <= 1500))
  99.                 {
  100.                         menu_select_option = 1;
  101.                         val3 = 1;
  102.                 }
  103.                 if ((licznik3.read_ms() >= 1500)  && (licznik3.read_ms() <= 3200))
  104.                 {
  105.                         menu_select_option = 2;
  106.                         val3 = 1;
  107.                 }
  108.                 if (licznik3.read_ms() >= 3200)
  109.                 {
  110.                         menu_select_option = 0;
  111.                         licznik3.reset();
  112.                 }
  113.         }
  114.         else
  115.         {
  116.                 val3 = 0;
  117.                 licznik3.stop();
  118.                 licznik3.reset();
  119.         }
  120.  
  121. }
  122.  
  123. void menu_main()
  124. {
  125.         if (( val3 == 0) && (menu_select_option == 1))
  126.         {
  127.                 val2 = 1;
  128.         }
  129.         if ((val3 == 0) && (menu_select_option == 2))
  130.         {
  131.                 licznik4.start();
  132.                 monitor_batery_light();
  133.                 if (licznik4.read() >= 5)
  134.                 {
  135.                         menu_select_option = 0;
  136.                         Red_diode = 1; Green_diode = 1;
  137.                         licznik4.stop();
  138.                         licznik4.reset();
  139.                 }
  140.         }
  141. }
  142. void refresh_buffer()
  143. {
  144.         for (int y = 0; y < sizeof(buffer); y++)
  145.                 buffer[y] = 0;
  146.         for (int z = 0; z < sizeof(dane); z++)
  147.                 dane[z] = 0;
  148. }              
  149.  
  150. void serials()
  151. {
  152.         if (pc.readable())
  153.         {
  154.                 pc.scanf("%s", buffer);
  155.         }
  156. }
  157.  
  158. void signaller()
  159. {
  160.         licznik.start();
  161.        
  162.         if (licznik.read_ms() >= 1000)
  163.         {
  164.                 buzzer = !buzzer;
  165.                 licznik.reset();
  166.         }
  167.        
  168. }
  169.  
  170. void alarm_power(float voltage_limit_definition)
  171. {
  172.         if (monitor_batery() <= voltage_limit_definition)
  173.         {
  174.                 if (lock <= 4)
  175.                 {
  176.                         licznik2.start();
  177.                                
  178.                         if (licznik2.read_ms() >= 1500)
  179.                         {
  180.                                        
  181.                                 buzzer = !buzzer;
  182.                                 licznik2.reset();
  183.                                        
  184.                         }
  185.                         lock++;
  186.                 }
  187.         }
  188.         if (voltage_limit_definition <= monitor_batery())
  189.         {
  190.                 lock = 0;
  191.                 licznik2.stop();
  192.                 licznik2.reset();
  193.         }
  194. }
  195.  
  196. void alarm_temp(string  & temp_read_input)
  197. {
  198.         string str = temp_read_input;
  199.         temperature_live_state = atoi(str.c_str());
  200.         if (val2 == 0)
  201.         {
  202.                 if (temperature_live_state >= *temp_data)
  203.                 {
  204.                         signaller();
  205.                 }
  206.         }
  207.         if (*temp_data - temperature_live_state == 1)
  208.         {
  209.                 val2 = 0;
  210.         }
  211.         if (*temp_data > temperature_live_state)
  212.         {
  213.                 buzzer = 0;
  214.                 licznik.stop();
  215.                 licznik.reset();
  216.         }
  217.        
  218. }
  219.  
  220. void screen()
  221. {
  222.         pc.foreground(0xFFFF00);
  223.         pc.hideCursor();
  224. }
  225. void main_menu_legend_rs232()
  226. {
  227.         pc.locate(25, 12);
  228.         pc.printf("Menu główne konsoli - komendy:");
  229.         pc.locate(22, 13);
  230.         pc.printf("\"alarm\"  Ustawienie alarmu");
  231.         pc.locate(22, 14);
  232.         pc.printf("\"wycisz\" Wyłaczenie alarmu");
  233.         pc.locate(22, 15);
  234.         pc.printf("\"reset\"  Ponownie uruchomienie");
  235. }
  236. void intro()
  237. {
  238.         pc.locate(15, 5);
  239.         pc.printf(" ** inteligentny Termometr   ** ");
  240.         pc.locate(15, 6);
  241.         pc.printf("Created by Foreste");
  242. }
  243. void labels_rs232()
  244. {
  245.         pc.locate(10, 7);
  246.         pc.printf("Temperatura");
  247.         pc.locate(25, 7);
  248.         pc.printf("Cisnienie");
  249.         pc.locate(38, 7);
  250.         pc.printf("otrzezenie wysokiej temp");
  251.         pc.locate(65, 7);
  252.         pc.printf("Bateria");
  253. }
  254.  
  255. void labels_lcd()
  256. {
  257.         lcd.set_font_zoom(3, 3);
  258.         lcd.locate(10, 7);
  259.         lcd.printf("Temperatura");
  260.         lcd.locate(25, 90);
  261.         lcd.printf("Cisnienie");
  262.         lcd.locate(30, 175);
  263.         lcd.printf("Alarm temp");
  264.         lcd.locate(52, 235);
  265.         lcd.printf("Bateria");
  266. }
  267. void input_add_user_define_temperature()
  268. {
  269.         int tempint;
  270.         refresh_buffer();
  271.        
  272.         screen();
  273.         intro();
  274.         pc.locate(1, 7);
  275.         pc.printf("Wpisz wartość temperatury ,po której termometr bedzie sygnalizował przekroczenie");
  276.        
  277.         if (pc.readable())
  278.         {
  279.                 pc.scanf("%s", dane);
  280.                
  281.         }      
  282.        
  283.        
  284.         for (int   z = 0; z < 4; z++)
  285.         {
  286.                
  287.                 if (isdigit(dane[z]))//sprawdzanie czy znak jest liczbą
  288.                 {
  289.        
  290.                         tempint = atoi(dane);  //kowertowanie tablicy typu char na zmienną int
  291.                                
  292.                 }
  293.         }
  294.        
  295.                  
  296.         *temp_data = tempint;
  297.         if ((*temp_data >= 1) && (*temp_data <= 99))
  298.         {
  299.                
  300.                 if ((*temp_data >= 12) && (*temp_data <= 40))
  301.                 {
  302.                         pc.cls();
  303.                         screen();
  304.                         intro();
  305.                         brain.write(eeprom_size = 8, (int32_t) *temp_data);
  306.                         pc.locate(20, 7);
  307.                         pc.printf("Zapisalem podaną temperature przekroczenia");
  308.                         wait(5);
  309.                         val = 1;
  310.                         refresh_buffer();
  311.                         pc.cls();
  312.                                
  313.                 }
  314.                 else
  315.                 {
  316.                         pc.cls();
  317.                         screen();
  318.                         intro();
  319.                         pc.locate(20, 7);
  320.                         pc.printf("Wpisano niepoprawne dane. Dopuszczalny zakres: od 12 do 40");
  321.                         wait(5);
  322.                         pc.cls();
  323.                        
  324.                 }
  325.         }
  326. }
  327. void mute()
  328. {
  329.         pc.cls();
  330.         intro();
  331.         val2 = 1;
  332.         pc.locate(10, 7);
  333.         pc.printf("Alarm został wyłączony");
  334.         wait(2);
  335.         refresh_buffer();
  336. }
  337. void reset()
  338. {
  339.         pc.cls();
  340.         intro();
  341.         pc.locate(15, 7);
  342.         pc.printf("Zachwile nastąpi ponowne uruchomienie");
  343.         wait(2);
  344.         NVIC_SystemReset();
  345. }
  346. void rs232_menu()
  347. {
  348.        
  349.         if (strcmp(buffer, "wycisz") == 0)
  350.         {
  351.                 mute();
  352.         }
  353.         if (strcmp(buffer, "reset") == 0)
  354.         {
  355.                 reset();
  356.         }
  357.         else if (strcmp(buffer, "alarm") == 0)
  358.         {
  359.                 pc.cls();
  360.                 while (val <= 0)
  361.                 {
  362.                         input_add_user_define_temperature();
  363.                 }
  364.         }
  365.        
  366. }
  367. void lcd_setting()
  368. {
  369.         lcd.background(Black);
  370.         lcd.foreground(White);
  371. }
  372. void rs232_write_data()
  373. {
  374.         pc.locate(10, 9);
  375.         pc.printf("%s C", t.print());
  376.         pc.locate(25, 9);
  377.         pc.printf("%s Hpa", p.print());
  378.         pc.locate(45, 9);
  379.         pc.printf("%d", *temp_data);
  380.         pc.locate(65, 9);
  381.         pc.printf("%1.2fV", monitor_batery());
  382.        
  383. }
  384.  
  385. void lcd_write_data()
  386. {
  387.         lcd.set_font_zoom(3, 2);
  388.         lcd.locate(55, 55);
  389.         lcd.printf("%s C", t.print());
  390.         lcd.locate(45, 140);
  391.         lcd.printf("%s Hpa", p.print());
  392.         lcd.locate(90, 210);
  393.         lcd.printf("%d C", *temp_data);
  394.         lcd.locate(70, 280);
  395.         lcd.printf("%1.2fV", monitor_batery());
  396.        
  397. }
  398. int main() {
  399.         int lock  = 0; 
  400.         pc.baud(9600);    
  401.         pc.cls();
  402.         sensor.init();
  403.         screen();
  404.         intro();
  405.         refresh_buffer();
  406.         lcd_setting();
  407.         wait(5);
  408.                                                                                                                                            
  409.         sensor.setOffsetTemperature(20);
  410.         sensor.setOffsetPressure(-32);
  411.         brain.read((uint32_t)(eeprom_size = 8), (int32_t&) *temp_data);
  412.        
  413.         while (read_user_temp <= 0)
  414.         {
  415.                 while (val <= 0)
  416.                 {
  417.                         input_add_user_define_temperature();
  418.                 }              
  419.         }
  420.         pc.cls();
  421.        
  422.        
  423.         while (1)
  424.         {
  425.                 val = 0;
  426.                
  427.                 sensor.readTemperature(&t);
  428.                 sensor.setModeStandby();
  429.                 sensor.setModeBarometer();
  430.                 sensor.setModeActive();
  431.                 sensor.readPressure(&p);
  432.                
  433.                 screen();
  434.                 intro();
  435.                 labels_rs232();
  436.                 labels_lcd();
  437.                 string temp_cache = t.print();
  438.                 rs232_write_data();
  439.                 lcd_write_data();
  440.                
  441.                
  442.                 alarm_temp(temp_cache);
  443.                 main_menu_legend_rs232();
  444.                 serials();
  445.                 alarm_power(3.38);
  446.                 key_menu_main();
  447.                 rs232_menu();
  448.                 menu_main();
  449.                 sensor.setModeStandby();
  450.                 sensor.setModeAltimeter();
  451.                 sensor.setModeActive();
  452.         }
  453. }

odpowiedź "termometr"

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

captcha