Web server on STM32F4DISCOVERY using Murata SN8200 Wi-Fi Network Controller Module

Instead of PC based servers, stm32 microcontroller may be used along with WiFi module as Embedded Web Server. The basic idea is utilizing this microcontroller for monitoring and controlling an embedded system  through a web application. Without using a computer, WiFi module can communicate to the owner of the overall system which is able to manage appliances from any location outside.

In this demonstration the server is still listening for incoming connections. Once a client connects to the server, it sends back a web page. This page (Fig. 1) allows to the client to control the four LEDs: LED1, LED2, LED3 and LED4 of the STM32F4-DISCOVERY board as it's shown in (Fig. 2).

Fig. 1. Web page for LEDs control

Fig. 2.STM32F4-DISCOVERY

In this application I used client-server architecture where the client accesses the server via LAN and Internet router. The client sends the request to the server. This request is processed by the router to connect to the Internet. The web processes the made request and finally the client connects to the desired web server. Requested data is sent to the client.

Each time the client select the LEDs to turn on, he presses the button "Send" to confirm his request. This request is a GET request which contain the ID of the LEDs to turn on or off.
For example, if the client selects LED1 and LED2, the request that will be send in this form :

"GET /leds.cgi?led=1&led=2 HTTP/1.1"

You can find a quick video demonstration  on YouTube.

Générer un signal PWM avec un STM32F4

PWM ou Pulse Width Modulation est la technique utilisée pour générer des signaux analogiques à partir d'un appareil numérique. Dans ce tutoriel, nous allons apprendre les bases de la technique PWM et nous verrons comment mettre en œuvre la génération d'un signal PWM avec le micro-contrôleur STM32F4DISCOVERY et aussi avec le système temps réel ChibiOS/RT.

     1- Principe de base du PWM : 

Un appareil numérique, comme un micro-contrôleur STM32 ou autres (PIC , Arduino ..)ne peut générer que deux niveaux sur ses lignes de sortie, soit un niveau haut égale à 5v ou 3.3v selon le micro-contrôleur que vous utilisez soit un niveau bas égale à 0V. Mais que faire si nous voulons générer 0.7v ou 2.9V ou n'importe quelle tension de sortie entre 0-V+ ? 

Pour ce genre de condition, au lieu de générer une sortie de tension continue, nous générons une onde carrée comme montre la figure.

Donc vous pouvez remarquer que si le pourcentage du temps au niveau haut augmente la tension moyenne à la sortie augmente . Ainsi, si cette sortie est reliée à un moteur ou à une LED lumineuse et on suppose que le rapport cyclique (pulse width) est à 25% de la période, il tourne à 25% de la vitesse maximale à V+ de même pour la LED sa luminosité sera à 25% de la luminosité maximale à V+. 

Pour conclure, l'astuce consiste à faire varier le rapport cyclique entre 0-100% et obtenir le même pourcentage de la tension d'entrée à la sortie.

     2- Programmer un signal PWM avec les librairies STM32 :

À partir du user manual stm32f4 on remarque que les 4 LEDs de l'stm32f4 sont connectés au port entrée sortie D avec les pins PD12,PD13,PD14 et PD15 et ces derniers sont aussi liés à des canaux PWM de 16 bits du timer 4.

Voici un programme qui génère 4 signaux pwm avec leurs configurations et le calculer de la période et des rapports cycliques.

