SE3Groupe2024-4

Description

Objectif

Concevoir un petit objet affichant le volume sonore en décibels et enregistrant les voix environnantes.

Cahier des charges

Notre système devra :

• afficher le volume en décibels
• Si un certaine valeur est atteinte
  • faire clignoter une LED
  • l'audio est enregisté puis transmis au PC
• allumer une LED en cas de batterie faible

Spécification techniques

• Notre système sera alimenté par batterie et rechargeable/programmable par USB.
• Un écran LCD nous servira à afficher le volume en décibels.
• LED :
  • Pour la batterie
  • Pour l'enregistrement
• Une puce NRF24L01 permettra la reception des données par communication radio.
• Un capteur de son ou microphone servira à récupérer le volume et l'enregistrement.
• Nous utilisons un ATmega32u4 pour la transmission, par un USB de type carte son, des données vers un PC

ReX : rien sur la connexion USB ?!

Lien vers le Gitea du Projet

Carte électronique

Schématique

Chargeur LiPo, Microphone, Ecran et Mode d'Alimentation

suite schématique

La schématique des éléments de notre carte pour le projet.

Nous travaillons donc avec un atmega32u4.

Le câblage a été réalisé selon les différentes datasheets.

Extrait de la datasheet du régulateur

Pour le régulateur, nous nous sommes basés sur la datasheet du LTC5351ES6-3.3 pour le schéma.

Pour le microphone, nous avons décidé d'utiliser un montage constitué d'un transistor pour des raisons d'économie et de praticité.

Pour l'écran, le modèle utilisé est ADM1602K, qui peut marcher en 4 ou 8 bits. Pour des raisons de praticité, nous avons décidé de travailler en 4 bits.

Extrait de la datasheet de l'écran.

On voit sur la datasheet que les pins de 7 à 10 ne sont pas nécessaire. Nous avons alors branché ceux de DB4 à DB7 à notre atmega. Nous les avons mis sur des sorties analogiques, comme nécesssaire selon la datasheet du même produit.

Routage

Le routage nous donne la carte ici présente :

Image globale du routage sur kicad

Image zoomée sur le microcontrôleur

Plan 3D de la carte

On obtient une carte occupée en majeure partie par l'écran.

Autour de l'antenne, nous avons modifié le ground, car selon la datasheet, l'antenne ne doit pas être sur la même base de masse que les autres composant afin d'éviter les interférences.

Réalisation

