stacja meteo

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

odpowiedź "stacja meteo"

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

captcha