termometr

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

odpowiedź "termometr"

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

captcha