termometr

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

odpowiedź "termometr"

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

captcha