[IO Development Notes] smart cloud intelligent watering device practice (1) - Basic demo implementation

One , Total system design

The system is mainly composed of three parts ： Sensing execution part 、 Wireless communication part , Smart cloud self-service development platform . The sensing execution part is controlled by the main control unit 、 Display unit 、 And storage unit . The sensor detection part collects the information of air environment parameters , And process the collected sensor data in real time , Then send the data to the wireless communication module .

The wireless communication part is esp8266 module , It is also a post station for all information interaction , All collected information and control information are transmitted with the cloud platform through the wireless communication module . Data is passed through WIF The introduction module sends the data to the cloud platform , Cloud platform data can be synchronized to mobile phones or other mobile devices . On the smart cloud platform are user-defined data points, which can record local sensor data in real time and control local devices . The overall design drawing is shown in the figure 1.

 

 

Two , System function introduction

Use smart cloud self-service development platform ,ESP8266 Module networking , Realize environmental humidity detection , Ambient light intensity detection ,OLED The screen displays data . The relay can be automatically and remotely controlled and timed . Remote viewing of environmental parameters , Modify threshold parameters remotely .

 

3、 ... and , Intelligent hardware self-service development selects the machine intelligence cloud platform

 

Wit cloud AIoT Self service development platform , Adopt microservice architecture , There will be a lot of IoT Technical principle 、 Industry knowledge 、 Basic model regularization 、 Software 、 modularization , Through stupid development tools 、MCU Automatic code generation 、APP Open source framework 、IoTSDK、 to open up API, Minimize IoT Technical threshold and development cost of equipment development , Improve development 、 test 、 Deployment efficiency , Has served more than 320000+ developer .

 

Smart cloud self-service development platform - Development tool GAgent

GAgent- Standard serial communication program , Accelerate the development process of intelligent device networking ,1 The equipment docking platform can be completed within days .GAgent Is running on the WiFi/ bluetooth /5G/4G/NB-IOT And other communication module applications , Enable the communication module to actively connect to the enabling platform server , And realize the communication with the cloud . Integrate the communication module on the control circuit board of the developer's product , Only need to realize the serial communication with the communication module （ Code auto generation ）, You can directly access the enabling platform server , There is no need for the network thread transmission at the bottom of the key .

Four , Project folder frame

5、 ... and , Core board schematic diagram

6、 ... and ,LED Lamp driver code writing

Schematic diagram

7、 ... and , Code implementation

1. #include "led.h"
2. #include "systick.h"
4. void LED_Init(void)
5. {
6.         RCC_APB2PeriphClockCmd(LED1_CLK, ENABLE);        
7.         RCC_APB2PeriphClockCmd(LED2_CLK, ENABLE);        
8.         RCC_APB2PeriphClockCmd(LED3_CLK, ENABLE);        
9.         
10.         GPIO_InitTypeDef            LED_InitStruct = {0};
11.         
12.         LED_InitStruct.GPIO_Pin   = LED1_PIN;
13.         LED_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;                 
14.         LED_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;        
15.         
16.         GPIO_Init(LED1_PORT, &LED_InitStruct);
17.         
18.         LED_InitStruct.GPIO_Pin   = LED2_PIN;
19.         GPIO_Init(LED2_PORT, &LED_InitStruct);
20.         
21.         LED_InitStruct.GPIO_Pin   = LED3_PIN;
22.         GPIO_Init(LED3_PORT, &LED_InitStruct);
23.         
24.         LED1(0);  
25.   LED2(0);
26.         LED3(0);
27. }
29. void LED_Task(void)
30. {
31.         static uint32_t Timer = 0;
32.         static uint8_t  Sta   = 0;
33.         if(SoftTimer(Timer,500))
34.         {
35.                 Timer=GetSoftTimer();
36.                 Sta?(Sta=0):(Sta=1);
37.                 LED1(Sta);
38.                 LED2(Sta);
39.                 LED3(Sta);
40.         }
41. }
43. void GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
44. {
45.         uint32_t ODR;
46.         ODR = GPIOx->ODR;
47.         GPIOx->BSRR = ((ODR & GPIO_Pin) << 16U) | (~ODR & GPIO_Pin);
48. }