Lors du routage, nous nous sommes rendu compte d'une erreur lors du choix de l'inductance du régulateur, nous avons donc choisit d’alimenter notre carte en 5V, car les deux composant principaux de notre carte (le micro et l'écran) sont supposé fonctionner en 5V selon leur datasheet.

LEDS

Pour tester les leds, on les fait clignoter avec le programme suivant :

#include <avr/io.h>
#include <util/delay.h>

int main() {
    DDRB |= 1<<PB6 | 1<<PB7;

    while(1) {
    PORTB ^= 1<<PB6 ^ 1<<PB7;
    _delay_ms(10);
    }   
}

On remarque que seul la LED sur PB7 fonctionne.

Pour la suite, nous nous sommes concentré sur la programmation du micro et de l'écran et avons donc mis le NRF et la batterie de coté. La LED sur PB6 ne nous intéresse donc pas.

Voici notre carte soudé avec les composants que nous allons utiliser :

Micro

Pour vérifié le bon fonctionnement du micro, nous avons essayé d'afficher la valeur d'entrée du port analogique PF0 (ADC0)

Pour se faire nous avons utiliser la LUFA et plus précisément la demo VirtualSerial que nous avons modifié pour renvoyer la valeur de PF0.

Dans la fonction SetupHardware nous avons ajouté :

    // Sélectionner la référence de tension pour l'ADC (AVCC)
    ADMUX = (1 << REFS0);
 
    // Activer l'ADC et définir le facteur de division d'horloge
    ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

et dans la fonction CDC_Task :

      // Sélection du canal ADC0
    ADMUX = (1 << REFS0) | (0 & 0x07);

      // Démarrer la conversion ADC
    ADCSRA |= (1 << ADSC);

      // Attendre la fin de la conversion
    while (ADCSRA & (1 << ADSC));

    if(ADC>0) {
        itoa(ADC, ReportString, 10);
        //ReportString = "test\r\n";
    }
    else ActionSent = false;

Malheureusement, minicom n'affichant rien, nous avons opté pour une seconde possibilité faire clignoter une LED lorsque lorsque nous dépassons une certaine valeur

#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>

void ADC_Init() {

    ADMUX = (1 << REFS0);
    ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
}

uint16_t ADC_Read(uint8_t channel) {
    ADMUX = (1 << REFS0) | (channel & 0x07);
    ADCSRA |= (1 << ADSC);
    while (ADCSRA & (1 << ADSC)); 
    return ADC;
}

int main(void) {
    ADC_Init();
    DDRB |= 1<<PB7;
    while (1) {
        uint16_t sensorValue = ADC_Read(0);
        if(sensorValue > 980) PORTB ^= 1<<PB7;
        _delay_ms(10);
    }
}

Nous nous somme donc rendu compte d'un problème : la valeur semble constante (environ 980)

Ecran

Pour l'écran, nous l'avons soudé après le micro. À l'aide de la datasheet et de ressources en ligne, nous avons essayé de faire fonctionner le code suivant sur notre carte :

#include <avr.io>
#include <util/delay.h>

// Définition des broches utilisées pour le LCD, selon notre câblage
#define RS PD0
#define EN PD1
#define D4 PD4
#define D5 PD5
#define D6 PD6
#define D7 PD7


//Fonction du gère les commandes données au LCD
void LCD_Commandgiver(unsigned char comand){
	PORTD = (PORTD & 0x0F) | (comand & 0x0F);
	PORTD &= (1<<EN);
	_delay_ms(1);
	PORTD &= ~(1<<EN);

	_delay_ms(10);

	PORTD = (PORTD & 0x0F) | (comand << 4);
	PORTD |= (1<<EN);
	_delay_ms(2);
	PORTD &= ~(1<<EN);
	_delay_ms(2);
}

//Gère l'envoi d'un paramètre char
void LCD_Character( unsigned char data_00){
	PORTD = (PORTD & 0x0F) | (data_00 & 0xF0);
	PORTD |= (1<<RS);
	PORTD |= (1<<EN);
	_delay_ms(1);
	PORTD &= ~(1<<EN);

	_delay_ms(2);

	PORTD = (PORTD & 0x0F) | (data_00 << 4);
	PORTD |= (1<<EN);
	_delay_ms(1);
	PORTD &= ~(1<<EN);
	_delay_ms(2);
}

//Initialise le LCD et active les registres pour écrire
void LCD_Initializer (void){
	DDRD = 0xFF;
	_delay_ms(20);

	LCD_Commandgiver(0x02);
	LCD_Commandgiver(0x28);
	LCD_Commandgiver(0x0c);
	LCD_Commandgiver(0x06);
	LCD_Commandgiver(0x01);
	_delay_ms(2);
}

//Gère l'envoi d'une chaîne de caractère au contrôleur
void LCD_String(char *string_00){
	int ci;
	for(ci = 0; string_00[ci] != 0; ci++){
		LCD_Character (string_00[ci]);
	}
}

//Clear l'écran
void LCD_Clear(){
	LCD_Commandgiver(0x01);
	_delay_ms(2);
	LCD_Commandgiver(0x80);
}

//fonction principale
int main(){
	LCD_Initializer();

	LCD_String("PSE !");
	LCD_Commandgiver(0xC0);
	LCD_String("Volume :");
	while(1);
}

Nous avons réussi à compiler le code et le flasher sur l'atmega, cependant, il n'y avait pas de résultat s'affichant sur l'écran.

Programmation AVR

Au cours du module de programmation de système embarqué, nous avons donc schématisé, soudé et programmé un AVR ATMega8u2.

Cette carte est composée notamment de 2 Led et d'un bouton afin d'effectuer les tests de programmation.

Nous avons donc réussi à faire clignoter la led D1 avec le code suivant :

#include <avr/io.h>
#include <util/delay.h>

#define D1 5

int main() {
    DDRC |= 1<<D1;

    while(1) 
    {   
        PORTC ^= 1<<D1;
        _delay_ms(50);
    }   

}

Avec la LUFA on simule un port série avec la demo VirtualSerial. dans VirtualSerial.c, on a modifié la fonction CDC_Task et implémenté le code suivant

    char*       ReportString    = NULL;
    static bool ActionSent      = false;

    /* Device must be connected and configured for the task to run */
    if (USB_DeviceState != DEVICE_STATE_Configured)
        return;

    if ((1<<7 & PINB) == 1<<7)
        ReportString = "Button Pressed\r\n";
    else
        ActionSent = false;

en pressant le bouton de notre carte, on pouvait afficher dans le minicom que le bouton était bel et bien pressé.

Rendus

Archive GIT

lien du git: https://gitea.plil.fr/tdelobel/SE3_2024_B4.git

Autres rendus

Projet KiCAd programmateur AVR : Fichier:2024-PSE-G4-Prog.zip