---
# System prepended metadata

title: 'Compte rendu TP IOT :'

---

# Compte rendu TP IOT : 

## I. 01_GPIO

Dans ce tp nous devions faire en sorte que des leds s'allume grace a un script sur SystemeWorkbench (SW).

Pour commencer, nous devions choisir notre carte dans CubeMx puis nous devions initialisé les pins des leds.

Il faut ensuite configurer le projet pour qu'il se génère correctement dans cubeMx (CMx).

![](https://i.imgur.com/Y0gLH6q.png)

Dans CMx, il faut ensuite créer notre code dans la boucle infinie générée par SW.

Il fallait faire 4 schémas différents. (Voir le code dans le fichier).

## II. 02_Timers

Pour ce 2ème TP il fallait faire cligniter des leds grace à des timers.
Dans un 1er temps il fallait choisir notre carte dans SW. Cela fait, nous devions configurer le timer.

Pour ce faire il faut en activer 2 : 
![](https://i.imgur.com/hVbeilY.png)

Une fois cela fait, il faut les configurer comme ceci : 

#### Timer 1 :
![](https://i.imgur.com/Li4kvn9.png)
#### Timer 2 :
![](https://i.imgur.com/OycDwGW.png)

Une fois les timers configurer il nous reste a faire le code, en gardant la même configuration du projet.

Dans le fichier stm32f4xx_it.c, nous devons faire en sorte d'activer les leds grâce au timer. Il faut donc le faire dans le TIM6 ET TIM7, qui sont les 2 timers que nous avons activés.

Dans une deuxieme partie, nous avons aussi regarder sur un oscilloscope les périodes pour vérifier que les timers marchaient.


![](https://i.imgur.com/4NWg7aX.jpg)

## III. 03_Communication

Pour le 3ème TP, il fallait créer une connection avec Putty.
Comme pour les 2 TP d'avant, il faut configurer notre carte.
il faut ensuite activer et configurer un Usart ici Usart2

![](https://i.imgur.com/F4z9N12.png)
![](https://i.imgur.com/6PIxx4i.png)

On peut ensuite lancer le projet dans SW.

Il faut créer 3 variables dans USER CPDE BEGIN : 
```
void write_char(uint8_t car);
void write_txt(uint8_t *txt);
void read_txt(char *txt);
```
Il faut ensuite créer 2 fonction qui recupère et envoie du text dans USER CODE BEGIN 4 : 

```
void ecris_char(uint8_t car){
 HAL_UART_Transmit(&huart2,&car,1,1000);
}
void ecris_txt(uint8_t *txt){
 int i;
 for(i=0;i<strlen(txt);i++) {
 ecris_char(txt[i]);
 }
}
void lis_txt(char *txt) {
txt[0]='\0';
while(!txt[0])
HAL_UART_Receive(&huart2, txt, 1, 1000);
}
```

Enfin, on fait en sorte de pouvoir ecrire dans putty, et que lui nous renvoie du text dans la boucle infinie : 

```
/* USER CODE BEGIN 2 */
  HAL_GPIO_TogglePin(LD3_GPIO_Port, LD3_Pin);
  ecris_char('a');
  char car='a';
  HAL_UART_Transmit(&huart2,(uint8_t *) &car, 1, 1000);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	  //ecris_char('B');
	  char reponse, retour[20];
	  ecris_txt(message);
	  lis_txt(&reponse);
	  sprintf(retour, "Choix=%c\n\r",reponse);
	  ecris_txt(retour);

    /* USER CODE END WHILE */
    MX_USB_HOST_Process();

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}L_UART_Receive(&huart2, txt, 1, 1000);
}
```

## IV. 04_PWM

## V. 05_DAC

Pour le 5ème TP il fallait faire 4 projets avec un timer et un oscilloscope.

Comme d'habitude il faut configurer la carte et le timer ainsi que le DAC sur CMx.

![](https://i.imgur.com/JF5Gr2U.png)


![](https://i.imgur.com/yRZ7ulQ.png)

Sur SW on démarre le DAC avant la boucle infinie et on envoie des valeurs a celui-ci.

Pour le 1er projet, il fallait générer un signal entre 1241 et 2482.

```
while (1)
  {
	 valDac= 2482;
	  HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1,DAC_ALIGN_12B_L, (uint32_t)valDac);
	  HAL_Delay(200);
	  valDac= 1241;
	  HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1,DAC_ALIGN_12B_L, (uint32_t)valDac);
	  HAL_Delay(200);
    /* USER CODE END WHILE */
    MX_USB_HOST_Process();

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 
```

![](https://i.imgur.com/zFuJ4Yw.jpg)

Pour le 2ème il fallait utilisé le timer pour créer un signal de 440 Hz.

![](https://i.imgur.com/6mWuLBO.jpg)

Pour le 3ème il fallait un signal en dent de scie, toujours avec le timer.

![](https://i.imgur.com/mmhwXFt.jpg)

Et enfin pour le dernier, il fallit un signal triangulaire, toujours avec un timer.

```
void TIM6_DAC_IRQHandler(void)
{
  /* USER CODE BEGIN TIM6_DAC_IRQn 0 */
	compteur++;
	//if(compteur<50)
		valDac += 24;
	/*else
		valDac=2482;*/
		if(compteur < 25)
			HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1,DAC_ALIGN_12B_L, (uint32_t)1241 + (compteur * 24));
		else if(compteur > 25)
			HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1,DAC_ALIGN_12B_L, (uint32_t)2482 - (compteur * 24));
	compteur = compteur%50;

  /* USER CODE END TIM6_DAC_IRQn 0 */
  HAL_DAC_IRQHandler(&hdac);
  HAL_TIM_IRQHandler(&htim6);
  /* USER CODE BEGIN TIM6_DAC_IRQn 1 */
  /* USER CODE END TIM6_DAC_IRQn 1 */
}
```

![](https://i.imgur.com/PVRJewK.jpg)

## VI. 06_ADC

Pour le dernier TP il fallait récupérer les données d'un potentiomètre sur putty.

Comme d'habitude, on configure la carte et on active l'usart pour putty.

Pour le potentionmètre, il faut activer un ADC et le configurer de cette façon : 

![](https://i.imgur.com/C6QAEPa.png)

Sur SW, il déclarer l'encienne valeur du potentiomètre avant la boucle.
Dans celle ci, on active l'ADC, on lis la valeur de celui-ci et on le stop.
On fait une condition qui compare la valeur actuelle a l'ancienne, et on envoie notre valeur a Putty.
La valeur actuelle devient ensuite l'ancienne et on recommence.

```
int old_val = 0;
  while (1)
  {
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  int adcData = HAL_ADC_GetValue(&hadc1);
	  HAL_ADC_Stop(&hadc1);
	  int duty = (adcData * 100)/4095;
	  float v = (adcData * 3.3)/4095;
	  if(! proche(adcData, old_val)){
		 sprintf(message,"Valeur ADC: %x -> pourc %d %% -> V = %.2f \n",adcData,duty,v);
		 ecris_txt(message);
		 old_val = adcData;
	  }

	  HAL_Delay(200);
    /* USER CODE END WHILE */
    MX_USB_HOST_Process();
```