Copy code

1. #ifndef __LED_H_
2. #define __LED_H_
4. #include "STM32f10x.h"
7. //PB9  --- LED1   --- Low efficiency
8. //PB8  --- LED2   --- Low efficiency
9. //PA3  --- LED3   --- Low efficiency
11. // be based on STM32 Standard library    The chip is STM32F103C8T6
15. #define LED1_CLK  RCC_APB2Periph_GPIOB
16. #define LED1_PORT GPIOB
17. #define LED1_PIN  GPIO_Pin_9
19. #define LED2_CLK  RCC_APB2Periph_GPIOB
20. #define LED2_PORT GPIOB
21. #define LED2_PIN  GPIO_Pin_8
23. #define LED3_CLK  RCC_APB2Periph_GPIOA
24. #define LED3_PORT GPIOA
25. #define LED3_PIN  GPIO_Pin_3
28. // A switch defined by a macro
29. #define LED1(X)  X?(GPIO_ResetBits(LED1_PORT,LED1_PIN)):(GPIO_SetBits(LED1_PORT,LED1_PIN))
30. #define LED2(X)  X?(GPIO_ResetBits(LED2_PORT,LED2_PIN)):(GPIO_SetBits(LED2_PORT,LED2_PIN))
31. #define LED3(X)  X?(GPIO_ResetBits(LED3_PORT,LED3_PIN)):(GPIO_SetBits(LED3_PORT,LED3_PIN))
33. void LED_Init(void);
34. void GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
35. void LED_Task(void);
37. #endif

Copy code

Key driven code writing

Schematic diagram

Code implementation

1. #include "key.h"
2. #include "systick.h"
4. void KEY_Init(void)
5. {
6.         RCC_APB2PeriphClockCmd(KEY0_CLK,ENABLE);
7.         RCC_APB2PeriphClockCmd(KEY1_CLK,ENABLE);
8.         RCC_APB2PeriphClockCmd(KEY2_CLK,ENABLE);
9.         
10.         GPIO_InitTypeDef            KEY_InitStruct;
11.         KEY_InitStruct.GPIO_Pin   = KEY0_PIN|KEY1_PIN|KEY2_PIN;
12.         KEY_InitStruct.GPIO_Mode  = GPIO_Mode_IPU;      
13.         KEY_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
14.         
15.         GPIO_Init(KEY0_PORT ,&KEY_InitStruct);
16.         GPIO_Init(KEY1_PORT ,&KEY_InitStruct);
17.         GPIO_Init(KEY2_PORT ,&KEY_InitStruct);
18.         
19. }
22. static uint8_t Key0Value=0;
23. static uint8_t Key1Value=0;
24. static uint8_t Key2Value=0;
26. void KeyScan(void)
27. {
28.         static uint16_t Key0Timer=0;
29.         static uint16_t Key1Timer=0;
30.         static uint16_t Key2Timer=0;
31.         if(KEY0==0)
32.         {
33.                 if(Key0Timer<10)
34.                 {
35.                         Key0Timer++;
36.                         if(Key0Timer>=10)
37.                                 Key0Value=1;
38.                 }        
39.         }
40.         else
41.         {
42.                 Key0Timer = 0;
43.         }
44.         if(KEY1==0)
45.         {
46.                 if(Key1Timer<10)
47.                 {
48.                         Key1Timer++;
49.                         if(Key1Timer>=10)
50.                                 Key1Value=1;
51.                 }        
52.         }
53.         else
54.         {
55.                 Key1Timer = 0;
56.         }
57.         if(KEY2==0)
58.         {
59.                 if(Key2Timer<10)
60.                 {
61.                         Key2Timer++;
62.                         if(Key2Timer>=10)
63.                                 Key2Value=1;
64.                 }        
65.         }
66.         else
67.         {
68.                 Key2Timer = 0;
69.         }
70. }
73. uint8_t GetKey0(void)
74. {
75.         uint8_t Key=Key0Value;
76.         Key0Value=0;
77.         return Key;
78. }
80. uint8_t GetKey1(void)
81. {
82.         uint8_t Key=Key1Value;
83.         Key1Value=0;
84.         return Key;
85. }
87. uint8_t GetKey2(void)
88. {
89.         uint8_t Key=Key2Value;
90.         Key2Value=0;
91.         return Key;
92. }

Copy code

1. #ifndef __KEY_H_
2. #define __KEY_H_
4. #include "stm32f10x.h"
6. #define KEY0_CLK         RCC_APB2Periph_GPIOA                        
7. #define KEY0_PORT                     GPIOA                        
8. #define KEY0_PIN                     GPIO_Pin_0
10. #define KEY1_CLK         RCC_APB2Periph_GPIOA                        
11. #define KEY1_PORT                     GPIOA                        
12. #define KEY1_PIN                     GPIO_Pin_1
14. #define KEY2_CLK         RCC_APB2Periph_GPIOA                        
15. #define KEY2_PORT                     GPIOA                        
16. #define KEY2_PIN                     GPIO_Pin_2
18. #define KEY0             GPIO_ReadInputDataBit(KEY0_PORT,KEY0_PIN)           
19. #define KEY1             GPIO_ReadInputDataBit(KEY1_PORT,KEY1_PIN)     
20. #define KEY2             GPIO_ReadInputDataBit(KEY2_PORT,KEY2_PIN)     
22. void KEY_Init(void);
23. void KeyScan(void);
24. uint8_t GetKey0(void);
25. uint8_t GetKey1(void);
26. uint8_t GetKey2(void);
27. #endif
28. <b>
29. </b>

Copy code

Test the correctness of the driver

1. #include "main.h"
2. int main(void)
3. {
4.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
5.         USART1_Init(9600);        
6.         //printf(" Print serial port initialization OK !\r\n");        
7.   SysTick_Init();   
8.   //printf(" The system clicks to initialize OK !\r\n");        
9.         LED_Init();  
10.   //printf(" Status indication initialization OK !\r\n");               
11.   KEY_Init();
12.   //printf(" Key configuration initialization OK !\r\n");        
13.         while(1)
14.         {        
15.                 LED_Task();        
16.                 if(GetKey0())
17.                 {
18.                         GPIO_TogglePin(LED1_PORT,LED1_PIN);
19.                         //JiaoHua(1-currentDataPoint.valueRelay_1);
20.                 }
21.                 if(GetKey1())
22.                 {
23.                         GPIO_TogglePin(LED2_PORT,LED2_PIN);
24.                         //gizwitsSetMode(WIFI_AIRLINK_MODE);
25.                         // Press the key to enter the distribution network mode
26.                 }
27.                 if(GetKey2())
28.                 {
29.                         GPIO_TogglePin(LED3_PORT,LED3_PIN);
30.                 }
31.         }
32. }

Copy code

Other auxiliary codes

Serial port printing implementation

On the development board USB TO TTL Tools A serial port 1 Print The circuit is not designed on the actual project board （ error 1）

A serial port 1 Driver code

1. #include "usart1.h"
2. #include <stdio.h>
4. void USART1_NVIC_Config(void)
5. {
6.   // Receive interrupt enable
7.         NVIC_InitTypeDef  NVIC_InitStruct;
8.         /*NVIC Controller configuration */
9.         NVIC_InitStruct.NVIC_IRQChannel    = USART1_IRQn;// Specific interrupt source name
10.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;//NVIC Response channel enable
11.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;// Preemption priority value
12.         NVIC_InitStruct.NVIC_IRQChannelSubPriority        = 1;// Response priority value
13.   NVIC_Init(&NVIC_InitStruct);
14.         
15. }
17. /* Print debug serial port */
18. void USART1_Init(uint32_t BaudRate)
19. {
20.         USART_DeInit(USART1);
21.         //1. open GPIO The clock of
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
23.         
24.         //2. Configure related structures
25.         GPIO_InitTypeDef           GPIO_InitStruct;
26.         
27.         // Configuration of serial port sending pin          PA9-> Multiplexing push pull output
28.         GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_9;      
29.         GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_PP;
30.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
31.         GPIO_Init(GPIOA,&GPIO_InitStruct);
32.         
33.         // Configuration of serial port receiving pin         PA10-> Floating input mode
34.         GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_10;      
35.         GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IN_FLOATING;// Floating input mode
36.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
37.         GPIO_Init(GPIOA,&GPIO_InitStruct);
38.         
39.         //1. Turn on the clock of the serial port
40.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);// Be careful APB2
41.         
42.         USART_InitTypeDef USART1_InitStruct;
43.         // Serial port parameter configuration       The baud rate can be changed    
44.         // No hardware flow control        Transceiver mode   
45.         //1 Start bit 8 Data bits No parity 1 Bit stop bit
46.         USART1_InitStruct.USART_BaudRate            = BaudRate;
47.         USART1_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
48.         USART1_InitStruct.USART_Mode                = USART_Mode_Rx|USART_Mode_Tx;
49.         USART1_InitStruct.USART_Parity              = USART_Parity_No;
50.         USART1_InitStruct.USART_StopBits            = USART_StopBits_1;
51.         USART1_InitStruct.USART_WordLength          = USART_WordLength_8b;
52.         // A serial port 1 initialization
53.         USART_Init(USART1,&USART1_InitStruct);
54.         
55.         /*******************/
56.         // Open serial port interrupt
57.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);// Receive interrupt
58.         //USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);// Idle interrupt
59.         // Interrupt priority configuration
60.         USART1_NVIC_Config();
61.         USART_Cmd(USART1,ENABLE);
62. }
65. /* Serial port redirection function The goal is to make STM32 Support printf("%d %x %c ")*/
66. int fputc(int ch , FILE *stream)
67. {
68.         while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
69.         USART_SendData(USART1,(uint16_t) ch); // Data is sent through serial port
70.         while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
71.         return ch;        
72. }

Copy code

1. #ifndef __USART1_H_
2. #define __USART1_H_
4. #include "stm32f10x.h"
6. void USART1_Init(uint32_t BaudRate);
8. #endif

Copy code

System tick timer code

1. #include "systick.h"
2. #include "key.h"
5. uint32_t mySysTick_Config(uint32_t ticks)
6. {
7.   if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
8.                                                                
9.   SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
10.   NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Cortex-M0 System Interrupts */
11.   SysTick->VAL   = 0;                                          /* Load the SysTick Counter Value */
12.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
13.                    SysTick_CTRL_TICKINT_Msk   |
14.                    SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
15.   return (0);                                                  /* Function successful */
16. }
18. void SysTick_Init(void)
19. {
20.         //SystemInit();
21.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
22.         mySysTick_Config(SystemCoreClock/1000);
23. }
24. void SysTick_Handler(void)
25. {
26.         SystemTick();
27.         KeyScan();
28. }
29. static uint32_t Ticks=0;
30. void SystemTick(void)
31. {
32.         Ticks++;
33. }
34. uint32_t GetSoftTimer(void)
35. {
36.         return Ticks;
37. }
38. uint8_t SoftTimer(uint32_t BaseTimer,uint32_t Timeout)
39. {
40.         if(Ticks>=BaseTimer)
41.         return (Ticks)>=Timeout+BaseTimer;
42.         return (Ticks+0xFFFFFF)>=Timeout+BaseTimer;
43. }

Copy code

 

To be continued

Smart cloud intelligent watering device actual combat (2)- Basics Demo Realization -
Relay implementation / A functional test /DHT11 Driver code implementation /OLED The screen displays sensor data / Chinese font making and so on