I2L 2024 Groupe4
Proposition de système
Ce projet consiste à concevoir un simulateur de Morse basé sur un microcontrôleur ATmega32U4. Il permet la traduction :
- Morse → Texte : L'utilisateur entre un code Morse via un bouton poussoir, et la carte le convertit en texte affiché sur le PC via une connexion USB série. On peut imaginer également afficher en temps réel les caractères entrés dans un écran LCD, dans le cas où il n'y a aucune connexion avec un poste fixe.
- Texte → Morse : Le PC envoie un message via USB, et la carte le traduit en signaux lumineux (LED) et sonores (buzzer). On peut également imaginer un affichage sur l'écran LCD.
Le circuit comprend :
- Un bouton poussoir pour saisir le Morse.
- Une LED et un buzzer pour la restitution des signaux.
- Un écran LCD pour afficher le message saisi en morse.
- Une interface USB pour la communication avec un PC.
Contre-proposition
OK pour le système embarqué décrit.
Pas de difficulté de programmation au niveau du système embarqué pour le buzzer et le bouton (gestion classique d'entrée et de sortie).
Pour la gestion de l'écran LCD vous pouvez vous inspirer du code des groupes 3 et 4 I2L en 2023/2024.
Pour la gestion série au niveau du système embarqué vous pouvez vous inspirer du code du groupe 5 I2L en 2023/2024.
Proposition définitive
Système de communication en port série avec deux boutons : un pour changer le mode (transmission ou réception) et un pour écrire des données en mode transmission.
La led s'allumera en mode transmission et reception, soit lorsque l'utilisateur appuie sur le bouton en transmission, soit lors de la traduction en mode réception et le buzzer émettera du son en conséquence. Les caratères traduits seront envoyés dans le port USB série et l'écran LCD et le texte à chiffrer en morse sera entré par le port série et affiché au fur et à mesure de la traduction sur l'écran LCD. Un mode de reset permettera de supprimer le texte affiché sur l'écran LCD lorsque le bouton sera maintenu.
Les caractères ASCII et les caractères spéciaux seront gérés, sauf les accents et caractères qui ne font pas partis du code international du morse.
Répartition du travail
Maxime se concentre sur la partie du haut parleur et les boutons poussoirs.
Jérémy réalise le micro controlleur avec les LEDs.
Conclusion : nous avons travaillé tous les deux sur des sujets différents au départ. Jérémy a réussi à réaliser la transmission et la réception USB en port série et Maxime a géré l'affichage sur l'écran LCD. Pour le reste, nous avons travaillé à part égale, ensemble, sur toutes les fonctionnalités spécifiées.
Carte
Schéma initial
- schéma : Fichier:I2L-2024-Carte-G4.zip
Carte routée
Composants
- ATmega32u4 : disponible
- quartz GND24 : disponible
- buzzer : disponible
- perle ferrite MH2029-300Y : commandée
- chargeur MAX1811 : disponible
- potentiomètre : disponible
- connecteur femelle 16 contacts : commandé
- écran LCD 2 lignes : commandé
- boutons : disponibles
Carte au 23/02/2025
Non encore réalisé :
- ajouter les connecteurs J5, J6, J7 et J9 pour la charge ;
- ajouter le condensateur de 2,2uF pour la charge ;
- ajouter R8 et le potentiomètre pour l'écran LCD ;
- ajouter le buzzer.
Carte au 27/02/2025
Carte finalisée avec l'écran LCD et prête à l'emploi.
Code
Tout d'abord, pour développer notre projet, il nous fallait un moyen de représenter le code morse, et donc des structures :
typedef struct
{
char character;
const char *code;
} CharToMorseEntry;
typedef struct
{
const char *code;
char character;
} MorseToCharEntry;
Nous avons également définis les valeurs associées du code morse international :
CharToMorseEntry char_to_morse_table[] = {
{'A', ".-"}, {'B', "-..."}, {'C', "-.-."} /* autres....*/ }};
MorseToCharEntry morse_to_char_table[] = {
{".-", 'A'}, {"-...", 'B'}, {"-.-.", 'C'} /* autres....*/};
Ensuite nous avons définis différentes fonctions utilitaires afin de transformer les caractères en morse et inversement, de les lire, de mettre à jour des tableaux, comme en témoigne ces signatures de méthodes (leur documentation détaillée est disponible dans le code).
const char *get_morse_from_char(char c);
char get_char_from_morse(const char *morse);
void get_morse_from_text(const char *input, char *output, size_t max_size);
bool is_character_is_valid_morse(char c);
void update_morse_array(char *morse_array, int *char_index, char character);
void update_message_array(char *message_array, int *char_index, char character);
void reinitilize_array(char *array, int max_index);
Nous avons ajouté des fonctions pour contrôler la partie hardware du programme, tel que le buzzer, l'initialisation du timer, etc.
void initiliaze_timer(int diviseur, long periode);
void initialize_morse_game(void);
void use_buzzer(void);
La partie la plus complexe réside finalement dans ces fonctions qui sont les principales du projet :
int main(void);
char translate_morse_to_char(bool reset_message);
bool translate_text_to_morse(const char *message, const char *morse_message, bool reset_message);
Lancement
Pour lancer le projet, il faut insérer la carte dans l'ordinateur et se placer dans le dossier I2L/VirtualSerial à la racine du projet. Depuis cet endroit, il faudra lancer la commande de compilation qui va appeler les makefiles et transférer le code dans la carte :
sudo make dfu
Une fois cette commande effectuée vous serez en mesurer de texter en morse comme l'illustre les vidéos ci-dessous!
Démonstrations
Voici deux vidéo, la première montre comment il est possible d'écrire du texte en morse (même si c'est très dur on ne dira pas qu'on a enregistré la vidéo plusieurs fois) et la deuxième, ce que représente en morse un texte écris dans un port série USB.
Rendus
Projet KiCAD : Fichier:I2L-2024-Carte-G4-rex.zip
Programmes : Fichier:I2L-2024-Programmes-G4.zip