#include "stm32f4_discovery.h" /*GPIO structure to initialize port*/ GPIO_InitTypeDef gpio; /*TIM_TimeBaseInitTypeDef structure to initialize TIM Time Base*/ TIM_TimeBaseInitTypeDef tim; /*TIM_OCInitTypeDef structure to initialize TIM Output Compare*/ TIM_OCInitTypeDef tim_oc; uint16_t prescaler = 0; int main(void) { /* TIM3 clock enable */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); /* GPIOD clock enable */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); /* GPIOD Configuration: TIM4 CH1 (PD12) (green LED) TIM4 CH2 (PD13) (orange LED) TIM4 CH3 (PD14) (red LED) TIM4 CH4 (PD15) (bleu LED) */ gpio.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_Speed = GPIO_Speed_100MHz; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOD, &gpio); /* Connect TIM4 pins to AF2 */ GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4); GPIO_PinAFConfig(GPIOD, GPIO_PinSource13, GPIO_AF_TIM4); GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_TIM4); GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_TIM4); /* ------------------------------------------------------------- TIM4 Configuration: generate 4 PWM signals with 4 different duty cycles. In this example, SystemCoreClock is equal to 168 MHz and is defined in system_stm32f4xx.c file. In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1), since APB1 prescaler is different from 1. TIM3CLK = 2 * PCLK1 PCLK1 = HCLK / 4 => TIM3CLK = HCLK / 2 = SystemCoreClock /2 To get TIM3 counter clock at 10 KHz, the prescaler is computed as follows: Prescaler = (TIM3CLK / TIM3 counter clock) - 1 Prescaler = ((SystemCoreClock /2) /10 KHz) - 1 To get TIM3 output clock at 1 Hz, the period (ARR)) is computed as follows: ARR = (TIM3 counter clock / TIM3 output clock) - 1 = 9999 --------------------------------------------------------------- */ /* Compute the prescaler value */ prescaler = (uint16_t) ((SystemCoreClock /2) / 10000) - 1; /* Time base configuration */ tim.TIM_Prescaler = prescaler; tim.TIM_CounterMode = TIM_CounterMode_Up; tim.TIM_Period = 9999; tim.TIM_ClockDivision = 0; TIM_TimeBaseInit(TIM4, &tim); /* PWM1 Mode configuration: Channel 1 */ tim_oc.TIM_OCMode = TIM_OCMode_PWM1; tim_oc.TIM_OutputState = TIM_OutputState_Enable; tim_oc.TIM_Pulse = 3900; tim_oc.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM4, &tim_oc); TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable); /* PWM1 Mode configuration: Channel 2 */ tim_oc.TIM_Pulse = 410; tim_oc.TIM_OutputState = TIM_OutputState_Enable; TIM_OC2Init(TIM4, &tim_oc); TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable); /* PWM1 Mode configuration: Channel 3 */ tim_oc.TIM_Pulse = 7000; tim_oc.TIM_OutputState = TIM_OutputState_Enable; TIM_OC3Init(TIM4, &tim_oc); TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable); /* PWM1 Mode configuration: Channel 4 */ tim_oc.TIM_Pulse = 9000; tim_oc.TIM_OutputState = TIM_OutputState_Enable; TIM_OC4Init(TIM4, &tim_oc); TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable); TIM_ARRPreloadConfig(TIM4, ENABLE); /* TIM3 enable counter */ TIM_Cmd(TIM4, ENABLE); while (1) {} }

     3- Programmer un signal PWM avec systéme temps réel ChibiOS/RT:

ChibiOS / RT est conçu pour les applications profondément ancrées en temps réel où l'efficacité et l'exécution du code compact sont des exigences importantes. 

Il peut être utiliser dans de nombreux domaines applicatifs, par exemple:

• Les applications robotiques.
• L'enseignement et l'apprentissage de la technologie RTOS.

Pour avoir plus de détail sur ce système temps réel vous pouvez visiter ChibiOS/RT Homepage ou encore Getting started with the STM32F4-Discovery board and ChibiOS/RT.

Revenons à notre application  pour générer des signaux PWM la couche HAL (Hardware Abstraction Layer) dans ChibiOS/RT fournit un mécanisme très simple.

Et voici un programme très simple qui génère 4 signaux pwm.

#include "ch.h" #include "hal.h" static PWMConfig pwmcfg = { 7000, /* Timer clock in 7 Hz */ 5000, /* PWM period in ticks(0,5 second) */ NULL, /* Periodic callback pointer. */ { {PWM_OUTPUT_ACTIVE_HIGH, NULL}, /* Channels configurations. */ {PWM_OUTPUT_ACTIVE_HIGH, NULL}, {PWM_OUTPUT_ACTIVE_HIGH, NULL}, {PWM_OUTPUT_ACTIVE_HIGH, NULL}, }, 0 }; int main(void) { /* HAL initialization. */ halInit(); /* ChibiOS/RT initialization. */ chSysInit(); /* GPIOD Configurations: TIM4 CH1 (PD12) (green LED) TIM4 CH2 (PD13) (orange LED) TIM4 CH3 (PD14) (red LED) TIM4 CH4 (PD15) (bleu LED) */ palSetPadMode(GPIOD, GPIOD_LED3, PAL_MODE_ALTERNATE(2));/* Orange LED. */ palSetPadMode(GPIOD, GPIOD_LED4, PAL_MODE_ALTERNATE(2));/* Green LED. */ palSetPadMode(GPIOD, GPIOD_LED5, PAL_MODE_ALTERNATE(2));/* Red LED. */ palSetPadMode(GPIOD, GPIOD_LED6, PAL_MODE_ALTERNATE(2));/* Blue LED. */ /* Configures and activates the PWM peripheral. */ /* The driver PWMD4 allocates the timer TIM4 when enabled. */ pwmStart(&PWMD4, &pwmcfg); /* Enables a PWM channel. */ /* &PWMD4 is a pointer to a @p PWMDriver object */ /* 3..0 is PWM channel identifier (0...PWM_CHANNELS-1)*/ /* 500,100,1000,1500 are PWM pulse width as clock pulses number */ pwmEnableChannel(&PWMD4, 3, 100); pwmEnableChannel(&PWMD4, 2, 700); pwmEnableChannel(&PWMD4, 1, 3000); pwmEnableChannel(&PWMD4, 0, 5000); while (TRUE) { } }

La vidéo ci-dessous montre que l'STM32F4 génère 4 signaux pwm et comme les canaux des timers 4 sont relié aux LEDs donc on peut voir nos signaux à travers ces LEDs: