termometr

z foreste, 2 lata temu, napisane w C++, wyświetlone 114 razy. [paste_expire] 1 sekunda.
URL https://codetab.e3x.pl/view/c0a2a307 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, 1);
  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() >= 3000)  && (licznik3.read_ms() <= 4000))
  109.                 {
  110.                         menu_select_option = 3;
  111.                         val3 = 1;
  112.                 }
  113.                 if (licznik3.read_ms() >= 4000)
  114.                 {
  115.                         menu_select_option = 0;
  116.                         licznik3.reset();
  117.                 }
  118.         }
  119.         else
  120.         {
  121.                 val3 = 0;
  122.                 licznik3.stop();
  123.                 licznik3.reset();
  124.         }
  125.  
  126. }
  127.  
  128. void menu_main()
  129. {
  130.         if (( val3 == 0) && (menu_select_option == 1))
  131.         {
  132.                 val2 = 1;
  133.         }
  134.         if ((val3 == 0) && (menu_select_option == 2))
  135.         {
  136.                 licznik4.start();
  137.                 lcd_light = 0;
  138.                 if (licznik4.read() >= 5)
  139.                 {
  140.                         menu_select_option = 0;
  141.                         lcd_light = 1;
  142.                         licznik4.stop();
  143.                         licznik4.reset();
  144.                 }
  145.         }
  146.          
  147.         if ((val3 == 0) && (menu_select_option == 3))
  148.         {
  149.                 licznik4.start();
  150.                 monitor_batery_light();
  151.                 if (licznik4.read() >= 8)
  152.                 {
  153.                         menu_select_option = 0;
  154.                         Red_diode = 1; Green_diode = 1;
  155.                         licznik4.stop();
  156.                         licznik4.reset();
  157.                 }
  158.         }
  159. }
  160. void refresh_buffer()
  161. {
  162.         for (int y = 0; y < sizeof(buffer); y++)
  163.                 buffer[y] = 0;
  164.         for (int z = 0; z < sizeof(dane); z++)
  165.                 dane[z] = 0;
  166. }              
  167.  
  168. void serials()
  169. {
  170.         if (pc.readable())
  171.         {
  172.                 pc.scanf("%s", buffer);
  173.         }
  174. }
  175.  
  176. void signaller()
  177. {
  178.         licznik.start();
  179.        
  180.         if (licznik.read_ms() >= 1000)
  181.         {
  182.                 buzzer = !buzzer;
  183.                 licznik.reset();
  184.         }
  185.        
  186. }
  187.  
  188. void alarm_power(float voltage_limit_definition)
  189. {
  190.         if (monitor_batery() <= voltage_limit_definition)
  191.         {
  192.                 if (lock <= 4)
  193.                 {
  194.                         licznik2.start();
  195.                                
  196.                         if (licznik2.read_ms() >= 1500)
  197.                         {
  198.                                        
  199.                                 buzzer = !buzzer;
  200.                                 licznik2.reset();
  201.                                        
  202.                         }
  203.                         lock++;
  204.                 }
  205.         }
  206.         if (voltage_limit_definition <= monitor_batery())
  207.         {
  208.                 lock = 0;
  209.                 licznik2.stop();
  210.                 licznik2.reset();
  211.         }
  212. }
  213.  
  214. void alarm_temp(string  & temp_read_input)
  215. {
  216.         string str = temp_read_input;
  217.         temperature_live_state = atoi(str.c_str());
  218.         if (val2 == 0)
  219.         {
  220.                 if (temperature_live_state >= *temp_data)
  221.                 {
  222.                         signaller();
  223.                 }
  224.         }
  225.         if (*temp_data - temperature_live_state == 1)
  226.         {
  227.                 val2 = 0;
  228.         }
  229.         if (*temp_data > temperature_live_state)
  230.         {
  231.                 buzzer = 0;
  232.                 licznik.stop();
  233.                 licznik.reset();
  234.         }
  235.        
  236. }
  237.  
  238. void screen()
  239. {
  240.         pc.foreground(0xFFFF00);
  241.         pc.hideCursor();
  242. }
  243. void main_menu_legend_rs232()
  244. {
  245.         pc.locate(25, 12);
  246.         pc.printf("Menu główne konsoli - komendy:");
  247.         pc.locate(22, 13);
  248.         pc.printf("\"alarm\"  Ustawienie alarmu");
  249.         pc.locate(22, 14);
  250.         pc.printf("\"wycisz\" Wyłaczenie alarmu");
  251.         pc.locate(22, 15);
  252.         pc.printf("\"reset\"  Ponownie uruchomienie");
  253. }
  254. void intro()
  255. {
  256.         pc.locate(15, 5);
  257.         pc.printf(" ** inteligentny Termometr   ** ");
  258.         pc.locate(15, 6);
  259.         pc.printf("Created by Foreste");
  260. }
  261. void labels_rs232()
  262. {
  263.         pc.locate(10, 7);
  264.         pc.printf("Temperatura");
  265.         pc.locate(25, 7);
  266.         pc.printf("Cisnienie");
  267.         pc.locate(38, 7);
  268.         pc.printf("otrzezenie wysokiej temp");
  269.         pc.locate(65, 7);
  270.         pc.printf("Bateria");
  271. }
  272.  
  273. void labels_lcd()
  274. {
  275.         lcd.set_font_zoom(3, 3);
  276.         lcd.locate(10, 7);
  277.         lcd.printf("Temperatura");
  278.         lcd.locate(25, 90);
  279.         lcd.printf("Cisnienie");
  280.         lcd.locate(30, 175);
  281.         lcd.printf("Alarm temp");
  282.         lcd.locate(52, 235);
  283.         lcd.printf("Bateria");
  284. }
  285. void input_add_user_define_temperature()
  286. {
  287.         int tempint;
  288.         refresh_buffer();
  289.        
  290.         screen();
  291.         intro();
  292.         pc.locate(1, 7);
  293.         pc.printf("Wpisz wartość temperatury ,po której termometr bedzie sygnalizował przekroczenie");
  294.        
  295.         if (pc.readable())
  296.         {
  297.                 pc.scanf("%s", dane);
  298.                
  299.         }      
  300.        
  301.        
  302.         for (int   z = 0; z < 4; z++)
  303.         {
  304.                
  305.                 if (isdigit(dane[z]))//sprawdzanie czy znak jest liczbą
  306.                 {
  307.        
  308.                         tempint = atoi(dane);  //kowertowanie tablicy typu char na zmienną int
  309.                                
  310.                 }
  311.         }
  312.        
  313.                  
  314.         *temp_data = tempint;
  315.         if ((*temp_data >= 1) && (*temp_data <= 99))
  316.         {
  317.                
  318.                 if ((*temp_data >= 12) && (*temp_data <= 40))
  319.                 {
  320.                         pc.cls();
  321.                         screen();
  322.                         intro();
  323.                         brain.write(eeprom_size = 8, (int32_t) *temp_data);
  324.                         pc.locate(20, 7);
  325.                         pc.printf("Zapisalem podaną temperature przekroczenia");
  326.                         wait(5);
  327.                         val = 1;
  328.                         refresh_buffer();
  329.                         pc.cls();
  330.                                
  331.                 }
  332.                 else
  333.                 {
  334.                         pc.cls();
  335.                         screen();
  336.                         intro();
  337.                         pc.locate(20, 7);
  338.                         pc.printf("Wpisano niepoprawne dane. Dopuszczalny zakres: od 12 do 40");
  339.                         wait(5);
  340.                         pc.cls();
  341.                        
  342.                 }
  343.         }
  344. }
  345. void mute()
  346. {
  347.         pc.cls();
  348.         intro();
  349.         val2 = 1;
  350.         pc.locate(10, 7);
  351.         pc.printf("Alarm został wyłączony");
  352.         wait(2);
  353.         refresh_buffer();
  354. }
  355. void reset()
  356. {
  357.         pc.cls();
  358.         intro();
  359.         pc.locate(15, 7);
  360.         pc.printf("Zachwile nastąpi ponowne uruchomienie");
  361.         wait(2);
  362.         NVIC_SystemReset();
  363. }
  364. void rs232_menu()
  365. {
  366.        
  367.         if (strcmp(buffer, "wycisz") == 0)
  368.         {
  369.                 mute();
  370.         }
  371.         if (strcmp(buffer, "reset") == 0)
  372.         {
  373.                 reset();
  374.         }
  375.         else if (strcmp(buffer, "alarm") == 0)
  376.         {
  377.                 pc.cls();
  378.                 while (val <= 0)
  379.                 {
  380.                         input_add_user_define_temperature();
  381.                 }
  382.         }
  383.        
  384. }
  385. void lcd_setting()
  386. {
  387.         lcd.background(Black);
  388.         lcd.foreground(White);
  389. }
  390. void rs232_write_data()
  391. {
  392.         pc.locate(10, 9);
  393.         pc.printf("%s C", t.print());
  394.         pc.locate(25, 9);
  395.         pc.printf("%s Hpa", p.print());
  396.         pc.locate(45, 9);
  397.         pc.printf("%d", *temp_data);
  398.         pc.locate(65, 9);
  399.         pc.printf("%1.2fV", monitor_batery());
  400.        
  401. }
  402.  
  403. void lcd_write_data()
  404. {
  405.         lcd.set_font_zoom(3, 2);
  406.         lcd.locate(55, 55);
  407.         lcd.printf("%s C", t.print());
  408.         lcd.locate(45, 140);
  409.         lcd.printf("%s Hpa", p.print());
  410.         lcd.locate(90, 210);
  411.         lcd.printf("%d C", *temp_data);
  412.         lcd.locate(70, 280);
  413.         lcd.printf("%1.2fV", monitor_batery());
  414.        
  415. }
  416. int main() {
  417.         int lock  = 0; 
  418.         pc.baud(9600);    
  419.         pc.cls();
  420.         sensor.init();
  421.         screen();
  422.         intro();
  423.         refresh_buffer();
  424.         lcd_setting();
  425.         wait(5);
  426.                                                                                                                                            
  427.         sensor.setOffsetTemperature(20);
  428.         sensor.setOffsetPressure(-32);
  429.         brain.read((uint32_t)(eeprom_size = 8), (int32_t&) *temp_data);
  430.        
  431.         while (read_user_temp <= 0)
  432.         {
  433.                 while (val <= 0)
  434.                 {
  435.                         input_add_user_define_temperature();
  436.                 }              
  437.         }
  438.         pc.cls();
  439.        
  440.        
  441.         while (1)
  442.         {
  443.                 val = 0;
  444.                
  445.                 sensor.readTemperature(&t);
  446.                 sensor.setModeStandby();
  447.                 sensor.setModeBarometer();
  448.                 sensor.setModeActive();
  449.                 sensor.readPressure(&p);
  450.                
  451.                 screen();
  452.                 intro();
  453.                 labels_rs232();
  454.                 labels_lcd();
  455.                 string temp_cache = t.print();
  456.                 rs232_write_data();
  457.                 lcd_write_data();
  458.                
  459.                
  460.                 alarm_temp(temp_cache);
  461.                 main_menu_legend_rs232();
  462.                 serials();
  463.                 alarm_power(3.38);
  464.                 key_menu_main();
  465.                 rs232_menu();
  466.                 menu_main();
  467.                 sensor.setModeStandby();
  468.                 sensor.setModeAltimeter();
  469.                 sensor.setModeActive();
  470.         }
  471. }

odpowiedź "termometr"

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

captcha