https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Cpayetprojets-se.plil.fr - Contributions [fr]2026-05-14T01:05:45ZContributionsMediaWiki 1.39.1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=9880SE4Binome2025-62026-03-16T14:24:03Z<p>Cpayet : /* Cahier des charges */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<br />
<br />
Le zip qui sauve :<br />
[[Fichier:Recherche ARM.zip|centré|vignette|Recherche ARM]]<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons un ensemble de fonctions liées à notre matériel pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vues ensemble précedemment sont appelées :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrôleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basée sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<br />
Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrôleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite procéder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
====== Startup (.s) ======<br />
Le Startup file est crucial en Bare Metal. Une erreur dans ce fichier peut empêcher le microcontrôleur de démarrer ou provoquer des crashs.<br />
Rôles principaux :<br />
<br />
- Définir l'environnement nécessaire à l'exécution de main().<br />
<br />
- S'exécuter avant main() et lancer ensuite main().<br />
<br />
- Être adapté à la target (processeur) utilisée.<br />
<br />
- Placer correctement la table des vecteurs comme exigé par les ARM Cortex-M.<br />
<br />
- Initialiser la pile correctement.<br />
<br />
- Initialiser les sections .data et .bss dans la SRAM.<br />
<br />
====== Linker (.ld) ======<br />
Le Linker Script détermine comment les sections du code sont placées en mémoire.<br />
''Fonctionnalités :''<br />
* Définir les adresses absolues des sections.<br />
* Définir les zones mémoire, leurs tailles et adresses.<br />
* Fournir les instructions au linker GNU via l'option -T.<br />
* L'extension de fichier est .ld.<br />
<br />
Le code linker sert à guider le compilateur pour assembler toutes les sections d’un programme en un fichier binaire unique. Sur un microcontrôleur comme le '''STM32F410RB''', il faut indiquer où chaque partie du code et des données doit être placée dans la '''mémoire du MCU :'''<br />
<br />
- Où commence le code executable, son point d'entrée ;<br />
<br />
- Définit chaque region de la memoire qui existe sur le microcontrôleur et leur taille ;<br />
<br />
- Où placer les sections differentes du code en memoire (exemple : interruption, etc...).<br />
Dans l'idée on peut le faire à la main afin de mieux assimiler le linker puis récuperer celui générer automatiquement par le logiciel STM32IDE (également disponible sur github) afin de ne pas avoir a y retoucher a chaque fois et ne pas briquer accidentellement notre puce.<br />
Pour realiser un linker on doit preciser la SRAM et sa flash. Cette partie décrit les zones mémoire physiques du STM32F410RB. Il faut se fier au plan memoire de la datasheet p.40/763<br />
Sur celui-ci nous constatons que SRAM est à 32kB et commence à 0x2000 0000 et que la fash commence à 0x0800 0000 et sa taille est de 128kB (donné à la figure 1 page 37/763).<br />
<br />
On peut alors placer dans le linker :<syntaxhighlight lang="c"><br />
MEMORY<br />
{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
</syntaxhighlight>(rx) → read et execute, donc on peut lire et exécuter du code dedans.<br />
(rwx) → read, write, execute (en pratique, on n’exécute pas depuis la RAM, mais certains MCU le permettent).<br />
'''<u>Sections</u>'''Chaque programme compilé contient plusieurs sections générées par le compilateur. L'ordre à laquelle ils sont cris découle de la convention utilisé dans CMSIS (fichier startup fournis par ARM).<br />
<br />
<br />
Tous les compilateurs suivent la même idée :<br />
<br />
- Sections nécessaires au CPU d’abord (vecteurs, code)<br />
<br />
- Sections de données ensuite (initialisées, non initialisées)<br />
<br />
- Mémoire dynamique à la fin (heap, stack)<br />
La '''partie ISR_VECTOR''' indique les vecteurs d'interruptions :<syntaxhighlight lang="c"><br />
isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
</syntaxhighlight>".isr_vector" : C'est la section qui contient le vecteur d'interruptions (ISR - Interrupt Service Routine). Les vecteurs d'interruptions sont des adresses de fonction qui seront appelées lorsque des interruptions spécifiques se produisent.<br />
"KEEP" : Cette directive indique au linker de conserver cette section dans le binaire final, même si elle semble inutilisée par le programme. Cela est crucial pour les vecteurs d'interruptions qui doivent absolument être présents dans le binaire.<br />
">FLASH" : Cela indique que cette section doit être placée en mémoire Flash, qui est généralement de la mémoire non-volatile, utilisée pour stocker le programme.<br />
Elle est placée en Flash pour être disponible dès le reset.<br />
La '''partie TEXT''' contient le code de notre programme :<syntaxhighlight lang="c"><br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
</syntaxhighlight>.text = code exécutable (fonctions, instructions machine).<br />
.rodata = données constantes (const int, chaînes de caractères, etc.).<br />
<br />
_etext marque la fin de la zone code, utile pour copier ensuite la section .data au démarrage.<br />
ALIGN(4) permet d'aligner l'adresse courante sur une frontière de 4 octets. Cela garantit que le code est correctement aligné en mémoire, ce qui peut être nécessaire pour des performances optimales ou des restrictions matérielles.<br />
La '''partie DATA''' contient les variables initialisées :<syntaxhighlight lang="c"><br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
</syntaxhighlight>.data contient les variables globales initialisées (ex: int x = 5;).<br />
Ces valeurs sont stockées dans la Flash au moment de la programmation, mais copiées dans la RAM lors du démarrage (d’où >SRAM AT>FLASH).<br />
<br />
_sdata et _edata servent au code d’initialisation (startup.s) pour savoir quoi copier et combien d’octets.<br />
La partie BSS contient les variables non initialisées :<syntaxhighlight lang="c"><br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
</syntaxhighlight>.bss contient les variables globales non initialisées (ex: int counter;).<br />
Ces variables ne sont pas stockées en Flash, car elles ne contiennent pas de valeur initiale.<br />
<br />
Au démarrage, le startup code remplit cette zone avec des zéros (memset), d’où “zeroed during startup”.<br />
Et voici le code complet du linker : <syntaxhighlight lang="c"><br />
MEMORY{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
<br />
SECTIONS<br />
{<br />
.isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
<br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
}<br />
<br />
</syntaxhighlight>Il a été tester sur ce main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
// do two dummy reads after enabling the peripheral clock, as per the errata<br />
volatile uint32_t dummy;<br />
dummy = RCC->AHB1ENR;<br />
dummy = RCC->AHB1ENR;<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Et le makefile :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = faisALaMainLinker.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Fichiers objets<br />
OBJS = main.o system_stm32f4xx.o startup_stm32f410rx.o<br />
<br />
# Cible principale<br />
all: main.elf<br />
<br />
main.elf: $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
main.o: main.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
system_stm32f4xx.o: ../00-cmsis-device-f4-master/Source/Templates/system_stm32f4xx.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
startup_stm32f410rx.o: ../01-lib/gcc/startup_stm32f410rx.s<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
firmware.bin: main.elf<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: firmware.bin<br />
st-flash write firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -f *.o *.elf *.bin<br />
<br />
size:<br />
arm-none-eabi-size main.elf<br />
<br />
</syntaxhighlight><br />
<br />
===== Processus de compilation : =====<br />
- Le linker assemble ces fichiers et les place correctement en mémoire, générant un fichier .elf.<br />
<br />
- Le fichier .elf est converti en .bin et téléversé dans le microcontrôleur via ST-LINK ou OpenOCD.<br />
[[Fichier:SchemaCompil.png|centré|vignette|425x425px|Schéma chaine compilation]]<br />
<br />
<br />
Nous retrouvons notre code principal en .c qui est compiler pour en ressortir des fichiers .o qui seront ensuite traiter dans le bloc Linker qui fera le lien entre le code et les blocs mémoires réelles. A la sortie nous aurons des .elf qui une fois dans le programmer le transformera en .bin et y sera téléversé dans le mircocontrôleur.<br />
<br />
====== CMSIS ======<br />
C'est à ce lien : <nowiki>https://github.com/STMicroelectronics/cmsis-device-f4</nowiki> qu'on vient télécharger la bibliothèque CMSIS (Cortex Microcontroller Software Interface Standard).<br />
<br />
CMSIS (Cortex Microcontroller Software Interface Standard) simplifie l'accès au matériel, l'équivalent d'un "#include <avr/io.h>" pour ARM.<br />
<br />
C'est une bibliothèque fournie par ARM et ST, qui simplifie l'accès au matériel en proposant :<br />
<br />
- Des définitions pour tous les registres du MCU<br />
<br />
- Les prototypes des fonctions système (comme SystemInit())<br />
<br />
- La table des vecteurs d'interruptions (startup code)<br />
<br />
Si on veut la bibliothèque contenant plus d'informations et des examples, on peut se fier à ce repertoire : https://github.com/STMicroelectronics/STM32CubeF4/tree/master.<br />
<br />
====== Aide à la compilation avec un simple Blink ======<br />
Récuperation des fichiers "syscall.c" et "sysmem.c" : <nowiki>https://github.com/STMicroelectronics/STM32CubeF4/tree/master/Projects/STM32F410xx-Nucleo/Templates/STM32CubeIDE/Example/User</nowiki><br />
Voici le Makefile correspondant :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib/User \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = generatedLinkerIDE.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Répertoire build et bin<br />
BUILD = build<br />
BIN = bin<br />
<br />
# Fichiers source<br />
SRCS := main.c \<br />
../01-lib/User/syscalls.c \<br />
../01-lib/User/sysmem.c \<br />
../01-lib/system_stm32f4xx.c<br />
# Fichier startup asm<br />
ASM_SRCS = ../01-lib/gcc/startup_stm32f410rx.s<br />
<br />
# Objets<br />
OBJS = $(patsubst %.c,$(BUILD)/%.o,$(notdir $(SRCS))) \<br />
$(patsubst %.s,$(BUILD)/%.o,$(notdir $(ASM_SRCS)))<br />
<br />
<br />
# Cible principale<br />
all: $(BUILD)/main.elf<br />
<br />
# Crée le dossier build/ et bin/<br />
$(BUILD):<br />
mkdir -p $(BUILD)<br />
<br />
$(BIN):<br />
mkdir -p $(BIN)<br />
<br />
# Link<br />
$(BUILD)/main.elf: $(BUILD) $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
$(BUILD)/%.o: %.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../01-lib/User/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../00-cmsis-device-f4-master/Source/Templates/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
$(BUILD)/%.o: ../01-lib/gcc/%.s | $(BUILD)<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
$(BIN)/firmware.bin: $(BUILD)/main.elf | $(BIN)<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: $(BIN)/firmware.bin<br />
st-flash write $(BIN)/firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -rf $(BUILD) $(BIN)<br />
<br />
size:<br />
arm-none-eabi-size $(BUILD)/main.elf<br />
</syntaxhighlight>et le main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Nous faisons simplement clignoter une led afin de préparer l'environnement de compilation et vérifier que tout fonctionne. Comme ça, si il y a un bug nous pourrons vite isoler cette étape.<br />
<br />
<br />
Afin de faire clignoter une LED il faut :<br />
1. Activer l'horloge du GPIO correspondant. Pour ce faire, nous modifions le registre RCC->AHB1ENR. (Cf datasheet RM0401 p.119/763)<syntaxhighlight lang="c"><br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIO<PORT>EN_Pos);<br />
<br />
</syntaxhighlight>2. Définir la direction du PIN via le registre<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2);<br />
<br />
</syntaxhighlight>"PB2" => PORT = B et PIN_NUM = 2<br />
Ici par exemple le PIN 3 correspond au 6ieme et 7ieme bit de MODER.<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2); // Output<br />
<br />
</syntaxhighlight>3. Définir le type de sortie (Registre OTYPER)<syntaxhighlight lang="c"><br />
GPIO<PORT>->OTYPER &= ~(0x1 << (<PIN_NUM>)); // Push pull<br />
<br />
</syntaxhighlight>4. Définir le type de pull (Registre PUPDR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->PUPDR &= ~(0x3 << (<PIN_NUM> * 2)); // Forcage 00 : No pull<br />
<br />
</syntaxhighlight>5. Etape finale : écriture sur le pin (Registre ODR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->ODR ^= (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>On peut également modifier de façon atomique (donc juste 1 bit pas tous) via le registre BSRR.<syntaxhighlight lang="c"><br />
if (GPIO<PORT>->ODR & (1 << <PIN_NUM>))<br />
GPIO<PORT>->BSRR = (1 << (<PIN_NUM> + 16)); // Ici 16 est l'offset à ajouter afin d'avoir le bon registre pour eteindre<br />
else<br />
GPIO<PORT>->BSRR = (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>Lorsque BSRR est lu il est reset juste après et cela permet d'éviter les conflits si une interruption intervient et modifie ODR entre 2 instructions.<br />
Après on peut également toucher à la vitesse du pin (Registre OSPEEDR) si l'on souhaite optimiser la consommation de batterie.<br />
''Note : Remplacer <PORT> par A ou B ou C ou etc... et remplacer <PIN> par 1,2,etc.. selon ce qu'on veut activer''<br />
<br />
====== Acceder a PA2 et PA3 sur la Nucleo ======<br />
"SB62 and SB63 must be ON, while SB13 and SB14 must be OFF." Extrait de la datasheet UM1724 : Chapitre7.10 p26/91 <br />
<br />
Il faut dessouder les resistances bridges pour accéder à ces ports. Et ensuite déplacer le jumper sur U5V.<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<br />
<br />
La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
===== SPI =====<br />
Nous allons programmer le SPI sur notre microcontrôleur et tester ce code pour la carte Sparkfun Serial 7-Segments Display. Sur ce git : <nowiki>https://github.com/sparkfun/Serial7SegmentDisplay/wiki/Serial-7-Segment-Display-Datasheet</nowiki> se trouve la datasheet de cette carte que nous allons utiliser pour communiquer en SPI. Dans l'idée, nous allons programmer une bibliothèque suffisament complète afin de pouvoir simplement afficher "9" via une commande dans ce style dans notre main : "spi_sent('G');"<br />
<br />
On peut tout d'abord centraliser la logique des initialisations des pins afin d'alléger le main (Cf fichier hardware_setup.c et .h) .<br />
[[Fichier:Carte7SegmentSparkFunPinout.png|centré|vignette|446x446px|7 segments SparkFun Pinout]]<br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testée nous avons fait plusieurs codes intermediaires pour tester chaque primitive séparément. Ici le détail du code final seulement. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liées au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de contrôler une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
Cette partie est assez complexe et sera implémentée plus tard.<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
// static uint8_t cursor_pos = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (WAITCHAR())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
PRINT_STRING("\r\nUP - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
PRINT_STRING("\r\nDOWN - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touches avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de gérer la détection des cartes filles (généralement après un appel de la fonction "devices"). <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaires pour une meilleure lisibilité. Elle permet aussi de contrôler et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importantes car elles étaient les plus difficiles à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présentes sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrôleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très intéressant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shield, ici nous avons une gestion dynamique avec une liste chaînée (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothèque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitute =====<br />
Ce code à pour but de simplifier l'implémentation de la carte clavier ou la carte écran à moyen et long terme.<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
<br />
#define GETCHAR() usart_read()<br />
#define WAITCHAR() !usart_buffer_available()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le strict minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouver les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importé dans nos différents projets afin d'avoir une détection de touches portable pour la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilée... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons plein de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensée pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnues comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est nécessaire seulement si vous avez un bootloader personnalisé, auquel cas faire un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal à trouver certains caractères mais le document présent ci-dessous m'a grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mappée (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se déplacer via la touche FN qui correspond aux fonctionnalités spéciales, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappées aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Cette partie nécessite d'être travaillée mais servira de point de départ pour les prochaines années je l'espère.<br />
Dans un dossier SPI à part nous avons ajouté un fichier cmd.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_H<br />
#define CMD_H<br />
<br />
#include <stdint.h><br />
<br />
#define CMD_NOCMD 0x00<br />
#define CMD_ACK_SLAVE 0xFF<br />
<br />
// -------------- Detection presence carte fille --------------<br />
#define CMD_PING 0xAA<br />
#define CMD_PING_REPLY 0x55<br />
<br />
// -------------- Identification carte fille --------------<br />
#define CMD_IDENTIFY 0x10<br />
<br />
#define ID_KEYBOARD 0x01<br />
#define ID_ECRAN 0x02<br />
#define ID_SON 0x03<br />
#define ID_RESEAU 0x04<br />
#define ID_FPGA 0x05<br />
<br />
// -------------- Specifique Keyboard --------------<br />
#define CMD_READ_EVENT 0x20<br />
<br />
// -------- Structure keycode -------- //<br />
typedef struct {<br />
char key; // lettre correspondante<br />
uint8_t pressed; // 1 = press, 0 = release<br />
} key_event_t;<br />
<br />
#endif<br />
</syntaxhighlight>Il sert à simplifier l'implémentation des commandes qui sont communes à tous les groupes.<br />
spi.c :<syntaxhighlight lang="c"><br />
#include "spi.h"<br />
#include <avr/io.h><br />
#include <avr/interrupt.h><br />
<br />
// -------- SPI avec carte mere -------- //<br />
#define INT_PORT PORTB<br />
#define INT_DDR DDRB<br />
#define INT_PIN PB0<br />
<br />
#define INT_LOW() (INT_PORT &= ~(1 << INT_PIN))<br />
#define INT_HIGH() (INT_PORT |= (1 << INT_PIN))<br />
<br />
static volatile uint8_t spi_state = 0;<br />
static volatile key_event_t current_event;<br />
<br />
// -------- Buffer circulaire -------- //<br />
#define SPI_BUFFER_SIZE 16<br />
static volatile key_event_t buffer[SPI_BUFFER_SIZE];<br />
static volatile uint8_t head = 0;<br />
static volatile uint8_t tail = 0;<br />
<br />
<br />
static inline uint8_t __bufferIsEmpty(void) {<br />
return head == tail;<br />
}<br />
<br />
static inline void __bufferPush(key_event_t ev) {<br />
uint8_t next = (head + 1) % SPI_BUFFER_SIZE;<br />
<br />
if (next == tail) {<br />
tail = (tail + 1) % SPI_BUFFER_SIZE; // overwrite<br />
}<br />
<br />
buffer[head] = ev;<br />
head = next;<br />
}<br />
<br />
static inline uint8_t __bufferPop(volatile key_event_t *ev) {<br />
if (__bufferIsEmpty())<br />
return 0;<br />
<br />
*ev = buffer[tail];<br />
tail = (tail + 1) % SPI_BUFFER_SIZE;<br />
return 1;<br />
}<br />
<br />
// -------- SPI -------- //<br />
void spi_init(void) {<br />
/* Config SPI Slave : MISO => output, MOSI/SCK/SS => input */<br />
DDRB |= (1 << PB3); // MISO<br />
DDRB &= ~((1 << PB2) | (1 << PB1) | (1 << PB0)); // MOSI, SCK, SS<br />
<br />
/* SPI enable + interruption */<br />
SPCR = (1 << SPE) | (1 << SPIE);<br />
<br />
/* INT pin */<br />
INT_DDR |= (1 << INT_PIN);<br />
INT_HIGH();<br />
<br />
SPDR = CMD_ACK_SLAVE; // On precharge ack pour le 1er cycle, a chaque reset c'est utile<br />
}<br />
<br />
ISR(SPI_STC_vect) {<br />
uint8_t rx = SPDR;<br />
uint8_t tx = CMD_NOCMD;<br />
<br />
switch (rx) {<br />
case CMD_PING:<br />
tx = CMD_PING_REPLY;<br />
break;<br />
<br />
case CMD_IDENTIFY:<br />
tx = ID_KEYBOARD;<br />
break;<br />
<br />
case CMD_READ_EVENT:<br />
if (__bufferPop(&current_event)) {<br />
tx = current_event.key;<br />
spi_state = 1; // prochain octet = pressed<br />
} else {<br />
tx = CMD_NOCMD;<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
<br />
default:<br />
if (spi_state == 1) {<br />
tx = current_event.pressed;<br />
spi_state = 0;<br />
<br />
if (__bufferIsEmpty())<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
}<br />
<br />
SPDR = tx; // a envoyer au prochain cycle<br />
}<br />
// Manque a coder dautre primitive<br />
<br />
<br />
</syntaxhighlight>spi.h :<syntaxhighlight lang="c"><br />
#ifndef SPI_H<br />
#define SPI_H<br />
<br />
#include "cmd.h"<br />
<br />
void spi_init(void);<br />
void spi_push_event(char key, uint8_t pressed);<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=9879SE4Binome2025-62026-03-16T14:21:10Z<p>Cpayet : /* Cahier des charges */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
[[Fichier:Recherche ARM.zip|centré|vignette|Recherche ARM]]<br />
<p style="clear: both;" />Le zip qui sauve : <br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons un ensemble de fonctions liées à notre matériel pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vues ensemble précedemment sont appelées :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrôleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basée sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<br />
Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrôleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite procéder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
====== Startup (.s) ======<br />
Le Startup file est crucial en Bare Metal. Une erreur dans ce fichier peut empêcher le microcontrôleur de démarrer ou provoquer des crashs.<br />
Rôles principaux :<br />
<br />
- Définir l'environnement nécessaire à l'exécution de main().<br />
<br />
- S'exécuter avant main() et lancer ensuite main().<br />
<br />
- Être adapté à la target (processeur) utilisée.<br />
<br />
- Placer correctement la table des vecteurs comme exigé par les ARM Cortex-M.<br />
<br />
- Initialiser la pile correctement.<br />
<br />
- Initialiser les sections .data et .bss dans la SRAM.<br />
<br />
====== Linker (.ld) ======<br />
Le Linker Script détermine comment les sections du code sont placées en mémoire.<br />
''Fonctionnalités :''<br />
* Définir les adresses absolues des sections.<br />
* Définir les zones mémoire, leurs tailles et adresses.<br />
* Fournir les instructions au linker GNU via l'option -T.<br />
* L'extension de fichier est .ld.<br />
<br />
Le code linker sert à guider le compilateur pour assembler toutes les sections d’un programme en un fichier binaire unique. Sur un microcontrôleur comme le '''STM32F410RB''', il faut indiquer où chaque partie du code et des données doit être placée dans la '''mémoire du MCU :'''<br />
<br />
- Où commence le code executable, son point d'entrée ;<br />
<br />
- Définit chaque region de la memoire qui existe sur le microcontrôleur et leur taille ;<br />
<br />
- Où placer les sections differentes du code en memoire (exemple : interruption, etc...).<br />
Dans l'idée on peut le faire à la main afin de mieux assimiler le linker puis récuperer celui générer automatiquement par le logiciel STM32IDE (également disponible sur github) afin de ne pas avoir a y retoucher a chaque fois et ne pas briquer accidentellement notre puce.<br />
Pour realiser un linker on doit preciser la SRAM et sa flash. Cette partie décrit les zones mémoire physiques du STM32F410RB. Il faut se fier au plan memoire de la datasheet p.40/763<br />
Sur celui-ci nous constatons que SRAM est à 32kB et commence à 0x2000 0000 et que la fash commence à 0x0800 0000 et sa taille est de 128kB (donné à la figure 1 page 37/763).<br />
<br />
On peut alors placer dans le linker :<syntaxhighlight lang="c"><br />
MEMORY<br />
{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
</syntaxhighlight>(rx) → read et execute, donc on peut lire et exécuter du code dedans.<br />
(rwx) → read, write, execute (en pratique, on n’exécute pas depuis la RAM, mais certains MCU le permettent).<br />
'''<u>Sections</u>'''Chaque programme compilé contient plusieurs sections générées par le compilateur. L'ordre à laquelle ils sont cris découle de la convention utilisé dans CMSIS (fichier startup fournis par ARM).<br />
<br />
<br />
Tous les compilateurs suivent la même idée :<br />
<br />
- Sections nécessaires au CPU d’abord (vecteurs, code)<br />
<br />
- Sections de données ensuite (initialisées, non initialisées)<br />
<br />
- Mémoire dynamique à la fin (heap, stack)<br />
La '''partie ISR_VECTOR''' indique les vecteurs d'interruptions :<syntaxhighlight lang="c"><br />
isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
</syntaxhighlight>".isr_vector" : C'est la section qui contient le vecteur d'interruptions (ISR - Interrupt Service Routine). Les vecteurs d'interruptions sont des adresses de fonction qui seront appelées lorsque des interruptions spécifiques se produisent.<br />
"KEEP" : Cette directive indique au linker de conserver cette section dans le binaire final, même si elle semble inutilisée par le programme. Cela est crucial pour les vecteurs d'interruptions qui doivent absolument être présents dans le binaire.<br />
">FLASH" : Cela indique que cette section doit être placée en mémoire Flash, qui est généralement de la mémoire non-volatile, utilisée pour stocker le programme.<br />
Elle est placée en Flash pour être disponible dès le reset.<br />
La '''partie TEXT''' contient le code de notre programme :<syntaxhighlight lang="c"><br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
</syntaxhighlight>.text = code exécutable (fonctions, instructions machine).<br />
.rodata = données constantes (const int, chaînes de caractères, etc.).<br />
<br />
_etext marque la fin de la zone code, utile pour copier ensuite la section .data au démarrage.<br />
ALIGN(4) permet d'aligner l'adresse courante sur une frontière de 4 octets. Cela garantit que le code est correctement aligné en mémoire, ce qui peut être nécessaire pour des performances optimales ou des restrictions matérielles.<br />
La '''partie DATA''' contient les variables initialisées :<syntaxhighlight lang="c"><br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
</syntaxhighlight>.data contient les variables globales initialisées (ex: int x = 5;).<br />
Ces valeurs sont stockées dans la Flash au moment de la programmation, mais copiées dans la RAM lors du démarrage (d’où >SRAM AT>FLASH).<br />
<br />
_sdata et _edata servent au code d’initialisation (startup.s) pour savoir quoi copier et combien d’octets.<br />
La partie BSS contient les variables non initialisées :<syntaxhighlight lang="c"><br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
</syntaxhighlight>.bss contient les variables globales non initialisées (ex: int counter;).<br />
Ces variables ne sont pas stockées en Flash, car elles ne contiennent pas de valeur initiale.<br />
<br />
Au démarrage, le startup code remplit cette zone avec des zéros (memset), d’où “zeroed during startup”.<br />
Et voici le code complet du linker : <syntaxhighlight lang="c"><br />
MEMORY{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
<br />
SECTIONS<br />
{<br />
.isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
<br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
}<br />
<br />
</syntaxhighlight>Il a été tester sur ce main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
// do two dummy reads after enabling the peripheral clock, as per the errata<br />
volatile uint32_t dummy;<br />
dummy = RCC->AHB1ENR;<br />
dummy = RCC->AHB1ENR;<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Et le makefile :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = faisALaMainLinker.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Fichiers objets<br />
OBJS = main.o system_stm32f4xx.o startup_stm32f410rx.o<br />
<br />
# Cible principale<br />
all: main.elf<br />
<br />
main.elf: $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
main.o: main.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
system_stm32f4xx.o: ../00-cmsis-device-f4-master/Source/Templates/system_stm32f4xx.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
startup_stm32f410rx.o: ../01-lib/gcc/startup_stm32f410rx.s<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
firmware.bin: main.elf<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: firmware.bin<br />
st-flash write firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -f *.o *.elf *.bin<br />
<br />
size:<br />
arm-none-eabi-size main.elf<br />
<br />
</syntaxhighlight><br />
<br />
===== Processus de compilation : =====<br />
- Le linker assemble ces fichiers et les place correctement en mémoire, générant un fichier .elf.<br />
<br />
- Le fichier .elf est converti en .bin et téléversé dans le microcontrôleur via ST-LINK ou OpenOCD.<br />
[[Fichier:SchemaCompil.png|centré|vignette|425x425px|Schéma chaine compilation]]<br />
<br />
<br />
Nous retrouvons notre code principal en .c qui est compiler pour en ressortir des fichiers .o qui seront ensuite traiter dans le bloc Linker qui fera le lien entre le code et les blocs mémoires réelles. A la sortie nous aurons des .elf qui une fois dans le programmer le transformera en .bin et y sera téléversé dans le mircocontrôleur.<br />
<br />
====== CMSIS ======<br />
C'est à ce lien : <nowiki>https://github.com/STMicroelectronics/cmsis-device-f4</nowiki> qu'on vient télécharger la bibliothèque CMSIS (Cortex Microcontroller Software Interface Standard).<br />
<br />
CMSIS (Cortex Microcontroller Software Interface Standard) simplifie l'accès au matériel, l'équivalent d'un "#include <avr/io.h>" pour ARM.<br />
<br />
C'est une bibliothèque fournie par ARM et ST, qui simplifie l'accès au matériel en proposant :<br />
<br />
- Des définitions pour tous les registres du MCU<br />
<br />
- Les prototypes des fonctions système (comme SystemInit())<br />
<br />
- La table des vecteurs d'interruptions (startup code)<br />
<br />
Si on veut la bibliothèque contenant plus d'informations et des examples, on peut se fier à ce repertoire : https://github.com/STMicroelectronics/STM32CubeF4/tree/master.<br />
<br />
====== Aide à la compilation avec un simple Blink ======<br />
Récuperation des fichiers "syscall.c" et "sysmem.c" : <nowiki>https://github.com/STMicroelectronics/STM32CubeF4/tree/master/Projects/STM32F410xx-Nucleo/Templates/STM32CubeIDE/Example/User</nowiki><br />
Voici le Makefile correspondant :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib/User \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = generatedLinkerIDE.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Répertoire build et bin<br />
BUILD = build<br />
BIN = bin<br />
<br />
# Fichiers source<br />
SRCS := main.c \<br />
../01-lib/User/syscalls.c \<br />
../01-lib/User/sysmem.c \<br />
../01-lib/system_stm32f4xx.c<br />
# Fichier startup asm<br />
ASM_SRCS = ../01-lib/gcc/startup_stm32f410rx.s<br />
<br />
# Objets<br />
OBJS = $(patsubst %.c,$(BUILD)/%.o,$(notdir $(SRCS))) \<br />
$(patsubst %.s,$(BUILD)/%.o,$(notdir $(ASM_SRCS)))<br />
<br />
<br />
# Cible principale<br />
all: $(BUILD)/main.elf<br />
<br />
# Crée le dossier build/ et bin/<br />
$(BUILD):<br />
mkdir -p $(BUILD)<br />
<br />
$(BIN):<br />
mkdir -p $(BIN)<br />
<br />
# Link<br />
$(BUILD)/main.elf: $(BUILD) $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
$(BUILD)/%.o: %.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../01-lib/User/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../00-cmsis-device-f4-master/Source/Templates/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
$(BUILD)/%.o: ../01-lib/gcc/%.s | $(BUILD)<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
$(BIN)/firmware.bin: $(BUILD)/main.elf | $(BIN)<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: $(BIN)/firmware.bin<br />
st-flash write $(BIN)/firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -rf $(BUILD) $(BIN)<br />
<br />
size:<br />
arm-none-eabi-size $(BUILD)/main.elf<br />
</syntaxhighlight>et le main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Nous faisons simplement clignoter une led afin de préparer l'environnement de compilation et vérifier que tout fonctionne. Comme ça, si il y a un bug nous pourrons vite isoler cette étape.<br />
<br />
<br />
Afin de faire clignoter une LED il faut :<br />
1. Activer l'horloge du GPIO correspondant. Pour ce faire, nous modifions le registre RCC->AHB1ENR. (Cf datasheet RM0401 p.119/763)<syntaxhighlight lang="c"><br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIO<PORT>EN_Pos);<br />
<br />
</syntaxhighlight>2. Définir la direction du PIN via le registre<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2);<br />
<br />
</syntaxhighlight>"PB2" => PORT = B et PIN_NUM = 2<br />
Ici par exemple le PIN 3 correspond au 6ieme et 7ieme bit de MODER.<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2); // Output<br />
<br />
</syntaxhighlight>3. Définir le type de sortie (Registre OTYPER)<syntaxhighlight lang="c"><br />
GPIO<PORT>->OTYPER &= ~(0x1 << (<PIN_NUM>)); // Push pull<br />
<br />
</syntaxhighlight>4. Définir le type de pull (Registre PUPDR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->PUPDR &= ~(0x3 << (<PIN_NUM> * 2)); // Forcage 00 : No pull<br />
<br />
</syntaxhighlight>5. Etape finale : écriture sur le pin (Registre ODR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->ODR ^= (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>On peut également modifier de façon atomique (donc juste 1 bit pas tous) via le registre BSRR.<syntaxhighlight lang="c"><br />
if (GPIO<PORT>->ODR & (1 << <PIN_NUM>))<br />
GPIO<PORT>->BSRR = (1 << (<PIN_NUM> + 16)); // Ici 16 est l'offset à ajouter afin d'avoir le bon registre pour eteindre<br />
else<br />
GPIO<PORT>->BSRR = (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>Lorsque BSRR est lu il est reset juste après et cela permet d'éviter les conflits si une interruption intervient et modifie ODR entre 2 instructions.<br />
Après on peut également toucher à la vitesse du pin (Registre OSPEEDR) si l'on souhaite optimiser la consommation de batterie.<br />
''Note : Remplacer <PORT> par A ou B ou C ou etc... et remplacer <PIN> par 1,2,etc.. selon ce qu'on veut activer''<br />
<br />
====== Acceder a PA2 et PA3 sur la Nucleo ======<br />
"SB62 and SB63 must be ON, while SB13 and SB14 must be OFF." Extrait de la datasheet UM1724 : Chapitre7.10 p26/91 <br />
<br />
Il faut dessouder les resistances bridges pour accéder à ces ports. Et ensuite déplacer le jumper sur U5V.<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<br />
<br />
La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
===== SPI =====<br />
Nous allons programmer le SPI sur notre microcontrôleur et tester ce code pour la carte Sparkfun Serial 7-Segments Display. Sur ce git : <nowiki>https://github.com/sparkfun/Serial7SegmentDisplay/wiki/Serial-7-Segment-Display-Datasheet</nowiki> se trouve la datasheet de cette carte que nous allons utiliser pour communiquer en SPI. Dans l'idée, nous allons programmer une bibliothèque suffisament complète afin de pouvoir simplement afficher "9" via une commande dans ce style dans notre main : "spi_sent('G');"<br />
<br />
On peut tout d'abord centraliser la logique des initialisations des pins afin d'alléger le main (Cf fichier hardware_setup.c et .h) .<br />
[[Fichier:Carte7SegmentSparkFunPinout.png|centré|vignette|446x446px|7 segments SparkFun Pinout]]<br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testée nous avons fait plusieurs codes intermediaires pour tester chaque primitive séparément. Ici le détail du code final seulement. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liées au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de contrôler une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
Cette partie est assez complexe et sera implémentée plus tard.<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
// static uint8_t cursor_pos = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (WAITCHAR())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
PRINT_STRING("\r\nUP - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
PRINT_STRING("\r\nDOWN - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touches avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de gérer la détection des cartes filles (généralement après un appel de la fonction "devices"). <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaires pour une meilleure lisibilité. Elle permet aussi de contrôler et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importantes car elles étaient les plus difficiles à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présentes sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrôleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très intéressant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shield, ici nous avons une gestion dynamique avec une liste chaînée (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothèque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitute =====<br />
Ce code à pour but de simplifier l'implémentation de la carte clavier ou la carte écran à moyen et long terme.<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
<br />
#define GETCHAR() usart_read()<br />
#define WAITCHAR() !usart_buffer_available()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le strict minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouver les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importé dans nos différents projets afin d'avoir une détection de touches portable pour la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilée... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons plein de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensée pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnues comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est nécessaire seulement si vous avez un bootloader personnalisé, auquel cas faire un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal à trouver certains caractères mais le document présent ci-dessous m'a grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mappée (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se déplacer via la touche FN qui correspond aux fonctionnalités spéciales, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappées aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Cette partie nécessite d'être travaillée mais servira de point de départ pour les prochaines années je l'espère.<br />
Dans un dossier SPI à part nous avons ajouté un fichier cmd.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_H<br />
#define CMD_H<br />
<br />
#include <stdint.h><br />
<br />
#define CMD_NOCMD 0x00<br />
#define CMD_ACK_SLAVE 0xFF<br />
<br />
// -------------- Detection presence carte fille --------------<br />
#define CMD_PING 0xAA<br />
#define CMD_PING_REPLY 0x55<br />
<br />
// -------------- Identification carte fille --------------<br />
#define CMD_IDENTIFY 0x10<br />
<br />
#define ID_KEYBOARD 0x01<br />
#define ID_ECRAN 0x02<br />
#define ID_SON 0x03<br />
#define ID_RESEAU 0x04<br />
#define ID_FPGA 0x05<br />
<br />
// -------------- Specifique Keyboard --------------<br />
#define CMD_READ_EVENT 0x20<br />
<br />
// -------- Structure keycode -------- //<br />
typedef struct {<br />
char key; // lettre correspondante<br />
uint8_t pressed; // 1 = press, 0 = release<br />
} key_event_t;<br />
<br />
#endif<br />
</syntaxhighlight>Il sert à simplifier l'implémentation des commandes qui sont communes à tous les groupes.<br />
spi.c :<syntaxhighlight lang="c"><br />
#include "spi.h"<br />
#include <avr/io.h><br />
#include <avr/interrupt.h><br />
<br />
// -------- SPI avec carte mere -------- //<br />
#define INT_PORT PORTB<br />
#define INT_DDR DDRB<br />
#define INT_PIN PB0<br />
<br />
#define INT_LOW() (INT_PORT &= ~(1 << INT_PIN))<br />
#define INT_HIGH() (INT_PORT |= (1 << INT_PIN))<br />
<br />
static volatile uint8_t spi_state = 0;<br />
static volatile key_event_t current_event;<br />
<br />
// -------- Buffer circulaire -------- //<br />
#define SPI_BUFFER_SIZE 16<br />
static volatile key_event_t buffer[SPI_BUFFER_SIZE];<br />
static volatile uint8_t head = 0;<br />
static volatile uint8_t tail = 0;<br />
<br />
<br />
static inline uint8_t __bufferIsEmpty(void) {<br />
return head == tail;<br />
}<br />
<br />
static inline void __bufferPush(key_event_t ev) {<br />
uint8_t next = (head + 1) % SPI_BUFFER_SIZE;<br />
<br />
if (next == tail) {<br />
tail = (tail + 1) % SPI_BUFFER_SIZE; // overwrite<br />
}<br />
<br />
buffer[head] = ev;<br />
head = next;<br />
}<br />
<br />
static inline uint8_t __bufferPop(volatile key_event_t *ev) {<br />
if (__bufferIsEmpty())<br />
return 0;<br />
<br />
*ev = buffer[tail];<br />
tail = (tail + 1) % SPI_BUFFER_SIZE;<br />
return 1;<br />
}<br />
<br />
// -------- SPI -------- //<br />
void spi_init(void) {<br />
/* Config SPI Slave : MISO => output, MOSI/SCK/SS => input */<br />
DDRB |= (1 << PB3); // MISO<br />
DDRB &= ~((1 << PB2) | (1 << PB1) | (1 << PB0)); // MOSI, SCK, SS<br />
<br />
/* SPI enable + interruption */<br />
SPCR = (1 << SPE) | (1 << SPIE);<br />
<br />
/* INT pin */<br />
INT_DDR |= (1 << INT_PIN);<br />
INT_HIGH();<br />
<br />
SPDR = CMD_ACK_SLAVE; // On precharge ack pour le 1er cycle, a chaque reset c'est utile<br />
}<br />
<br />
ISR(SPI_STC_vect) {<br />
uint8_t rx = SPDR;<br />
uint8_t tx = CMD_NOCMD;<br />
<br />
switch (rx) {<br />
case CMD_PING:<br />
tx = CMD_PING_REPLY;<br />
break;<br />
<br />
case CMD_IDENTIFY:<br />
tx = ID_KEYBOARD;<br />
break;<br />
<br />
case CMD_READ_EVENT:<br />
if (__bufferPop(&current_event)) {<br />
tx = current_event.key;<br />
spi_state = 1; // prochain octet = pressed<br />
} else {<br />
tx = CMD_NOCMD;<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
<br />
default:<br />
if (spi_state == 1) {<br />
tx = current_event.pressed;<br />
spi_state = 0;<br />
<br />
if (__bufferIsEmpty())<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
}<br />
<br />
SPDR = tx; // a envoyer au prochain cycle<br />
}<br />
// Manque a coder dautre primitive<br />
<br />
<br />
</syntaxhighlight>spi.h :<syntaxhighlight lang="c"><br />
#ifndef SPI_H<br />
#define SPI_H<br />
<br />
#include "cmd.h"<br />
<br />
void spi_init(void);<br />
void spi_push_event(char key, uint8_t pressed);<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Recherche_ARM.zip&diff=9878Fichier:Recherche ARM.zip2026-03-16T14:20:18Z<p>Cpayet : </p>
<hr />
<div>Recherche ARM</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8757SE4Binome2025-62026-01-05T14:55:33Z<p>Cpayet : /* Ajout partie clavier */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
====== Startup (.s) ======<br />
Le Startup file est crucial en Bare Metal. Une erreur dans ce fichier peut empêcher le microcontrôleur de démarrer ou provoquer des crashs.<br />
Rôles principaux :<br />
<br />
- Définir l'environnement nécessaire à l'exécution de main().<br />
<br />
- S'exécuter avant main() et lancer ensuite main().<br />
<br />
- Être adapté à la target (processeur) utilisée.<br />
<br />
- Placer correctement la table des vecteurs comme exigé par les ARM Cortex-M.<br />
<br />
- Initialiser la pile correctement.<br />
<br />
- Initialiser les sections .data et .bss dans la SRAM.<br />
<br />
====== Linker (.ld) ======<br />
Le Linker Script détermine comment les sections du code sont placées en mémoire.<br />
''Fonctionnalités :''<br />
* Définir les adresses absolues des sections.<br />
* Définir les zones mémoire, leurs tailles et adresses.<br />
* Fournir les instructions au linker GNU via l'option -T.<br />
* L'extension de fichier est .ld.<br />
<br />
Le code linker sert à guider le compilateur pour assembler toutes les sections d’un programme en un fichier binaire unique. Sur un microcontrôleur comme le '''STM32F410RB''', il faut indiquer où chaque partie du code et des données doit être placée dans la '''mémoire du MCU :'''<br />
<br />
- Où commence le code executable, son point d'entrée ;<br />
<br />
- Définit chaque region de la memoire qui existe sur le microcontrolleur et leur taille ;<br />
<br />
- Où placer les sections differentes du code en memoire (exemple : interruption, etc...).<br />
Dans l'idée on peut le faire à la main afin de mieux assimiler le linker puis récuperer celui générer automatiquement par le logiciel STM32IDE (également disponible sur github) afin de ne pas avoir a y retoucher a chaque fois et ne pas briquer accidentellement notre puce.<br />
Pour realiser un linker on doit preciser la SRAM et sa flash. Cette partie décrit les zones mémoire physiques du STM32F410RB. Il faut se fier au plan memoire de la datasheet p.40/763<br />
Sur celui-ci nous constatons que SRAM est à 32kB et commence à 0x2000 0000<br />
<br />
et que la fash commence à 0x0800 0000 et sa taille est de 128kB (donné à la figure 1 page 37/763)<br />
On peut alors placer dans le linker :<syntaxhighlight lang="c"><br />
MEMORY<br />
{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
</syntaxhighlight>(rx) → read et execute, donc on peut lire et exécuter du code dedans.<br />
(rwx) → read, write, execute (en pratique, on n’exécute pas depuis la RAM, mais certains MCU le permettent).<br />
'''<u>Sections</u>'''Chaque programme compilé contient plusieurs sections générées par le compilateur. L'ordre à laquelle ils sont cris découle de la convention utilisé dans CMSIS (fichier startup fournis par ARM).<br />
<br />
<br />
Tous les compilateurs suivent la même idée :<br />
<br />
- Sections nécessaires au CPU d’abord (vecteurs, code)<br />
<br />
- Sections de données ensuite (initialisées, non initialisées)<br />
<br />
- Mémoire dynamique à la fin (heap, stack)<br />
La '''partie ISR_VECTOR''' indique les vecteurs d'interruptions :<syntaxhighlight lang="c"><br />
isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
</syntaxhighlight>".isr_vector" : C'est la section qui contient le vecteur d'interruptions (ISR - Interrupt Service Routine). Les vecteurs d'interruptions sont des adresses de fonction qui seront appelées lorsque des interruptions spécifiques se produisent.<br />
"KEEP" : Cette directive indique au linker de conserver cette section dans le binaire final, même si elle semble inutilisée par le programme. Cela est crucial pour les vecteurs d'interruptions qui doivent absolument être présents dans le binaire.<br />
">FLASH" : Cela indique que cette section doit être placée en mémoire Flash, qui est généralement de la mémoire non-volatile, utilisée pour stocker le programme.<br />
Elle est placée en Flash pour être disponible dès le reset.<br />
La '''partie TEXT''' contient le code de notre programme :<syntaxhighlight lang="c"><br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
</syntaxhighlight>.text = code exécutable (fonctions, instructions machine).<br />
.rodata = données constantes (const int, chaînes de caractères, etc.).<br />
<br />
_etext marque la fin de la zone code, utile pour copier ensuite la section .data au démarrage.<br />
ALIGN(4) permet d'aligner l'adresse courante sur une frontière de 4 octets. Cela garantit que le code est correctement aligné en mémoire, ce qui peut être nécessaire pour des performances optimales ou des restrictions matérielles.<br />
La '''partie DATA''' contient les variables initialisées :<syntaxhighlight lang="c"><br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
</syntaxhighlight>.data contient les variables globales initialisées (ex: int x = 5;).<br />
Ces valeurs sont stockées dans la Flash au moment de la programmation, mais copiées dans la RAM lors du démarrage (d’où >SRAM AT>FLASH).<br />
<br />
_sdata et _edata servent au code d’initialisation (startup.s) pour savoir quoi copier et combien d’octets.<br />
La partie BSS contient les variables non initialisées :<syntaxhighlight lang="c"><br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
</syntaxhighlight>.bss contient les variables globales non initialisées (ex: int counter;).<br />
Ces variables ne sont pas stockées en Flash, car elles ne contiennent pas de valeur initiale.<br />
<br />
Au démarrage, le startup code remplit cette zone avec des zéros (memset), d’où “zeroed during startup”.<br />
Et voici le code complet du linker : <syntaxhighlight lang="c"><br />
MEMORY{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
<br />
SECTIONS<br />
{<br />
.isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
<br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
}<br />
<br />
</syntaxhighlight>Il a été tester sur ce main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
// do two dummy reads after enabling the peripheral clock, as per the errata<br />
volatile uint32_t dummy;<br />
dummy = RCC->AHB1ENR;<br />
dummy = RCC->AHB1ENR;<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Et le makefile :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = faisALaMainLinker.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Fichiers objets<br />
OBJS = main.o system_stm32f4xx.o startup_stm32f410rx.o<br />
<br />
# Cible principale<br />
all: main.elf<br />
<br />
main.elf: $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
main.o: main.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
system_stm32f4xx.o: ../00-cmsis-device-f4-master/Source/Templates/system_stm32f4xx.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
startup_stm32f410rx.o: ../01-lib/gcc/startup_stm32f410rx.s<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
firmware.bin: main.elf<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: firmware.bin<br />
st-flash write firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -f *.o *.elf *.bin<br />
<br />
size:<br />
arm-none-eabi-size main.elf<br />
<br />
</syntaxhighlight><br />
<br />
===== Processus de compilation : =====<br />
- Le linker assemble ces fichiers et les place correctement en mémoire, générant un fichier .elf.<br />
<br />
- Le fichier .elf est converti en .bin et téléversé dans le microcontrôleur via ST-LINK ou OpenOCD.<br />
[[Fichier:SchemaCompil.png|centré|vignette|425x425px|Schéma chaine compilation]]<br />
<br />
<br />
Nous retrouvons notre code principale en .c qui est compiler pour en ressortir des fichiers .o qui seront ensuite traiter dans le bloc Linker qui fera le lien entre le code et les blocs mémoires réelles. A la sortie nous aurons des .elf qui un fois dans le programmer le transformera en .bin et y sera téléverser dans le uControleur.<br />
<br />
====== CMSIS ======<br />
C'est à ce lien : <nowiki>https://github.com/STMicroelectronics/cmsis-device-f4</nowiki> qu'on vient télécharger la bibliothèque CMSIS (Cortex Microcontroller Software Interface Standard).<br />
<br />
CMSIS (Cortex Microcontroller Software Interface Standard) simplifie l'accès au matériel, l'équivalent d'un "#include <avr/io.h>" pour ARM.<br />
<br />
C'est une bibliothèque fournie par ARM et ST, qui simplifie l'accès au matériel en proposant :<br />
<br />
- Des définitions pour tous les registres du MCU<br />
<br />
- Les prototypes des fonctions système (comme SystemInit())<br />
<br />
- La table des vecteurs d'interruptions (startup code)<br />
<br />
Si on veut la bibliothèque contenant plus d'information et des examples on peut se fier a ce repertoire : https://github.com/STMicroelectronics/STM32CubeF4/tree/master.<br />
<br />
====== Aide à la compilation avec un simple Blink ======<br />
Récuperation des fichiers "syscall.c" et "sysmem.c" : <nowiki>https://github.com/STMicroelectronics/STM32CubeF4/tree/master/Projects/STM32F410xx-Nucleo/Templates/STM32CubeIDE/Example/User</nowiki><br />
Voici le Makefile correspondant :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib/User \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = generatedLinkerIDE.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Répertoire build et bin<br />
BUILD = build<br />
BIN = bin<br />
<br />
# Fichiers source<br />
SRCS := main.c \<br />
../01-lib/User/syscalls.c \<br />
../01-lib/User/sysmem.c \<br />
../01-lib/system_stm32f4xx.c<br />
# Fichier startup asm<br />
ASM_SRCS = ../01-lib/gcc/startup_stm32f410rx.s<br />
<br />
# Objets<br />
OBJS = $(patsubst %.c,$(BUILD)/%.o,$(notdir $(SRCS))) \<br />
$(patsubst %.s,$(BUILD)/%.o,$(notdir $(ASM_SRCS)))<br />
<br />
<br />
# Cible principale<br />
all: $(BUILD)/main.elf<br />
<br />
# Crée le dossier build/ et bin/<br />
$(BUILD):<br />
mkdir -p $(BUILD)<br />
<br />
$(BIN):<br />
mkdir -p $(BIN)<br />
<br />
# Link<br />
$(BUILD)/main.elf: $(BUILD) $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
$(BUILD)/%.o: %.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../01-lib/User/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../00-cmsis-device-f4-master/Source/Templates/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
$(BUILD)/%.o: ../01-lib/gcc/%.s | $(BUILD)<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
$(BIN)/firmware.bin: $(BUILD)/main.elf | $(BIN)<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: $(BIN)/firmware.bin<br />
st-flash write $(BIN)/firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -rf $(BUILD) $(BIN)<br />
<br />
size:<br />
arm-none-eabi-size $(BUILD)/main.elf<br />
</syntaxhighlight>et le main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Nous faisons simplement clignoter une led afin de préparer l'environnement de compilation et vérifier que tout fonctionne. Comme ça, si il y a un bug nous pourrons vite isoler cette étape.<br />
<br />
<br />
Afin de faire clignoter une LED il faut :<br />
1. Activer l'horloge du GPIO correspondant. Pour ce faire, nous modifions le registre RCC->AHB1ENR. (Cf datasheet RM0401 p.119/763)<syntaxhighlight lang="c"><br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIO<PORT>EN_Pos);<br />
<br />
</syntaxhighlight>2. Définir la direction du PIN via le registre<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2);<br />
<br />
</syntaxhighlight>"PB2" => PORT = B et PIN_NUM = 2<br />
Ici par exemple le PIN 3 correspond au 6ieme et 7ieme bit de MODER.<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2); // Output<br />
<br />
</syntaxhighlight>3. Définir le type de sortie (Registre OTYPER)<syntaxhighlight lang="c"><br />
GPIO<PORT>->OTYPER &= ~(0x1 << (<PIN_NUM>)); // Push pull<br />
<br />
</syntaxhighlight>4. Définir le type de pull (Registre PUPDR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->PUPDR &= ~(0x3 << (<PIN_NUM> * 2)); // Forcage 00 : No pull<br />
<br />
</syntaxhighlight>5. Etape finale : écriture sur le pin (Registre ODR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->ODR ^= (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>On peut également modifier de façon atomique (donc juste 1 bit pas tous) via le registre BSRR.<syntaxhighlight lang="c"><br />
if (GPIO<PORT>->ODR & (1 << <PIN_NUM>))<br />
GPIO<PORT>->BSRR = (1 << (<PIN_NUM> + 16)); // Ici 16 est l'offset à ajouter afin d'avoir le bon registre pour eteindre<br />
else<br />
GPIO<PORT>->BSRR = (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>Lorsque BSRR est lu il est reset juste après et cela permet d'éviter les conflits si une interruption intervient et modifie ODR entre 2 instructions.<br />
Après on peut également toucher a la vitesse du pin (Registre OSPEEDR) si l'on souhaite optimiser la consommation de batterie.<br />
''Note : Remplacer <PORT> par A ou B ou C ou etc... et remplacer <PIN> par 1,2,etc.. selon ce qu'on veut activer''<br />
<br />
====== Acceder a PA2 et PA3 sur la Nucleo ======<br />
"SB62 and SB63 must be ON, while SB13 and SB14 must be OFF." Extrait de la datasheet UM1724 : Chapitre7.10 p26/91 <br />
<br />
Il faut dessouder les resistances bridges pour acceder ces ports. Et ensuite deplacer le jumper sur U5V.<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<br />
<br />
La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
===== SPI =====<br />
Nous allons programmer le SPI sur notre microcontrolleur et tester ce code pour la carte Sparkfun Serial 7-Segments Display. Sur ce git : <nowiki>https://github.com/sparkfun/Serial7SegmentDisplay/wiki/Serial-7-Segment-Display-Datasheet</nowiki> se trouve la datasheet de cette carte que nous allons utiliser pour communiquer en SPI. Dans l'idée, nous allons programmer une bibliothèque suffisament complète afin de pouvoir simplement d'afficher "9" via une commande dans ce style dans notre main : "spi_sent('G');"<br />
<br />
On peut tout d'abord centraliser la logique des initialisations des pins afin d'alleger le main (Cf fichier hardware_setup.c et .h) .<br />
[[Fichier:Carte7SegmentSparkFunPinout.png|centré|vignette|446x446px|7 segments SparkFun Pinout]]<br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
Cette partie est assez complexe et sera implémenter plus tard.<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
// static uint8_t cursor_pos = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (WAITCHAR())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
PRINT_STRING("\r\nUP - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
PRINT_STRING("\r\nDOWN - Gestion historique a implementer\r\nPicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de gérer la détection des cartes filles (générealement après un appel de la fonction "devices"). <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shield, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothèque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitute =====<br />
Ce code à pour but de simplifier l'implémentation de la carte clavier ou la carte écran à moyen et long terme.<br />
<br />
<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
<br />
#define GETCHAR() usart_read()<br />
#define WAITCHAR() !usart_buffer_available()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Cette partie nécessite d'être travaillé mais servira de point de départ pour les prochaines années je l'espère.<br />
<br />
<br />
Dans un dossier SPI à part nous avons ajouté un fichier cmd.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_H<br />
#define CMD_H<br />
<br />
#include <stdint.h><br />
<br />
#define CMD_NOCMD 0x00<br />
#define CMD_ACK_SLAVE 0xFF<br />
<br />
// -------------- Detection presence carte fille --------------<br />
#define CMD_PING 0xAA<br />
#define CMD_PING_REPLY 0x55<br />
<br />
// -------------- Identification carte fille --------------<br />
#define CMD_IDENTIFY 0x10<br />
<br />
#define ID_KEYBOARD 0x01<br />
#define ID_ECRAN 0x02<br />
#define ID_SON 0x03<br />
#define ID_RESEAU 0x04<br />
#define ID_FPGA 0x05<br />
<br />
// -------------- Specifique Keyboard --------------<br />
#define CMD_READ_EVENT 0x20<br />
<br />
// -------- Structure keycode -------- //<br />
typedef struct {<br />
char key; // lettre correspondante<br />
uint8_t pressed; // 1 = press, 0 = release<br />
} key_event_t;<br />
<br />
#endif<br />
</syntaxhighlight>Il sert à simplifier l'implémentation des commandes qui sont communes à tous les groupes.<br />
<br />
<br />
spi.c :<syntaxhighlight lang="c"><br />
#include "spi.h"<br />
#include <avr/io.h><br />
#include <avr/interrupt.h><br />
<br />
// -------- SPI avec carte mere -------- //<br />
#define INT_PORT PORTB<br />
#define INT_DDR DDRB<br />
#define INT_PIN PB0<br />
<br />
#define INT_LOW() (INT_PORT &= ~(1 << INT_PIN))<br />
#define INT_HIGH() (INT_PORT |= (1 << INT_PIN))<br />
<br />
static volatile uint8_t spi_state = 0;<br />
static volatile key_event_t current_event;<br />
<br />
// -------- Buffer circulaire -------- //<br />
#define SPI_BUFFER_SIZE 16<br />
static volatile key_event_t buffer[SPI_BUFFER_SIZE];<br />
static volatile uint8_t head = 0;<br />
static volatile uint8_t tail = 0;<br />
<br />
<br />
static inline uint8_t __bufferIsEmpty(void) {<br />
return head == tail;<br />
}<br />
<br />
static inline void __bufferPush(key_event_t ev) {<br />
uint8_t next = (head + 1) % SPI_BUFFER_SIZE;<br />
<br />
if (next == tail) {<br />
tail = (tail + 1) % SPI_BUFFER_SIZE; // overwrite<br />
}<br />
<br />
buffer[head] = ev;<br />
head = next;<br />
}<br />
<br />
static inline uint8_t __bufferPop(volatile key_event_t *ev) {<br />
if (__bufferIsEmpty())<br />
return 0;<br />
<br />
*ev = buffer[tail];<br />
tail = (tail + 1) % SPI_BUFFER_SIZE;<br />
return 1;<br />
}<br />
<br />
// -------- SPI -------- //<br />
void spi_init(void) {<br />
/* Config SPI Slave : MISO => output, MOSI/SCK/SS => input */<br />
DDRB |= (1 << PB3); // MISO<br />
DDRB &= ~((1 << PB2) | (1 << PB1) | (1 << PB0)); // MOSI, SCK, SS<br />
<br />
/* SPI enable + interruption */<br />
SPCR = (1 << SPE) | (1 << SPIE);<br />
<br />
/* INT pin */<br />
INT_DDR |= (1 << INT_PIN);<br />
INT_HIGH();<br />
<br />
SPDR = CMD_ACK_SLAVE; // On precharge ack pour le 1er cycle, a chaque reset c'est utile<br />
}<br />
<br />
ISR(SPI_STC_vect) {<br />
uint8_t rx = SPDR;<br />
uint8_t tx = CMD_NOCMD;<br />
<br />
switch (rx) {<br />
case CMD_PING:<br />
tx = CMD_PING_REPLY;<br />
break;<br />
<br />
case CMD_IDENTIFY:<br />
tx = ID_KEYBOARD;<br />
break;<br />
<br />
case CMD_READ_EVENT:<br />
if (__bufferPop(&current_event)) {<br />
tx = current_event.key;<br />
spi_state = 1; // prochain octet = pressed<br />
} else {<br />
tx = CMD_NOCMD;<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
<br />
default:<br />
if (spi_state == 1) {<br />
tx = current_event.pressed;<br />
spi_state = 0;<br />
<br />
if (__bufferIsEmpty())<br />
INT_HIGH(); // RAS pour la carte mere<br />
}<br />
break;<br />
}<br />
<br />
SPDR = tx; // a envoyer au prochain cycle<br />
}<br />
// Manque a coder dautre primitive<br />
<br />
<br />
</syntaxhighlight>spi.h :<syntaxhighlight lang="c"><br />
#ifndef SPI_H<br />
#define SPI_H<br />
<br />
#include "cmd.h"<br />
<br />
void spi_init(void);<br />
void spi_push_event(char key, uint8_t pressed);<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8738SE4Binome2025-62026-01-05T13:59:18Z<p>Cpayet : /* Carte ecran */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
====== Startup (.s) ======<br />
Le Startup file est crucial en Bare Metal. Une erreur dans ce fichier peut empêcher le microcontrôleur de démarrer ou provoquer des crashs.<br />
Rôles principaux :<br />
<br />
- Définir l'environnement nécessaire à l'exécution de main().<br />
<br />
- S'exécuter avant main() et lancer ensuite main().<br />
<br />
- Être adapté à la target (processeur) utilisée.<br />
<br />
- Placer correctement la table des vecteurs comme exigé par les ARM Cortex-M.<br />
<br />
- Initialiser la pile correctement.<br />
<br />
- Initialiser les sections .data et .bss dans la SRAM.<br />
<br />
====== Linker (.ld) ======<br />
Le Linker Script détermine comment les sections du code sont placées en mémoire.<br />
''Fonctionnalités :''<br />
- Définir les adresses absolues des sections.<br />
<br />
- Définir les zones mémoire, leurs tailles et adresses.<br />
<br />
- Fournir les instructions au linker GNU via l'option -T.<br />
<br />
- L'extension de fichier est .ld.<br />
<br />
Le code linker sert à guider le compilateur pour assembler toutes les sections d’un programme en un fichier binaire unique. Sur un microcontrôleur comme le '''STM32F410RB''', il faut indiquer où chaque partie du code et des données doit être placée dans la '''mémoire du MCU :'''<br />
<br />
- Où commence le code executable, son point d'entrée ;<br />
<br />
- Définit chaque region de la memoire qui existe sur le microcontrolleur et leur taille ;<br />
<br />
- Où placer les sections differentes du code en memoire (exemple : interruption, etc...).<br />
Dans l'idée on peut le faire à la main afin de mieux assimiler le linker puis récuperer celui générer automatiquement par le logiciel STM32IDE (également disponible sur github) afin de ne pas avoir a y retoucher a chaque fois et ne pas briquer accidentellement notre puce.<br />
Pour realiser un linker on doit preciser la SRAM et sa flash. Cette partie décrit les zones mémoire physiques du STM32F410RB. Il faut se fier au plan memoire de la datasheet p.40/763<br />
Sur celui-ci nous constatons que SRAM est à 32kB et commence à 0x2000 0000<br />
<br />
et que la fash commence à 0x0800 0000 et sa taille est de 128kB (donné à la figure 1 page 37/763)<br />
On peut alors placer dans le linker :<syntaxhighlight lang="c"><br />
MEMORY<br />
{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
</syntaxhighlight>(rx) → read et execute, donc on peut lire et exécuter du code dedans.<br />
(rwx) → read, write, execute (en pratique, on n’exécute pas depuis la RAM, mais certains MCU le permettent).<br />
'''<u>Sections</u>'''Chaque programme compilé contient plusieurs sections générées par le compilateur. L'ordre à laquelle ils sont cris découle de la convention utilisé dans CMSIS (fichier startup fournis par ARM).<br />
<br />
<br />
Tous les compilateurs suivent la même idée :<br />
<br />
- Sections nécessaires au CPU d’abord (vecteurs, code)<br />
<br />
- Sections de données ensuite (initialisées, non initialisées)<br />
<br />
- Mémoire dynamique à la fin (heap, stack)<br />
La '''partie ISR_VECTOR''' indique les vecteurs d'interruptions :<syntaxhighlight lang="c"><br />
isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
</syntaxhighlight>".isr_vector" : C'est la section qui contient le vecteur d'interruptions (ISR - Interrupt Service Routine). Les vecteurs d'interruptions sont des adresses de fonction qui seront appelées lorsque des interruptions spécifiques se produisent.<br />
"KEEP" : Cette directive indique au linker de conserver cette section dans le binaire final, même si elle semble inutilisée par le programme. Cela est crucial pour les vecteurs d'interruptions qui doivent absolument être présents dans le binaire.<br />
">FLASH" : Cela indique que cette section doit être placée en mémoire Flash, qui est généralement de la mémoire non-volatile, utilisée pour stocker le programme.<br />
Elle est placée en Flash pour être disponible dès le reset.<br />
La '''partie TEXT''' contient le code de notre programme :<syntaxhighlight lang="c"><br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
</syntaxhighlight>.text = code exécutable (fonctions, instructions machine).<br />
.rodata = données constantes (const int, chaînes de caractères, etc.).<br />
<br />
_etext marque la fin de la zone code, utile pour copier ensuite la section .data au démarrage.<br />
ALIGN(4) permet d'aligner l'adresse courante sur une frontière de 4 octets. Cela garantit que le code est correctement aligné en mémoire, ce qui peut être nécessaire pour des performances optimales ou des restrictions matérielles.<br />
La '''partie DATA''' contient les variables initialisées :<syntaxhighlight lang="c"><br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
</syntaxhighlight>.data contient les variables globales initialisées (ex: int x = 5;).<br />
Ces valeurs sont stockées dans la Flash au moment de la programmation, mais copiées dans la RAM lors du démarrage (d’où >SRAM AT>FLASH).<br />
<br />
_sdata et _edata servent au code d’initialisation (startup.s) pour savoir quoi copier et combien d’octets.<br />
La partie BSS contient les variables non initialisées :<syntaxhighlight lang="c"><br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
</syntaxhighlight>.bss contient les variables globales non initialisées (ex: int counter;).<br />
Ces variables ne sont pas stockées en Flash, car elles ne contiennent pas de valeur initiale.<br />
<br />
Au démarrage, le startup code remplit cette zone avec des zéros (memset), d’où “zeroed during startup”.<br />
Et voici le code complet du linker : <syntaxhighlight lang="c"><br />
MEMORY{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
<br />
SECTIONS<br />
{<br />
.isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
<br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
}<br />
<br />
</syntaxhighlight>Il a été tester sur ce main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
// do two dummy reads after enabling the peripheral clock, as per the errata<br />
volatile uint32_t dummy;<br />
dummy = RCC->AHB1ENR;<br />
dummy = RCC->AHB1ENR;<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Et le makefile :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = faisALaMainLinker.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Fichiers objets<br />
OBJS = main.o system_stm32f4xx.o startup_stm32f410rx.o<br />
<br />
# Cible principale<br />
all: main.elf<br />
<br />
main.elf: $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
main.o: main.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
system_stm32f4xx.o: ../00-cmsis-device-f4-master/Source/Templates/system_stm32f4xx.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
startup_stm32f410rx.o: ../01-lib/gcc/startup_stm32f410rx.s<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
firmware.bin: main.elf<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: firmware.bin<br />
st-flash write firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -f *.o *.elf *.bin<br />
<br />
size:<br />
arm-none-eabi-size main.elf<br />
<br />
</syntaxhighlight><br />
<br />
===== Processus de compilation : =====<br />
- Le linker assemble ces fichiers et les place correctement en mémoire, générant un fichier .elf.<br />
<br />
- Le fichier .elf est converti en .bin et téléversé dans le microcontrôleur via ST-LINK ou OpenOCD.<br />
[[Fichier:SchemaCompil.png|centré|vignette|425x425px|Schéma chaine compilation]]<br />
<br />
<br />
Nous retrouvons notre code principale en .c qui est compiler pour en ressortir des fichiers .o qui seront ensuite traiter dans le bloc Linker qui fera le lien entre le code et les blocs mémoires réelles. A la sortie nous aurons des .elf qui un fois dans le programmer le transformera en .bin et y sera téléverser dans le uControleur.<br />
<br />
====== CMSIS ======<br />
C'est à ce lien : <nowiki>https://github.com/STMicroelectronics/cmsis-device-f4</nowiki> qu'on vient télécharger la bibliothèque CMSIS (Cortex Microcontroller Software Interface Standard).<br />
<br />
CMSIS (Cortex Microcontroller Software Interface Standard) simplifie l'accès au matériel, l'équivalent d'un "#include <avr/io.h>" pour ARM.<br />
<br />
C'est une bibliothèque fournie par ARM et ST, qui simplifie l'accès au matériel en proposant :<br />
<br />
- Des définitions pour tous les registres du MCU<br />
<br />
- Les prototypes des fonctions système (comme SystemInit())<br />
<br />
- La table des vecteurs d'interruptions (startup code)<br />
<br />
Si on veut la bibliothèque contenant plus d'information et des examples on peut se fier a ce repertoire : https://github.com/STMicroelectronics/STM32CubeF4/tree/master.<br />
<br />
====== Aide à la compilation avec un simple Blink ======<br />
Récuperation des fichiers "syscall.c" et "sysmem.c" : <nowiki>https://github.com/STMicroelectronics/STM32CubeF4/tree/master/Projects/STM32F410xx-Nucleo/Templates/STM32CubeIDE/Example/User</nowiki><br />
Voici le Makefile correspondant :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib/User \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = generatedLinkerIDE.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Répertoire build et bin<br />
BUILD = build<br />
BIN = bin<br />
<br />
# Fichiers source<br />
SRCS := main.c \<br />
../01-lib/User/syscalls.c \<br />
../01-lib/User/sysmem.c \<br />
../01-lib/system_stm32f4xx.c<br />
# Fichier startup asm<br />
ASM_SRCS = ../01-lib/gcc/startup_stm32f410rx.s<br />
<br />
# Objets<br />
OBJS = $(patsubst %.c,$(BUILD)/%.o,$(notdir $(SRCS))) \<br />
$(patsubst %.s,$(BUILD)/%.o,$(notdir $(ASM_SRCS)))<br />
<br />
<br />
# Cible principale<br />
all: $(BUILD)/main.elf<br />
<br />
# Crée le dossier build/ et bin/<br />
$(BUILD):<br />
mkdir -p $(BUILD)<br />
<br />
$(BIN):<br />
mkdir -p $(BIN)<br />
<br />
# Link<br />
$(BUILD)/main.elf: $(BUILD) $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
$(BUILD)/%.o: %.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../01-lib/User/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../00-cmsis-device-f4-master/Source/Templates/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
$(BUILD)/%.o: ../01-lib/gcc/%.s | $(BUILD)<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
$(BIN)/firmware.bin: $(BUILD)/main.elf | $(BIN)<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: $(BIN)/firmware.bin<br />
st-flash write $(BIN)/firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -rf $(BUILD) $(BIN)<br />
<br />
size:<br />
arm-none-eabi-size $(BUILD)/main.elf<br />
</syntaxhighlight>et le main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Nous faisons simplement clignoter une led afin de préparer l'environnement de compilation et vérifier que tout fonctionne. Comme ça, si il y a un bug nous pourrons vite isoler cette étape.<br />
<br />
<br />
Afin de faire clignoter une LED il faut :<br />
1. Activer l'horloge du GPIO correspondant. Pour ce faire, nous modifions le registre RCC->AHB1ENR. (Cf datasheet RM0401 p.119/763)<syntaxhighlight lang="c"><br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIO<PORT>EN_Pos);<br />
<br />
</syntaxhighlight>2. Définir la direction du PIN via le registre<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2);<br />
<br />
</syntaxhighlight>"PB2" => PORT = B et PIN_NUM = 2<br />
Ici par exemple le PIN 3 correspond au 6ieme et 7ieme bit de MODER.<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2); // Output<br />
<br />
</syntaxhighlight>3. Définir le type de sortie (Registre OTYPER)<syntaxhighlight lang="c"><br />
GPIO<PORT>->OTYPER &= ~(0x1 << (<PIN_NUM>)); // Push pull<br />
<br />
</syntaxhighlight>4. Définir le type de pull (Registre PUPDR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->PUPDR &= ~(0x3 << (<PIN_NUM> * 2)); // Forcage 00 : No pull<br />
<br />
</syntaxhighlight>5. Etape finale : écriture sur le pin (Registre ODR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->ODR ^= (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>On peut également modifier de façon atomique (donc juste 1 bit pas tous) via le registre BSRR.<syntaxhighlight lang="c"><br />
if (GPIO<PORT>->ODR & (1 << <PIN_NUM>))<br />
GPIO<PORT>->BSRR = (1 << (<PIN_NUM> + 16)); // Ici 16 est l'offset à ajouter afin d'avoir le bon registre pour eteindre<br />
else<br />
GPIO<PORT>->BSRR = (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>Lorsque BSRR est lu il est reset juste après et cela permet d'éviter les conflits si une interruption intervient et modifie ODR entre 2 instructions.<br />
Après on peut également toucher a la vitesse du pin (Registre OSPEEDR) si l'on souhaite optimiser la consommation de batterie.<br />
''Note : Remplacer <PORT> par A ou B ou C ou etc... et remplacer <PIN> par 1,2,etc.. selon ce qu'on veut activer''<br />
<br />
====== Acceder a PA2 et PA3 sur la Nucleo ======<br />
"SB62 and SB63 must be ON, while SB13 and SB14 must be OFF." Extrait de la datasheet UM1724 : Chapitre7.10 p26/91 <br />
<br />
Il faut dessouder les resistances bridges pour acceder ces ports. Et ensuite deplacer le jumper sur U5V.<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
===== SPI =====<br />
Nous allons programmer le SPI sur notre microcontrolleur et tester ce code pour la carte Sparkfun Serial 7-Segments Display. Sur ce git : <nowiki>https://github.com/sparkfun/Serial7SegmentDisplay/wiki/Serial-7-Segment-Display-Datasheet</nowiki> se trouve la datasheet de cette carte que nous allons utiliser pour communiquer en SPI. Dans l'idée, nous allons programmer une bibliothèque suffisament complète afin de pouvoir simplement d'afficher "9" via une commande dans ce style dans notre main : "spi_sent('G');"<br />
<br />
On peut tout d'abord centraliser la logique des initialisations des pins afin d'alleger le main (Cf fichier hardware_setup.c et .h) .<br />
[[Fichier:Carte7SegmentSparkFunPinout.png|centré|vignette|446x446px|7 segments SparkFun Pinout]]<br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8737SE4Binome2025-62026-01-05T13:54:03Z<p>Cpayet : /* Bcp de detail la miam */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
====== Startup (.s) ======<br />
Le Startup file est crucial en Bare Metal. Une erreur dans ce fichier peut empêcher le microcontrôleur de démarrer ou provoquer des crashs.<br />
Rôles principaux :<br />
<br />
- Définir l'environnement nécessaire à l'exécution de main().<br />
<br />
- S'exécuter avant main() et lancer ensuite main().<br />
<br />
- Être adapté à la target (processeur) utilisée.<br />
<br />
- Placer correctement la table des vecteurs comme exigé par les ARM Cortex-M.<br />
<br />
- Initialiser la pile correctement.<br />
<br />
- Initialiser les sections .data et .bss dans la SRAM.<br />
<br />
====== Linker (.ld) ======<br />
Le Linker Script détermine comment les sections du code sont placées en mémoire.<br />
''Fonctionnalités :''<br />
- Définir les adresses absolues des sections.<br />
<br />
- Définir les zones mémoire, leurs tailles et adresses.<br />
<br />
- Fournir les instructions au linker GNU via l'option -T.<br />
<br />
- L'extension de fichier est .ld.<br />
<br />
Le code linker sert à guider le compilateur pour assembler toutes les sections d’un programme en un fichier binaire unique. Sur un microcontrôleur comme le '''STM32F410RB''', il faut indiquer où chaque partie du code et des données doit être placée dans la '''mémoire du MCU :'''<br />
<br />
- Où commence le code executable, son point d'entrée ;<br />
<br />
- Définit chaque region de la memoire qui existe sur le microcontrolleur et leur taille ;<br />
<br />
- Où placer les sections differentes du code en memoire (exemple : interruption, etc...).<br />
Dans l'idée on peut le faire à la main afin de mieux assimiler le linker puis récuperer celui générer automatiquement par le logiciel STM32IDE (également disponible sur github) afin de ne pas avoir a y retoucher a chaque fois et ne pas briquer accidentellement notre puce.<br />
Pour realiser un linker on doit preciser la SRAM et sa flash. Cette partie décrit les zones mémoire physiques du STM32F410RB. Il faut se fier au plan memoire de la datasheet p.40/763<br />
Sur celui-ci nous constatons que SRAM est à 32kB et commence à 0x2000 0000<br />
<br />
et que la fash commence à 0x0800 0000 et sa taille est de 128kB (donné à la figure 1 page 37/763)<br />
On peut alors placer dans le linker :<syntaxhighlight lang="c"><br />
MEMORY<br />
{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
</syntaxhighlight>(rx) → read et execute, donc on peut lire et exécuter du code dedans.<br />
(rwx) → read, write, execute (en pratique, on n’exécute pas depuis la RAM, mais certains MCU le permettent).<br />
'''<u>Sections</u>'''Chaque programme compilé contient plusieurs sections générées par le compilateur. L'ordre à laquelle ils sont cris découle de la convention utilisé dans CMSIS (fichier startup fournis par ARM).<br />
<br />
<br />
Tous les compilateurs suivent la même idée :<br />
<br />
- Sections nécessaires au CPU d’abord (vecteurs, code)<br />
<br />
- Sections de données ensuite (initialisées, non initialisées)<br />
<br />
- Mémoire dynamique à la fin (heap, stack)<br />
La '''partie ISR_VECTOR''' indique les vecteurs d'interruptions :<syntaxhighlight lang="c"><br />
isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
</syntaxhighlight>".isr_vector" : C'est la section qui contient le vecteur d'interruptions (ISR - Interrupt Service Routine). Les vecteurs d'interruptions sont des adresses de fonction qui seront appelées lorsque des interruptions spécifiques se produisent.<br />
"KEEP" : Cette directive indique au linker de conserver cette section dans le binaire final, même si elle semble inutilisée par le programme. Cela est crucial pour les vecteurs d'interruptions qui doivent absolument être présents dans le binaire.<br />
">FLASH" : Cela indique que cette section doit être placée en mémoire Flash, qui est généralement de la mémoire non-volatile, utilisée pour stocker le programme.<br />
Elle est placée en Flash pour être disponible dès le reset.<br />
La '''partie TEXT''' contient le code de notre programme :<syntaxhighlight lang="c"><br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
</syntaxhighlight>.text = code exécutable (fonctions, instructions machine).<br />
.rodata = données constantes (const int, chaînes de caractères, etc.).<br />
<br />
_etext marque la fin de la zone code, utile pour copier ensuite la section .data au démarrage.<br />
ALIGN(4) permet d'aligner l'adresse courante sur une frontière de 4 octets. Cela garantit que le code est correctement aligné en mémoire, ce qui peut être nécessaire pour des performances optimales ou des restrictions matérielles.<br />
La '''partie DATA''' contient les variables initialisées :<syntaxhighlight lang="c"><br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
</syntaxhighlight>.data contient les variables globales initialisées (ex: int x = 5;).<br />
Ces valeurs sont stockées dans la Flash au moment de la programmation, mais copiées dans la RAM lors du démarrage (d’où >SRAM AT>FLASH).<br />
<br />
_sdata et _edata servent au code d’initialisation (startup.s) pour savoir quoi copier et combien d’octets.<br />
La partie BSS contient les variables non initialisées :<syntaxhighlight lang="c"><br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
</syntaxhighlight>.bss contient les variables globales non initialisées (ex: int counter;).<br />
Ces variables ne sont pas stockées en Flash, car elles ne contiennent pas de valeur initiale.<br />
<br />
Au démarrage, le startup code remplit cette zone avec des zéros (memset), d’où “zeroed during startup”.<br />
Et voici le code complet du linker : <syntaxhighlight lang="c"><br />
MEMORY{<br />
FLASH (rx): ORIGIN = 0x08000000, LENGTH = 128K<br />
SRAM (rwx): ORIGIN = 0x20000000, LENGTH = 32K<br />
}<br />
<br />
SECTIONS<br />
{<br />
.isr_vector :<br />
{<br />
KEEP(*(.isr_vector))<br />
} >FLASH<br />
<br />
.text :<br />
{<br />
. = ALIGN(4);<br />
<br />
*(.text)<br />
*(.rodata)<br />
<br />
. = ALIGN(4);<br />
_etext = .;<br />
} >FLASH<br />
<br />
.data :<br />
{<br />
. = ALIGN(4);<br />
_sdata = .;<br />
<br />
*(.data)<br />
<br />
. = ALIGN(4);<br />
_edata = .;<br />
} >SRAM AT> FLASH<br />
<br />
.bss :<br />
{<br />
. = ALIGN(4);<br />
_sbss = .;<br />
<br />
*(.bss)<br />
<br />
. = ALIGN(4);<br />
_ebss = .;<br />
} >SRAM<br />
}<br />
<br />
</syntaxhighlight>Il a été tester sur ce main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
// do two dummy reads after enabling the peripheral clock, as per the errata<br />
volatile uint32_t dummy;<br />
dummy = RCC->AHB1ENR;<br />
dummy = RCC->AHB1ENR;<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Et le makefile :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = faisALaMainLinker.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Fichiers objets<br />
OBJS = main.o system_stm32f4xx.o startup_stm32f410rx.o<br />
<br />
# Cible principale<br />
all: main.elf<br />
<br />
main.elf: $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
main.o: main.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
system_stm32f4xx.o: ../00-cmsis-device-f4-master/Source/Templates/system_stm32f4xx.c<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
startup_stm32f410rx.o: ../01-lib/gcc/startup_stm32f410rx.s<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
firmware.bin: main.elf<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: firmware.bin<br />
st-flash write firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -f *.o *.elf *.bin<br />
<br />
size:<br />
arm-none-eabi-size main.elf<br />
<br />
</syntaxhighlight><br />
<br />
===== Processus de compilation : =====<br />
- Le linker assemble ces fichiers et les place correctement en mémoire, générant un fichier .elf.<br />
<br />
- Le fichier .elf est converti en .bin et téléversé dans le microcontrôleur via ST-LINK ou OpenOCD.<br />
[[Fichier:SchemaCompil.png|centré|vignette|425x425px|Schéma chaine compilation]]<br />
<br />
<br />
Nous retrouvons notre code principale en .c qui est compiler pour en ressortir des fichiers .o qui seront ensuite traiter dans le bloc Linker qui fera le lien entre le code et les blocs mémoires réelles. A la sortie nous aurons des .elf qui un fois dans le programmer le transformera en .bin et y sera téléverser dans le uControleur.<br />
<br />
====== CMSIS ======<br />
C'est à ce lien : <nowiki>https://github.com/STMicroelectronics/cmsis-device-f4</nowiki> qu'on vient télécharger la bibliothèque CMSIS (Cortex Microcontroller Software Interface Standard).<br />
<br />
CMSIS (Cortex Microcontroller Software Interface Standard) simplifie l'accès au matériel, l'équivalent d'un "#include <avr/io.h>" pour ARM.<br />
<br />
C'est une bibliothèque fournie par ARM et ST, qui simplifie l'accès au matériel en proposant :<br />
<br />
- Des définitions pour tous les registres du MCU<br />
<br />
- Les prototypes des fonctions système (comme SystemInit())<br />
<br />
- La table des vecteurs d'interruptions (startup code)<br />
<br />
Si on veut la bibliothèque contenant plus d'information et des examples on peut se fier a ce repertoire : https://github.com/STMicroelectronics/STM32CubeF4/tree/master.<br />
<br />
====== Aide à la compilation avec un simple Blink ======<br />
Récuperation des fichiers "syscall.c" et "sysmem.c" : <nowiki>https://github.com/STMicroelectronics/STM32CubeF4/tree/master/Projects/STM32F410xx-Nucleo/Templates/STM32CubeIDE/Example/User</nowiki><br />
Voici le Makefile correspondant :<syntaxhighlight lang="makefile"><br />
# Compilateur et options<br />
CC = arm-none-eabi-gcc<br />
<br />
CFLAGS = -mcpu=cortex-m4 -mthumb -Wall -Wextra<br />
CPPFLAGS = -DSTM32F410Rx \<br />
-I../01-lib/gcc \<br />
-I../01-lib/Core \<br />
-I../01-lib/User \<br />
-I../01-lib<br />
<br />
# Linker<br />
LINKER_FILE = generatedLinkerIDE.ld<br />
LDFLAGS = -T $(LINKER_FILE)<br />
<br />
# Répertoire build et bin<br />
BUILD = build<br />
BIN = bin<br />
<br />
# Fichiers source<br />
SRCS := main.c \<br />
../01-lib/User/syscalls.c \<br />
../01-lib/User/sysmem.c \<br />
../01-lib/system_stm32f4xx.c<br />
# Fichier startup asm<br />
ASM_SRCS = ../01-lib/gcc/startup_stm32f410rx.s<br />
<br />
# Objets<br />
OBJS = $(patsubst %.c,$(BUILD)/%.o,$(notdir $(SRCS))) \<br />
$(patsubst %.s,$(BUILD)/%.o,$(notdir $(ASM_SRCS)))<br />
<br />
<br />
# Cible principale<br />
all: $(BUILD)/main.elf<br />
<br />
# Crée le dossier build/ et bin/<br />
$(BUILD):<br />
mkdir -p $(BUILD)<br />
<br />
$(BIN):<br />
mkdir -p $(BIN)<br />
<br />
# Link<br />
$(BUILD)/main.elf: $(BUILD) $(OBJS)<br />
$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -lc -lm -lnosys -o $@<br />
<br />
# Compilation des fichiers C<br />
$(BUILD)/%.o: %.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../01-lib/User/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
$(BUILD)/%.o: ../00-cmsis-device-f4-master/Source/Templates/%.c | $(BUILD)<br />
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@<br />
<br />
# Assemblage du startup<br />
$(BUILD)/%.o: ../01-lib/gcc/%.s | $(BUILD)<br />
arm-none-eabi-as -mcpu=cortex-m4 -mthumb $< -o $@<br />
<br />
# Converti ELF en BIN<br />
$(BIN)/firmware.bin: $(BUILD)/main.elf | $(BIN)<br />
arm-none-eabi-objcopy -O binary $< $@<br />
<br />
# Upload <br />
flash: $(BIN)/firmware.bin<br />
st-flash write $(BIN)/firmware.bin 0x8000000<br />
<br />
# Nettoyage<br />
clean:<br />
rm -rf $(BUILD) $(BIN)<br />
<br />
size:<br />
arm-none-eabi-size $(BUILD)/main.elf<br />
</syntaxhighlight>et le main.c :<syntaxhighlight lang="c"><br />
#include "../01-lib/stm32f410rx.h"<br />
<br />
#include <stdint.h><br />
<br />
#define LED_PIN 5<br />
<br />
int main(void) {<br />
// Activer horloge GPIOA<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOAEN_Pos);<br />
<br />
GPIOA->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOA->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOA->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOA->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOA->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight>Nous faisons simplement clignoter une led afin de préparer l'environnement de compilation et vérifier que tout fonctionne. Comme ça, si il y a un bug nous pourrons vite isoler cette étape.<br />
<br />
<br />
Afin de faire clignoter une LED il faut :<br />
1. Activer l'horloge du GPIO correspondant. Pour ce faire, nous modifions le registre RCC->AHB1ENR. (Cf datasheet RM0401 p.119/763)<syntaxhighlight lang="c"><br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIO<PORT>EN_Pos);<br />
<br />
</syntaxhighlight>2. Définir la direction du PIN via le registre<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2);<br />
<br />
</syntaxhighlight>"PB2" => PORT = B et PIN_NUM = 2<br />
Ici par exemple le PIN 3 correspond au 6ieme et 7ieme bit de MODER.<syntaxhighlight lang="c"><br />
GPIO<PORT>->MODER |= 0x1 << (<PIN_NUM> * 2); // Output<br />
<br />
</syntaxhighlight>3. Définir le type de sortie (Registre OTYPER)<syntaxhighlight lang="c"><br />
GPIO<PORT>->OTYPER &= ~(0x1 << (<PIN_NUM>)); // Push pull<br />
<br />
</syntaxhighlight>4. Définir le type de pull (Registre PUPDR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->PUPDR &= ~(0x3 << (<PIN_NUM> * 2)); // Forcage 00 : No pull<br />
<br />
</syntaxhighlight>5. Etape finale : écriture sur le pin (Registre ODR)<syntaxhighlight lang="c"><br />
GPIO<PORT>->ODR ^= (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>On peut également modifier de façon atomique (donc juste 1 bit pas tous) via le registre BSRR.<syntaxhighlight lang="c"><br />
if (GPIO<PORT>->ODR & (1 << <PIN_NUM>))<br />
GPIO<PORT>->BSRR = (1 << (<PIN_NUM> + 16)); // Ici 16 est l'offset à ajouter afin d'avoir le bon registre pour eteindre<br />
else<br />
GPIO<PORT>->BSRR = (1 << <PIN_NUM>);<br />
<br />
</syntaxhighlight>Lorsque BSRR est lu il est reset juste après et cela permet d'éviter les conflits si une interruption intervient et modifie ODR entre 2 instructions.<br />
Après on peut également toucher a la vitesse du pin (Registre OSPEEDR) si l'on souhaite optimiser la consommation de batterie.<br />
''Note : Remplacer <PORT> par A ou B ou C ou etc... et remplacer <PIN> par 1,2,etc.. selon ce qu'on veut activer''<br />
<br />
====== Acceder a PA2 et PA3 sur la Nucleo ======<br />
"SB62 and SB63 must be ON, while SB13 and SB14 must be OFF." Extrait de la datasheet UM1724 : Chapitre7.10 p26/91 <br />
<br />
Il faut dessouder les resistances bridges pour acceder ces ports. Et ensuite deplacer le jumper sur U5V.<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
===== SPI =====<br />
Nous allons programmer le SPI sur notre microcontrolleur et tester ce code pour la carte Sparkfun Serial 7-Segments Display.<br />
Sur ce git : <nowiki>https://github.com/sparkfun/Serial7SegmentDisplay/wiki/Serial-7-Segment-Display-Datasheet</nowiki> se trouve la datasheet de cette carte que nous allons utiliser pour communiquer en SPI.<br />
Dans l'idée, nous allons programmer une bibliothèque suffisament complète afin de pouvoir simplement d'afficher "9" via une commande dans ce style dans notre main : "spi_sent('G');"<br />
On peut tout d'abord centraliser la logique des initialisations des pins afin d'alleger le main (Cf fichier hardware_setup.c et .h) .<br />
[[Fichier:Carte7SegmentSparkFunPinout.png|centré|vignette|446x446px|7 segments SparkFun Pinout]]<br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Carte7SegmentSparkFunPinout.png&diff=8736Fichier:Carte7SegmentSparkFunPinout.png2026-01-05T13:52:18Z<p>Cpayet : </p>
<hr />
<div>Carte7SegmentSparkFunPinout</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:SchemaCompil.png&diff=8722Fichier:SchemaCompil.png2026-01-05T13:10:08Z<p>Cpayet : </p>
<hr />
<div>SchemaCompil</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8685SE4Binome2025-62026-01-03T22:27:16Z<p>Cpayet : /* LUFA */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
<br />
A FAIRE PROPREMENT<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
if (btn51)<br />
KeyboardReport->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). Update : Dernier bouton trouvé :) Clavier entierement mappé ! <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8684SE4Binome2025-62025-12-30T22:51:53Z<p>Cpayet : Ajout code 1ere partie</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
<br />
A FAIRE PROPREMENT<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
// if (btn51) KeyboardReport->KeyCode[UsedKeyCodes++] = ; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8683SE4Binome2025-62025-12-30T22:50:37Z<p>Cpayet : Ajout code 1ere partie</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
<br />
A FAIRE PROPREMENT<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
// if (btn51) KeyboardReport->KeyCode[UsedKeyCodes++] = ; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
<br />
A AJOUTER APRES<br />
<br />
<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8682SE4Binome2025-62025-12-30T22:48:50Z<p>Cpayet : Ajout code 1ere partie</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
<br />
A FAIRE PROPREMENT<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
// if (btn51) KeyboardReport->KeyCode[UsedKeyCodes++] = ; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8681SE4Binome2025-62025-12-30T22:44:51Z<p>Cpayet : /* HARWARE */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Le routage à été modifié sur kicad par la suite et l'erreur réparé comme on peut le voir sur la photo.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Faire un ordonnanceur sur une architecture AVR est nécessaire si l'on souhaite ensuite le faire sur une architecture ARM Cortex M4 qui est bien plus complexe. <br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARDWARE ======<br />
<syntaxhighlight lang="c"><br />
#include "hardware.h"<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
#include "../USART/usart.h"<br />
<br />
<br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
<br />
int readPin(volatile uint8_t *PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
<br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
<br />
</syntaxhighlight>Et son .h :<syntaxhighlight lang="c"><br />
#ifndef HARDWARE_H<br />
#define HARDWARE_H<br />
<br />
#include <stdint.h><br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN PIND<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
<br />
// ------------------ Prototypes ------------------ //<br />
void setupClock();<br />
<br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode);<br />
int readPin(volatile uint8_t* PINx, uint8_t pin);<br />
void setupHardware();<br />
<br />
void toggleLedCS1();<br />
void toggleLedCS2();<br />
void toggleLedCS3();<br />
void toggleLedCS4();<br />
<br />
void taskToggleCS1();<br />
void taskToggleCS2();<br />
void taskToggleCS3();<br />
void taskToggleCS4();<br />
<br />
#endif<br />
</syntaxhighlight>Dans la librairie hardware.c nous avons es ensembles de fonctions lié à notre matérielle pour son initialisation et son contrôle ou sa lecture (de pin).<br />
<br />
====== USART ======<br />
Dans la librarie USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include <avr/io.h><br />
#include <stdint.h><br />
#include <util/delay.h><br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
<br />
</syntaxhighlight>Et usart.h :<syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
// Baud rate variable que l'on peut modifier<br />
#define BAUD_RATE 9600<br />
<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU / 16 / BAUD_RATE) - 1)<br />
<br />
void init_usart();<br />
void usart_send(unsigned char data);<br />
unsigned char usart_receive();<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
Task.c :<syntaxhighlight lang="c"><br />
#include "../HARDWARE/hardware.h"<br />
#include "../ORDONNANCEUR/ordonnanceur.h"<br />
#include "../USART/usart.h"<br />
<br />
#include "task.h"<br />
<br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
{taskSendSerialB, 0x06E0, AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task) / sizeof(task[0]);<br />
<br />
void init_tasks() {<br />
for (int i = 0; i < nbTasks; i++) {<br />
init_pile(i);<br />
}<br />
}<br />
<br />
void taskCS1() {<br />
while (1) {<br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
}<br />
}<br />
<br />
void taskCS2() {<br />
while (1) {<br />
toggleLedCS2();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS3() {<br />
while (1) {<br />
toggleLedCS3();<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskCS4() {<br />
while (1) {<br />
toggleLedCS4();<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
<br />
</syntaxhighlight>Task.h: <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
typedef enum {<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
extern process task[];<br />
extern const uint8_t nbTasks;<br />
<br />
void init_tasks();<br />
void task_led(void (*toggleFunc)(void), uint16_t ms);<br />
<br />
void taskCS1();<br />
void taskCS2();<br />
void taskCS3();<br />
void taskCS4();<br />
void taskSendSerialA();<br />
void taskSendSerialB();<br />
<br />
#endif<br />
</syntaxhighlight>Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
On définit un tableau de tâches ainsi : <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight>Le nombre de tâche est calculé automatique pour ne pas s'embêter à le faire à chaque fois que l'on modifie de le tableau de tâche.<br />
<br />
Si certaines tâches sont commentés c'est parceque sur cette 1ere version d'ordonnanceur, nous avons fais au plus simple sans contrôle de tache endormi, nous ne pourrons donc pas avoir un résultat propre avec plusieurs tâches simultanément.<br />
<br />
====== ORDONNANCEUR ======<br />
ordonnanceur.c : <syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
#include <avr/interrupt.h><br />
<br />
#include "../HARDWARE/hardware.h"<br />
<br />
int currentTask = 0;<br />
uint16_t tick_ms = 0;<br />
<br />
// ------------------ TIMER ------------------ //<br />
void init_timer1(int diviseur, long periode_ms) {<br />
tick_ms = periode_ms;<br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch (diviseur) {<br />
case 64:<br />
TCCR1B |= (1 << CS11) | (1 << CS10);<br />
break;<br />
case 256:<br />
TCCR1B |= (1 << CS12);<br />
break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
<br />
// ------------------ PILE ------------------ //<br />
void init_pile(int n) {<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" ::"r"(addr));<br />
asm volatile("push %B0" ::"r"(addr));<br />
<br />
// r0-r31<br />
for (int i = 0; i < 32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" ::"r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
<br />
// ------------------ SCHEDULER ------------------ //<br />
void scheduler(void) {<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
// ------------------ ISR TIMER1 ------------------ //<br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) {<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
<br />
</syntaxhighlight>Nous avons ici un ordonnanceur préemptif : une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine qui va : <br />
* Sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* Appeller l'ordonnanceur qui va faire la bascule des tâches.<br />
* Restorer le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité sous sa forme la plus minimaliste.<br />
====== MAIN ======<br />
Dans le fichier main.c, voici comment les librairies vu ensemble precedemment sont appelés :<syntaxhighlight lang="c"><br />
#include <avr/interrupt.h><br />
#include <util/delay.h><br />
<br />
#include "./lib/HARDWARE/hardware.h"<br />
#include "./lib/ORDONNANCEUR/ordonnanceur.h"<br />
<br />
#include "./lib/TASK/task.h"<br />
#include "./lib/USART/usart.h"<br />
<br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
<br />
setupHardware();<br />
<br />
// initialisation des piles<br />
init_tasks();<br />
<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microcontrolleur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A sur notre Git.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6 basé sur un Cortex-M4.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<p style="clear: both;" />Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<p style="clear: both;" />Toutes les datasheets ayant servi pour la creation du Kicad de la carte se trouve dans le dossier Datasheet.<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir le bloc mémoire :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour tester en premier lieu le microcontrolleur puis l'ordonnanceur.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour la programmation de la carte :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" /><br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" />C'est un peu l'équivalent arduino, on code avec l'abstraction matérielle. Nous allons par la suite proceder au niveau bare metal.<br />
<br />
===== Bare metal =====<br />
Ce chapitre présente la programmation Bare Metal sur microcontrôleurs ARM, en utilisant un STM32 NUCLEO-F410RB comme exemple. Nous aborderons le startup, le linker, les exemples de clignotement LED, l'utilisation de CMSIS, ainsi que la gestion de périphériques comme le SPI, l'UART, etc...<br />
<br />
<br />
A FAIRE PROPREMENT<br />
<br />
===== Système de fichier =====<br />
<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" />'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<p style="clear: both;" />La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#include "../00-lib/stm32f410rx.h"<br />
<br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight>Maintenant que la carte à été testé nous avons fais plusieurs code intermediaire pour tester chaque primitive séparemment. Je vais detailler seulement code finale pour ne pas se répéter. <br />
<br />
===== Carte =====<br />
Dans ce dossier nous retrouverons toutes les librairies liés au contrôle des cartes filles correspondantes.<br />
<br />
====== Carte ecran ======<br />
L'idée est d'avoir une librairie permettant de controller une carte écran et d'afficher un compteur sur celui-ci. Notre carte écran est ici l'afficheur 7 segments de Sparkfun. <br />
<br />
carteEcran.c :<syntaxhighlight lang="c"><br />
#include "carteEcran.h"<br />
#include <stdint.h><br />
<br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void _ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
// Ces pins s'active à l'etat bas<br />
onPin(CS5_GPIO, CS5_PIN); // CS OFF<br />
<br />
offPin(RST5_GPIO, RST5_PIN); // RST ON<br />
onPin(RST5_GPIO, RST5_PIN); // RST OFF<br />
<br />
// Non utilisé ici<br />
// onPin(INT5_GPIO, INT5_PIN); // S'active à l'etat bas ?<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
void ecran_select_digit(uint8_t digit) {<br />
// Sécurité maximum digit<br />
if (digit >= 3)<br />
digit = 3;<br />
<br />
ecran_spi_write(0x79); // Cursor command<br />
ecran_spi_write(digit); // 0 à 3<br />
}<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight>Et son .h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include "../../SPI/spi.h"<br />
#include "../../GPIO/gpio.h"<br />
<br />
// Fonction inter librairie<br />
void _ecran_init();<br />
<br />
// Fonctions pour l'utilisateur<br />
void ecran_spi_write(uint8_t data);<br />
void ecran_brightness(uint8_t intensite);<br />
void ecran_select_digit(uint8_t digit);<br />
<br />
// Fonction exemple pour utilisateur<br />
void ecran_compteur();<br />
</syntaxhighlight>Les commandes de l'écran ont été trouvé sur leur site : https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
Il faut noter que la vitesse du SPI peut influencer sur la précision du SPI et donc faire échouer certains messages si la vitesse dépasse 9600 bauds rate.<br />
<br />
====== Carte clavier ======<br />
A COMPLETER<br />
<br />
===== Commande OS =====<br />
Cette librairie permet d'implémenter les commandes liés à notre OS tel que "version", "echo, et "devices".<br />
<br />
cmd_os.c: <syntaxhighlight lang="c"><br />
#include "cmd_os.h"<br />
<br />
#include "../DEVICES/devices.h"<br />
#include "../Substitute/printf.h"<br />
#include "../TASK/task.h"<br />
<br />
#include <string.h><br />
<br />
#define MAX_ARG_ECHO 20<br />
#define CMD_SIZE 128<br />
<br />
#define CHAR_CODE_ESC 0x1B<br />
#define CHAR_CODE_ENTER '\r'<br />
#define CHAR_CODE_BACKSPACE1 '\b'<br />
#define CHAR_CODE_BACKSPACE2 0x7F<br />
<br />
typedef enum {<br />
KEY_NONE,<br />
KEY_CHAR,<br />
KEY_ENTER,<br />
KEY_BACKSPACE,<br />
KEY_ARROW_UP,<br />
KEY_ARROW_DOWN,<br />
KEY_ARROW_LEFT,<br />
KEY_ARROW_RIGHT<br />
} KeyType;<br />
<br />
typedef enum {<br />
NORMAL_CHAR = 0,<br />
ESC_CHAR = 1,<br />
ARROW_CHAR = 2,<br />
} _stateKey;<br />
<br />
typedef struct {<br />
KeyType type;<br />
char ch;<br />
} KeyEvent;<br />
<br />
char current_cmd[CMD_SIZE + 1] = {'\0'};<br />
static uint8_t cmd_len = 0;<br />
<br />
_stateKey esc_state = NORMAL_CHAR;<br />
KeyEvent ev = {KEY_NONE, 0};<br />
<br />
KeyEvent _decode_key(char c) {<br />
switch (esc_state) {<br />
case NORMAL_CHAR:<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
if (c == CHAR_CODE_ESC) { // ESC<br />
esc_state = ESC_CHAR;<br />
return ev; // attente suite<br />
}<br />
<br />
if (c == CHAR_CODE_ENTER) {<br />
ev.type = KEY_ENTER;<br />
} else if (c == CHAR_CODE_BACKSPACE1 || c == CHAR_CODE_BACKSPACE2) {<br />
ev.type = KEY_BACKSPACE;<br />
} else {<br />
ev.type = KEY_CHAR;<br />
ev.ch = c;<br />
}<br />
return ev;<br />
<br />
case ESC_CHAR:<br />
if (c == '[' || c == 'O') {<br />
esc_state = ARROW_CHAR;<br />
} else {<br />
esc_state = NORMAL_CHAR; // ESC seul = abandon<br />
}<br />
return ev;<br />
<br />
case ARROW_CHAR:<br />
switch (c) {<br />
case 'A':<br />
ev.type = KEY_ARROW_UP;<br />
break;<br />
case 'B':<br />
ev.type = KEY_ARROW_DOWN;<br />
break;<br />
case 'C':<br />
ev.type = KEY_ARROW_RIGHT;<br />
break;<br />
case 'D':<br />
ev.type = KEY_ARROW_LEFT;<br />
break;<br />
default:<br />
// ignore les autres codes<br />
break;<br />
}<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
ev.type = KEY_NONE;<br />
ev.ch = 0;<br />
esc_state = NORMAL_CHAR;<br />
return ev;<br />
}<br />
<br />
void _cmdOS_inconnu() {<br />
PRINT_STRING("\r\nCommande inconnue : ");<br />
PRINT_STRING(current_cmd);<br />
PRINT_STRING("\r\n");<br />
}<br />
<br />
void _cmdOS_version() {<br />
PRINT_STRING("\r\nOS : version 0.0.2\n\r");<br />
}<br />
<br />
void _cmdOS_echo(char *input) {<br />
char *argv[MAX_ARG_ECHO];<br />
int argc = 0;<br />
<br />
// Découpe la ligne en mots<br />
char *token = strtok(input, " ");<br />
while (token != NULL && argc < MAX_ARG_ECHO) {<br />
argv[argc++] = token;<br />
token = strtok(NULL, " ");<br />
}<br />
<br />
if (argc > 0) {<br />
PRINT_STRING("\r");<br />
for (int i = 1; i < argc; i++) {<br />
PRINT_STRING(argv[i]);<br />
if (i + 1 < argc)<br />
PRINT_STRING(" ");<br />
}<br />
PRINT_STRING("\r\n\n");<br />
}<br />
}<br />
<br />
void _cmdOS_devices(void) {<br />
scan_devices();<br />
print_devices();<br />
}<br />
<br />
void _execute_command(char *cmd) {<br />
if (strcmp(cmd, "version") == 0)<br />
_cmdOS_version();<br />
else if (strcmp(cmd, "devices") == 0)<br />
_cmdOS_devices();<br />
else if (strncmp(cmd, "echo", strlen("echo")) == 0)<br />
_cmdOS_echo(cmd);<br />
else if (cmd_len > 0)<br />
_cmdOS_inconnu();<br />
}<br />
<br />
void _init_os() {<br />
PRINT_STRING("Initialisation du Pico ordinateur ");<br />
<br />
for (int i = 0; i < 6; i++) {<br />
task_delay(100);<br />
PRINT_STRING(".");<br />
}<br />
<br />
PRINT_STRING("\n\rPicoOrdi>");<br />
}<br />
<br />
void cmd_os(void) {<br />
_init_os();<br />
<br />
while (1) {<br />
while (!usart_buffer_available())<br />
;<br />
<br />
char c = GETCHAR();<br />
KeyEvent key = _decode_key(c);<br />
<br />
switch (key.type) {<br />
case KEY_CHAR:<br />
if (cmd_len < CMD_SIZE) {<br />
current_cmd[cmd_len++] = key.ch;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_CHAR(key.ch);<br />
}<br />
break;<br />
<br />
case KEY_BACKSPACE:<br />
if (cmd_len > 0) {<br />
cmd_len--;<br />
current_cmd[cmd_len] = '\0';<br />
PRINT_STRING("\b \b");<br />
}<br />
break;<br />
<br />
case KEY_ENTER:<br />
PRINT_STRING("\r\n");<br />
_execute_command(current_cmd);<br />
cmd_len = 0;<br />
current_cmd[0] = '\0';<br />
PRINT_STRING("PicoOrdi>");<br />
break;<br />
<br />
case KEY_ARROW_UP:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_DOWN:<br />
// A ajouter à la fin<br />
break;<br />
<br />
case KEY_ARROW_LEFT:<br />
PRINT_STRING("\x1B[D");<br />
cmd_len--;<br />
break;<br />
<br />
case KEY_ARROW_RIGHT:<br />
PRINT_STRING("\x1B[C");<br />
cmd_len++;<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
}<br />
</syntaxhighlight>cmd_os.h :<syntaxhighlight lang="c"><br />
#ifndef CMD_OS_H<br />
#define CMD_OS_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
<br />
/*<br />
Permet de lancer les commandes suivantes : <br />
<br />
version => Affiche la version du système d'exploitation<br />
echo => Affiche les arguments de la commande<br />
devices => Scan toutes les cartes et retourne celle connecté<br />
*/<br />
<br />
void cmd_os(void); // Affiche la liste des cartes filles connectées<br />
<br />
#endif<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Pour le moment la gestion du terminal permet de gérer la détection des flèches grâce à une implémentation de la détection de touche avec plusieurs états.<br />
<br />
===== Devices =====<br />
Cette librairie permet de <br />
<br />
device.c :<syntaxhighlight lang="c"><br />
#include "devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../Substitute/printf.h"<br />
#include <stdio.h><br />
<br />
static const GPIO_TypeDef *cs_gpios[MAX_DEVICES] = {<br />
[CS1] = GPIOC, // PC0<br />
[CS2] = GPIOA, // PA7<br />
[CS3] = GPIOC, // PC9<br />
[CS4] = GPIOA, // PA2<br />
[CS5] = GPIOC, // PC11<br />
[CS6] = GPIOA, // PA4<br />
};<br />
<br />
static const uint8_t cs_pins[MAX_DEVICES] = {<br />
[CS1] = 0, // PC0<br />
[CS2] = 7, // PA7<br />
[CS3] = 9, // PC9<br />
[CS4] = 2, // PA2<br />
[CS5] = 11, // PC11<br />
[CS6] = 4, // PA4<br />
};<br />
<br />
Device devices[MAX_DEVICES];<br />
<br />
static const char *device_names[] = {<br />
"NOT CONNECTED",<br />
"UNKNOWN",<br />
"KEYBOARD",<br />
"SCREEN",<br />
"NETWORK",<br />
"SOUND",<br />
"SD"};<br />
<br />
static const char *cs_names[] = {<br />
"PC0",<br />
"PA7",<br />
"PC9",<br />
"PA2",<br />
"PC11",<br />
"PA4"};<br />
<br />
static const char *names[] = {<br />
"Clavier",<br />
"FPGA",<br />
"Son",<br />
"Reseau",<br />
"Ecran",<br />
"SD"};<br />
<br />
void _devices_init() {<br />
// Init tableau<br />
for (int i = 0; i < MAX_DEVICES; i++) {<br />
devices[i].GPIO_CS = (GPIO_TypeDef *)cs_gpios[i];<br />
devices[i].PIN_CS = cs_pins[i];<br />
devices[i].type = UNKNOWN;<br />
}<br />
<br />
// SD toujours ici<br />
devices[5].type = SD; // Peut etre tester si connecte ou non<br />
<br />
// Scan du démarrage<br />
scan_devices();<br />
}<br />
<br />
void scan_devices() {<br />
// --------------------------------------------------------------------------------<br />
// A ajouter a la fin<br />
// --------------------------------------------------------------------------------<br />
}<br />
<br />
void print_devices() {<br />
PRINT_STRING("\r\nDevice list:\r\n");<br />
for (int device = 0; device < MAX_DEVICES; device++) {<br />
char buffer[15];<br />
<br />
sprintf(buffer, "%d", device);<br />
PRINT_STRING("N°");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(device_names[devices->type]);<br />
<br />
sprintf(buffer, "%d", device + 1);<br />
PRINT_STRING("\t\tCS");<br />
PRINT_STRING(buffer);<br />
PRINT_STRING(": ");<br />
PRINT_STRING(cs_names[device]);<br />
<br />
if (device < 10)<br />
PRINT_STRING(" ");<br />
<br />
PRINT_STRING("\t\tName port: ");<br />
PRINT_STRING(names[device]);<br />
PRINT_STRING("\r\n");<br />
}<br />
}<br />
<br />
Device get_state_device(DeviceCS CSx) {<br />
return devices[CSx];<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
<br />
device.h :<syntaxhighlight lang="c"><br />
#ifndef DEVICES_H<br />
#define DEVICES_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
#define MAX_DEVICES 6<br />
<br />
typedef enum {<br />
NOT_CONNECTED = 0,<br />
UNKNOWN,<br />
KEYBOARD,<br />
SCREEN,<br />
NETWORK,<br />
SOUND,<br />
SD,<br />
} DeviceType;<br />
<br />
typedef struct {<br />
GPIO_TypeDef *GPIO_CS; // GPIO Device Select<br />
uint8_t PIN_CS; // Pin Device Select<br />
DeviceType type; // Type de device<br />
} Device;<br />
<br />
typedef enum {<br />
CS1 = 0, // PC0<br />
CS2 = 1, // PA7<br />
CS3 = 2, // PC9<br />
CS4 = 3, // PA2<br />
CS5 = 4, // PC11<br />
CS6 = 5, // PA4<br />
} DeviceCS;<br />
<br />
void _devices_init(void);<br />
void scan_devices(void);<br />
Device get_state_device(DeviceCS CSx);<br />
void print_devices(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== GPIO =====<br />
Cette librairie permet d'initialiser les pins de notre carte via des fonctions intermediaire pour une meilleure lisibilité. Elle permet aussi de controller et lire les pins si besoin.<br />
<br />
gpio.c :<syntaxhighlight lang="c"><br />
#include "./gpio.h"<br />
<br />
#include "../CARTE/Ecran/carteEcran.h"<br />
#include "../DEVICES/devices.h"<br />
#include "../SPI/spi.h"<br />
#include "../USART/usart.h"<br />
<br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
case ALTERNATE_FUNCTION_USART:<br />
optionPort = 0x02;<br />
<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
// GPIOx->OSPEEDR |= 11 << (PINx * 2); // Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
if (GPIOx == GPIOA && (PINx == 9 || PINx == 10)) {<br />
// Sélection AF7 pour USART1 (PA9, PA10)<br />
GPIOx->AFR[1] &= ~(0xF << ((PINx - 8) * 4));<br />
GPIOx->AFR[1] |= (7 << ((PINx - 8) * 4)); // AF7 = USART1<br />
}<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
return (GPIOx->IDR & (1 << PINx));<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (readPin(GPIOx, PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
<br />
void setupCarte() {<br />
_devices_init();<br />
<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// Ecran<br />
_ecran_init();<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, INPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// SPI<br />
spiInit();<br />
<br />
// On eteint tous les RST<br />
onPin(GPIOC, 1); // PC1, RST1<br />
<br />
usart_init(115200);<br />
}<br />
</syntaxhighlight>gpio.h :<syntaxhighlight lang="c"><br />
#ifndef GPIO_H<br />
#define GPIO_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ALTERNATE_FUNCTION_USART,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
#define CLOCK_MHZ 16 // HSI = 16MHz Cf STM32F410 datasheet p82/142<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode);<br />
int readPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
void setupCarte();<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Ordonnanceur =====<br />
Cette librairie ainsi que TASK sont les plus importante car elles étaient les plus dur à implémenter. Aucun étudiant n'avait déjà travailler sur un ordonnanceur sur une architecture ARM et peu d'information sont présente sur internet sur ce sujet. Les professeurs m'ont confiés ce sujet afin que je puisse aider à l'évolution du module pico ordinateur avec peut être plus de microcontrolleur sur ARM pour les prochaines années.<br />
<br />
C'était donc un défi très interessant de réussir à coder les primitives d'un ordonnanceur sur ARM.<br />
<br />
ordonnanceur.c :<syntaxhighlight lang="c"><br />
#include "ordonnanceur.h"<br />
<br />
uint32_t g_tick_count = 0;<br />
uint32_t INCREMENT_TIMER = 0;<br />
<br />
extern TCB_t *current_task_ptr;<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
uint32_t _get_psp_addr(void) {<br />
if (!current_task_ptr)<br />
return 0;<br />
return (uint32_t)current_task_ptr->psp_addr;<br />
}<br />
<br />
void _save_psp_addr(uint32_t addr) {<br />
if (!current_task_ptr)<br />
return;<br />
current_task_ptr->psp_addr = (uint32_t *)addr;<br />
}<br />
<br />
void _setupTimer5(uint32_t ms) {<br />
INCREMENT_TIMER = ms;<br />
// Choix TIM5 car gestion d'un timer simple<br />
<br />
// ACTIVATION DE L'HORLOGE TIM5 SPECIFIQUE<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;<br />
<br />
// Prescaler Register<br />
TIM5->PSC = (CLOCK_MHZ - 1); // Diviser par Clock pour avoir 1 MHz<br />
<br />
// ARR : Auto Reload Register<br />
TIM5->ARR = (ms * 1000) - 1; // 1/1MHz * 1000 devient des millisecondes<br />
// valeur à laquelle le timer reset et déclenche une interruption Cf p341<br />
<br />
// Counter Register<br />
TIM5->CNT = 0; // On commencer a compter à 0<br />
<br />
// DMA/Interrupt enable register<br />
TIM5->DIER |= TIM_DIER_UIE; // Update interrupt enable<br />
<br />
// Activer TIM5 en mode compteur<br />
TIM5->CR1 |= TIM_CR1_CEN;<br />
<br />
NVIC_SetPriority(USART1_IRQn, 0x01);<br />
NVIC_SetPriority(TIM5_IRQn, 0x10);<br />
NVIC_SetPriority(PendSV_IRQn, 0x3);<br />
<br />
NVIC_EnableIRQ(TIM5_IRQn);<br />
NVIC_EnableIRQ(PendSV_IRQn);<br />
}<br />
<br />
void TIM5_IRQHandler(void) {<br />
// Clear flag<br />
TIM5->SR &= ~TIM_SR_UIF;<br />
<br />
g_tick_count += INCREMENT_TIMER;<br />
_unblock_tasks();<br />
<br />
// Déclenche PendSV (switch context)<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
// Bascule MSP à PSP<br />
__attribute__((naked)) void launch_os(void) {<br />
// Initialisation PSP avec la pile de la tâche courante<br />
__asm volatile("PUSH {LR}"); // Sauvegarde LR (adresse du main() )<br />
__asm volatile("BL _get_psp_addr"); // Appelle _get_psp_addr(), retourne le PSP de la tâche courante dans r0<br />
__asm volatile("MSR PSP,R0"); // Met à jour le PSP avec la nouvelle valeur<br />
__asm volatile("POP {LR}"); // Restaure LR sauvegardé avant les appels BL<br />
<br />
// Bascule du Stack Pointer actif de MSP vers PSP<br />
__asm volatile("MOV R0,#0X02"); // Selection du PSP en Thread mode (CONTROL.SPSEL = 1)<br />
__asm volatile("MSR CONTROL,R0"); // Mise à jour du registre CONTROL<br />
__asm volatile("CPSIE I"); // Active les IRQ<br />
__asm volatile("BX LR"); // Retour à l'appelant en utilisant désormais le PSP<br />
}<br />
<br />
// Quand PendSV est executé, le systeme enregistre le contexte de la tâche courante automatiquement.<br />
// Ici, il est utilisé en naked donc on enregistre à la mano.<br />
__attribute__((naked)) void PendSV_Handler(void) {<br />
SAVE_REGISTERS();<br />
<br />
// PC saute à l'adresse<br />
__asm volatile("BL _scheduler");<br />
<br />
RESTORE_REGISTERS()<br />
}<br />
<br />
void init_os(void) {<br />
__disable_irq();<br />
_setupTimer5(1);<br />
_init_tasks();<br />
}<br />
<br />
</syntaxhighlight>ordonnanceur.h :<syntaxhighlight lang="c"><br />
#ifndef ORDONNANCEUR_H<br />
#define ORDONNANCEUR_H<br />
<br />
#include "../GPIO/gpio.h"<br />
#include "../TASK/task.h"<br />
<br />
<br />
#define SAVE_REGISTERS() \<br />
__asm volatile("MRS r0, PSP @ r0 = PSP courant\n\t" \<br />
"STMDB r0!, {r4-r11} @ Sauvegarde registre R4 à R11 sur la pile PSP\n\t" \<br />
"PUSH {LR} @ Sauvegarde LR sur la pile MSP avant BL\n\t" \<br />
"BL _save_psp_addr @ Appelle save_psp_addr(r0) pour mémoriser le PSP\n\t");<br />
<br />
#define RESTORE_REGISTERS() \<br />
__asm volatile("BL _get_psp_addr @ Appelle get_psp_addr(), retourne le PSP de la tâche suivante dans r0\n\t"\<br />
"LDMIA r0!, {r4-r11} @ Restaure R4 à R11 depuis la pile de la nouvelle tâche\n\t"\<br />
"MSR PSP, r0 @ Met à jour le PSP avec la nouvelle valeur\n\t"\<br />
"POP {LR} @ Restaure LR sauvegardé avant les appels BL\n\t"\<br />
"BX LR @ Retour d'exception : sortie de PendSV vers la tâche sélectionnée\n\t");<br />
<br />
/* ------------------ Function Prototypes ------------------ */<br />
void init_os(void);<br />
void launch_os(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Tâche =====<br />
Contrairement à la gestion des tâches sur la carte shielld, ici nous avons une gestion dynamique avec une listé chainé (vu au semestre 6 avec M. FORGET). <br />
<br />
task.c : <syntaxhighlight lang="c"><br />
#include "task.h"<br />
<br />
#include <stddef.h><br />
#include <stdlib.h><br />
<br />
#define DUMMY_XPSR 0x01000000 // xPSR (32bits), 24eme bit indique thumb mode sinon crash<br />
<br />
/* ------------------ Variables globales ------------------ */<br />
TCB_t *task_list_head = NULL; // tête de liste chaînée<br />
TCB_t *current_task_ptr = NULL; // tâche courante<br />
<br />
/* ------------------ Fonctions interne ------------------ */<br />
// Initialise les piles de chaque taches<br />
void _init_task_stack(uint32_t **psp_addr, void (*task_handler)(void)) {<br />
uint32_t *pPSP = *psp_addr + STACK_SIZE;<br />
<br />
*(--pPSP) = DUMMY_XPSR; // xPSR<br />
*(--pPSP) = (uint32_t)task_handler; // PC<br />
*(--pPSP) = 0xFFFFFFFD; // LR, retour en Thread mode avec PSP<br />
<br />
// Initialisation registres R0-R12<br />
for (int i = 0; i < 13; i++) {<br />
*(--pPSP) = 0;<br />
}<br />
<br />
*psp_addr = pPSP; // Met à jour l'adresse PSP dans la TCB<br />
}<br />
<br />
// Sécurité dans le cas où il n'y aurait plus aucune tâche<br />
void _idle_task(void) {<br />
while (1)<br />
;<br />
}<br />
<br />
void _add_task_to_list(TCB_t *new_task) {<br />
// Sécurité : la liste ne doit jamais être vide, _idle_task doit exister<br />
if (task_list_head == NULL) {<br />
// Créer automatiquement _idle_task<br />
TCB_t *idle = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!idle)<br />
return;<br />
<br />
idle->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!idle->psp_addr) {<br />
free(idle);<br />
return;<br />
}<br />
<br />
idle->current_state = TASK_READY_STATE;<br />
idle->block_count = 0;<br />
idle->task_handler = _idle_task;<br />
_init_task_stack(&idle->psp_addr, _idle_task);<br />
<br />
task_list_head = idle;<br />
idle->next = idle; // liste circulaire<br />
current_task_ptr = idle; // pointe sur idle<br />
}<br />
<br />
// Ajout à la fin de la liste<br />
TCB_t *tmp = task_list_head;<br />
while (tmp->next != task_list_head) {<br />
tmp = tmp->next;<br />
}<br />
tmp->next = new_task;<br />
new_task->next = task_list_head;<br />
}<br />
<br />
/* ------------------ Fonctions externe ------------------ */<br />
// update_next_task<br />
void _scheduler(void) {<br />
if (!current_task_ptr) {<br />
current_task_ptr = task_list_head; // première tâche<br />
} else {<br />
TCB_t *start = current_task_ptr;<br />
do {<br />
current_task_ptr = current_task_ptr->next;<br />
if (current_task_ptr->current_state == TASK_READY_STATE)<br />
return;<br />
} while (current_task_ptr != start);<br />
<br />
// Si aucune tâche prête, idle<br />
current_task_ptr = task_list_head; // ou idle task<br />
}<br />
}<br />
<br />
// Débloque les taches endormi<br />
void _unblock_tasks(void) {<br />
if (!task_list_head)<br />
return;<br />
<br />
TCB_t *tmp = task_list_head;<br />
do {<br />
if (tmp->current_state == TASK_BLOCKED_STATE && tmp->block_count <= g_tick_count) {<br />
tmp->current_state = TASK_READY_STATE;<br />
}<br />
tmp = tmp->next;<br />
} while (tmp != task_list_head);<br />
}<br />
<br />
// Fonction qui endors une tache le temps précisé<br />
void task_delay(uint32_t ms) {<br />
__disable_irq();<br />
<br />
if (current_task_ptr && current_task_ptr->task_handler != _idle_task) { // On touche pas à idle c'est une securite<br />
current_task_ptr->block_count = g_tick_count + ms;<br />
current_task_ptr->current_state = TASK_BLOCKED_STATE;<br />
<br />
// Déclenche PendSV pour basculement de tâche<br />
SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;<br />
}<br />
<br />
__enable_irq();<br />
}<br />
<br />
void add_task(void (*task_handler)(void)) {<br />
// Allocation TCB<br />
TCB_t *new_task = (TCB_t *)malloc(sizeof(TCB_t));<br />
if (!new_task)<br />
return; // échec allocation<br />
<br />
// Allocation pile<br />
new_task->psp_addr = (uint32_t *)malloc(STACK_SIZE * sizeof(uint32_t));<br />
if (!new_task->psp_addr) {<br />
free(new_task);<br />
return;<br />
}<br />
<br />
// Initialisation TCB<br />
new_task->current_state = TASK_READY_STATE;<br />
new_task->block_count = 0;<br />
new_task->task_handler = task_handler;<br />
<br />
// Initialisation pile PSP<br />
_init_task_stack(&new_task->psp_addr, task_handler);<br />
<br />
// Ajouter à la liste chaînée (à la fin)<br />
_add_task_to_list(new_task);<br />
}<br />
<br />
void _init_tasks(void) {<br />
// Initialise la liste de tâches avec _idle_task<br />
task_list_head = NULL;<br />
current_task_ptr = NULL;<br />
<br />
// Crée automatiquement _idle_task<br />
add_task(_idle_task);<br />
}<br />
<br />
</syntaxhighlight>task.h : <syntaxhighlight lang="c"><br />
#ifndef TASK_H<br />
#define TASK_H<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
/* ------------------ Types ------------------ */<br />
typedef enum {<br />
TASK_READY_STATE = 0,<br />
TASK_BLOCKED_STATE = 1,<br />
} state_task;<br />
<br />
typedef struct TCB{<br />
uint32_t *psp_addr;<br />
void (*task_handler)(void);<br />
uint32_t block_count;<br />
state_task current_state;<br />
<br />
struct TCB *next; <br />
} TCB_t;<br />
<br />
extern uint32_t g_tick_count;<br />
<br />
/* ------------------ TASK ------------------ */<br />
#define IDLE_STACK_START 0x20001000<br />
#define SCHED_STACK_START 0x20006000<br />
#define STACK_SIZE 256 <br />
<br />
// Fonction pour dépendance ordonnanceur.c<br />
void _scheduler(void);<br />
void _unblock_tasks(void);<br />
void _init_tasks(void);<br />
<br />
// Fonction à partager à l'utilisateur<br />
void task_delay(uint32_t ms);<br />
void add_task(void (*task_handler)(void));<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== SPI =====<br />
spi.c : <syntaxhighlight lang="c"><br />
#include "./spi.h"<br />
<br />
#define AFR_NumberBitParPin 0x4 // Cf RM0401 p155/763<br />
#define AFR_OFFSET_HIGH 8 // Cf RM0401 p155/763<br />
<br />
#define SPI_AFR 0b0101 // SPI sur AF5, Cf RM0401 p143/763<br />
<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx) { offPin(GPIOx, PINx); }<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx) { onPin(GPIOx, PINx); }<br />
<br />
volatile uint8_t spi_lock;<br />
<br />
void spiInit() {<br />
// SPI configuration instruction Cf RM0401 p682/763<br />
<br />
// STEP 1: Write proper GPIO registers: Configure GPIO for MOSI, MISO and SCK<br />
// pins.<br />
<br />
// PB15, MOSI<br />
setupPin(GPIOB, 15, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((15 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB14, MISO<br />
setupPin(GPIOB, 14, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((14 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// PB13, SCK<br />
setupPin(GPIOB, 13, ALTERNATE_FUNCTION);<br />
GPIOB->AFR[1] &= ~(0b1111 << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin)); // Clear<br />
GPIOB->AFR[1] |= SPI_AFR << ((13 - AFR_OFFSET_HIGH) * AFR_NumberBitParPin); // AFR[1] = AFRH<br />
<br />
// STEP 2 : Write to the SPI_CR1 register:<br />
<br />
// ACTIVER L'HORLOGE AVANT TOUT SINON NE MARCHE<br />
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;<br />
<br />
SPI2->CR1 = 0; // Reset tout<br />
<br />
// Cf RM0401 page 711/763 le tableau des états<br />
<br />
// LES SPECS DU SPI<br />
// https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all<br />
<br />
// a) Configure the serial clock baud rate using the BR[2:0] bits (Note: 3).<br />
SPI2->CR1 |= 0b101 << SPI_CR1_BR_Pos; // 101 : fPCLK/64<br />
<br />
// fPCLK /32 fait 250kHz car fpclk = 8MHz et<br />
// on à 250kHz maximum clock, cf sparkfun spec<br />
// On prend alors en dessous car sinon des<br />
// erreurs viennent se glisser pendant l'envoie<br />
<br />
// b) Configure the CPOL and CPHA bits combination to define one of the four<br />
// relationships between the data transfer and the serial clock. (Note: 2 -<br />
// except the case when CRC is enabled at TI mode).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPOL_Pos); // 0 : 0 when idle<br />
// And, data is clocked in on the rising edge of the clock (when it goes from<br />
// 0V to 5V).<br />
<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CPHA_Pos); // 0 :<br />
// first clock transition is first data capture edge<br />
<br />
// c) Select simplex or half-duplex mode by configuring RXONLY or BIDIMODE and<br />
// BIDIOE (RXONLY and BIDIMODE can't be set at the same time).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_RXONLY_Pos); // 0 : full-duplex<br />
<br />
// d) Configure the LSBFIRST bit to define the frame format (Note: 2).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_LSBFIRST_Pos); // 0 : MSB transmitted first<br />
<br />
// e) Configure the CRCEN and CRCEN bits if CRC is needed (while SCK clock<br />
// signal is at idle state).<br />
SPI2->CR1 &= ~(1 << SPI_CR1_CRCEN_Pos); // 0: CRC calculation disabled<br />
<br />
// f) Configure SSM and SSI (Note: 2).<br />
// When the SSM bit is set, the NSS pin input is replaced with the value from<br />
// the SSI<br />
SPI2->CR1 |= (1 << SPI_CR1_SSM_Pos); // Software slave management<br />
SPI2->CR1 |= (1 << SPI_CR1_SSI_Pos); //<br />
<br />
// g) Configure the MSTR bit (in multimaster NSS configuration, avoid conflict<br />
// state on NSS if master is configured to prevent MODF error).<br />
SPI2->CR1 |= 1 << SPI_CR1_MSTR_Pos; // 1 : Master configuration<br />
<br />
// Data frame format<br />
SPI2->CR1 &= ~(1 << SPI_CR1_DFF_Pos); // 0: 8-bit data frame format is<br />
// selected for transmission/reception<br />
// Enable SPI<br />
SPI2->CR1 |= 1 << SPI_CR1_SPE_Pos; // 1 : Peripheral enabled<br />
}<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx) {<br />
uint8_t dataRecu;<br />
<br />
while (spi_lock)<br />
;<br />
spi_lock = 1;<br />
<br />
// Activer CS<br />
spi_cs_on(CS_GPIOx, CS_PINx);<br />
<br />
// Attendre que TXE soit prêt<br />
while (!(SPI2->SR & SPI_SR_TXE))<br />
;<br />
<br />
// Envoyer la donnée<br />
SPI2->DR = data;<br />
<br />
// Attendre que le buffer RXNE soit plein pour lire et vider<br />
while (!(SPI2->SR & SPI_SR_RXNE))<br />
;<br />
dataRecu = SPI2->DR;<br />
<br />
// Désactiver CS<br />
spi_cs_off(CS_GPIOx, CS_PINx);<br />
<br />
spi_lock = 0;<br />
return dataRecu;<br />
}<br />
<br />
</syntaxhighlight>spi.h : <syntaxhighlight lang="c"><br />
#pragma once<br />
<br />
#include <stdint.h><br />
#include "../GPIO/gpio.h"<br />
<br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
<br />
uint8_t spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
===== USART =====<br />
Bibliothéque permettant de gérer proprement l'UART et afficher et lire des caractères via le port série d'un PC.<br />
<br />
usart.c : <syntaxhighlight lang="c"><br />
#include "usart.h"<br />
#include "../GPIO/gpio.h"<br />
<br />
#define RX_BUFFER_SIZE 64<br />
<br />
volatile char rx_buffer[RX_BUFFER_SIZE];<br />
volatile uint8_t rx_head = 0;<br />
volatile uint8_t rx_tail = 0;<br />
<br />
void usart_init(uint32_t baudrate) {<br />
setupPin(GPIOA, 9, ALTERNATE_FUNCTION_USART); // PA9 => TX<br />
setupPin(GPIOA, 10, ALTERNATE_FUNCTION_USART); // PA10 => RX<br />
<br />
// Evidemment on active l'horloge du bus<br />
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;<br />
<br />
// Procedure (Cf STM32F410 p.627/763):<br />
// 2. Program the M bit in USART_CR1 to define the word length.<br />
USART1->CR1 = 0; // M=0, 1 Start bit, 8 Data bits, n Stop bit<br />
<br />
// 3. Program the number of stop bits in USART_CR2.<br />
USART1->CR2 = 0;<br />
<br />
// 4. Select DMA enable (DMAR) in USART_CR3 if multibuffer communication is to take<br />
// place. Configure the DMA register as explained in multibuffer communication. STEP 3<br />
USART1->CR3 = 0;<br />
<br />
// 5. Select the desired baud rate using the baud rate register USART_BRR<br />
uint32_t usartclk = 16000000; // APB2 ~16MHz (Nucleo F4)<br />
USART1->BRR = usartclk / baudrate; // BRR : baudrate = fclk / USARTDIV<br />
<br />
// 6. Set the RE bit USART_CR1. This enables the receiver that begins searching for a start<br />
// bit.<br />
USART1->CR1 |= USART_CR1_PS; // Parity selection, 0 = Even parity<br />
<br />
// 1. Enable the USART by writing the UE bit in USART_CR1 register to 1.<br />
// Bon la datasheet dis etape 1 mais faut vraiment le faire à la fin l'activation sinon marche pas<br />
USART1->CR1 |= USART_CR1_TE | USART_CR1_RE; // TX & RX<br />
<br />
USART1->CR1 |= USART_CR1_RXNEIE; // activer interruption RX<br />
<br />
USART1->CR1 |= USART_CR1_UE; // USART<br />
<br />
NVIC_EnableIRQ(USART1_IRQn);<br />
}<br />
<br />
void usart_send_char(char c) {<br />
while (!(USART1->SR & USART_SR_TXE))<br />
;<br />
USART1->DR = (c & 0xFF);<br />
}<br />
<br />
void usart_print(char *s) {<br />
while (*s) { // Tant que le caractère != '\0'<br />
usart_send_char(*s);<br />
s++;<br />
}<br />
}<br />
<br />
void USART1_IRQHandler() {<br />
if (USART1->SR & USART_SR_RXNE) {<br />
char c = USART1->DR & 0xFF;<br />
uint8_t next = (rx_head + 1) % RX_BUFFER_SIZE;<br />
<br />
if (next != rx_tail) { // buffer pas plein<br />
rx_buffer[rx_head] = c;<br />
rx_head = next;<br />
}<br />
}<br />
}<br />
<br />
int usart_buffer_available() {<br />
return (rx_head != rx_tail);<br />
}<br />
<br />
char usart_read() {<br />
if (rx_head == rx_tail)<br />
return 0; // rien dispo<br />
<br />
char c = rx_buffer[rx_tail];<br />
rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;<br />
return c;<br />
}<br />
<br />
</syntaxhighlight>usart.h : <syntaxhighlight lang="c"><br />
#ifndef USART_H<br />
#define USART_H<br />
<br />
#include "../../../00-lib/stm32f410rx.h"<br />
<br />
void usart_init(uint32_t baudrate);<br />
void usart_send_char(char c);<br />
void usart_print(char *s);<br />
void usart_print_c(char c);<br />
<br />
int usart_buffer_available(void);<br />
char usart_read(void);<br />
<br />
#endif<br />
</syntaxhighlight><br />
<br />
===== Substitue =====<br />
printf.h :<syntaxhighlight lang="c"><br />
#ifndef PRINTF_H<br />
#define PRINTF_H<br />
<br />
#include "../USART/usart.h"<br />
<br />
#define PRINT_STRING(str) usart_print((char*)str)<br />
#define PRINT_CHAR(c) usart_send_char(c)<br />
#define GETCHAR() usart_read()<br />
<br />
#endif<br />
</syntaxhighlight>Grâce à cette fonction macro on pourra changer facilement la dépendance USART en combinaison carte clavier et/ou écran.<br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope qui semble donner du bruit dans le cas de notre pcb dysfonctionnelle. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Le scan se fait facilement une fois la logique assimilé... <br />
<br />
Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite, nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bibliothèque à été pensé pour être facilement réadaptable et lisible pour un utilisateur souhaitant re-coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste coder/utiliser le clavier existant.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
Ensuite on vient ajouter nos libraries et notre code de logique aux fichiers Keyboard.c :<syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
// if (btn51) KeyboardReport->KeyCode[UsedKeyCodes++] = ; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
J'ai fais une petite macro (reprise de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.) (Bouton 51). <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
==== Communication carte mère ====<br />
Partie a détailler plus tard.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8680SE4Binome2025-62025-12-30T20:31:27Z<p>Cpayet : /* Lufa */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment dû mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARWARE ======<br />
La première étape est de faire clignoter les leds qui serviront de futures tâches. On implémente donc les fonctions suivantes : <syntaxhighlight lang="c"><br />
#define LEDs_PORT &PORTD<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
</syntaxhighlight>On réutilise ensuite la fonction setupPin qui permet d'initialiser nos leds.<syntaxhighlight lang="c"><br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
#define LEDs_DDR &DDRD<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight>On initialise ensuite l'horloge :<syntaxhighlight lang="c"><br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
</syntaxhighlight>Puis l'hardware complet :<syntaxhighlight lang="c"><br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
</syntaxhighlight><br />
<br />
====== USART ======<br />
Dans le dossier USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#define BAUD_RATE 9600<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU/16/BAUD_RATE)-1)<br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
On pense ensuite aux tâches que l'on va implémenter dans notre ordonnanceur.<br />
<br />
On implémente des tâches pour les leds :<syntaxhighlight lang="c"><br />
<br />
void taskCS1() {<br />
while(1){ <br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
} <br />
}<br />
<br />
void taskCS2() { <br />
while(1){ <br />
toggleLedCS2();<br />
_delay_ms(500);<br />
} <br />
}<br />
<br />
void taskCS3() { <br />
while(1){ <br />
toggleLedCS3();<br />
_delay_ms(500);<br />
} <br />
}<br />
<br />
void taskCS4() {<br />
while(1){ <br />
toggleLedCS4();<br />
_delay_ms(250);<br />
} <br />
} <br />
</syntaxhighlight>et pour le série :<syntaxhighlight lang="c"><br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
</syntaxhighlight>On définit ensuite la structure générale pour les tâches. <br />
<br />
Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
<syntaxhighlight lang="c"><br />
typedef enum{<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
<br />
</syntaxhighlight>On définit donc un tableau de tâches et une constante pour savoir le nombre de tâches que l'on a. <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight><br />
<br />
====== ORDONNANCEUR ======<br />
Pour débuter notre ordonnanceur, on commence par créér un minuteur afin de faire clignoter deux leds à des périodes différentes. <syntaxhighlight lang="c"><br />
void init_timer1(int diviseur, long periode_ms){<br />
tick_ms = periode_ms; <br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch(diviseur){<br />
case 64: TCCR1B |= (1<<CS11)|(1<<CS10); break;<br />
case 256: TCCR1B |= (1<<CS12); break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
</syntaxhighlight>Une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine, qui prend le relai. <br />
<br />
L'ISR a besoin de la pile, on implémente donc une fonction afin d'initialiser la pile. <syntaxhighlight lang="c"><br />
void init_pile(int n){<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" :: "r"(addr));<br />
asm volatile("push %B0" :: "r"(addr));<br />
<br />
// r0-r31<br />
for(int i=0; i<32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" :: "r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
</syntaxhighlight><br />
<br />
L'ISR procède ainsi :<br />
<br />
* Elle commence par sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* On appelle ensuite l'ordonnanceur qui définit la manière dont les tâches sont exécutées.<br />
* On restore ensuite le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité pour certaines tâches.<syntaxhighlight lang="c"><br />
void scheduler(void){<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
</syntaxhighlight>Fonction afin de mettre une tâche en sommeil :<syntaxhighlight lang="c"><br />
void sleep_ms(uint16_t t) {<br />
task[currentTask].state = SLEEP;<br />
task[currentTask].sleepTime = t / tick_ms;<br />
} <br />
</syntaxhighlight><br />
<br />
====== MAIN ======<br />
Dans le fichier main.c, on appelle diverses fonctions notamment le timer, qui appellera donc l'ISR puis le scheduler. On commence également par charger la première tâche sur la pile.<syntaxhighlight lang="c"><br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
setupHardware();<br />
// initialisation des piles<br />
init_tasks();<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
asm volatile("reti");<br />
return 0;<br />
}<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><br />
Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
====== Ordonnanceur ======<br />
<p style="clear: both;" /><br />
<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm. Notre ordonnanceur était originellement composé uniquement des fichiers ordonnanceur.c et ordonnanceur.h mais on a implémenté pas mal de fonctions donc on place celles-ci dans un nouveau fichier processus.c accompagné de son processus.h. Ci-dessous la description du contenu de ces 4 fichiers.<br />
* processus.h :<br />
Il inclut les librairies nécéssaires et les prototypes des fonctions implémentées dans processus.c<br />
* processus.c :<br />
<br />
# Fonction Delay : la fonction delay n'est pas présente sous arm donc on l'implémente ici.<syntaxhighlight lang="c"><br />
void delay(volatile uint32_t t){<br />
while (t--){<br />
__asm__("nop");<br />
}<br />
}<br />
</syntaxhighlight><br />
# Tâches pour la led : ci-dessous des fonctions permettant d'allumer, éteindre et faire clignoter la led LD2 de la nucleo. <syntaxhighlight lang="c"><br />
void init_led2(void){<br />
//active l’horloge pour GPIOA car ds les stm32, les peripheriques sont eteints pr economiser de l energie et on doit appeler la clock pr réveiller les gpio<br />
RCC->AHB1ENR |= (1 << 0);<br />
//on veut écrire 01 (état haut) et pas 11 (analogique) pour les broches 10 et 11 donc on doit procéder en deux étapes : d'abord effacer puis mettre en sortie<br />
GPIOA->MODER &= ~(0x3 << (5*2));<br />
GPIOA->MODER |= (0x1 << (5*2));<br />
}<br />
<br />
void led2_on(void){<br />
GPIOA->ODR |= (1 << 5);<br />
}<br />
<br />
void led2_off(void){<br />
GPIOA->ODR &= ~(1 << 5);<br />
}<br />
<br />
void led2_blink(void){<br />
while(1){<br />
GPIOA->ODR ^= (1 << 5);<br />
delay(1000000);<br />
}<br />
}<br />
<br />
void led2_blink_task(void){<br />
static uint32_t counter = 0;<br />
counter++;<br />
if(counter >= 10){ // clignote toutes les 10 interruptions<br />
GPIOA->ODR ^= (1 << 5);<br />
counter = 0;<br />
}<br />
}<br />
</syntaxhighlight><br />
# Tâches pour le série : envoyer un caractère, une chaîne de caractère, recevoir et allumer une led quand l'utilisateur écrit la lettre 'a' dans le minicom.<syntaxhighlight lang="c"><br />
void init_usart2(void){<br />
RCC->APB1ENR |= RCC_APB1ENR_USART2EN;<br />
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;<br />
//PA2 pour tx et PA3 pour rx<br />
GPIOA->MODER &= ~((3 << (2*2)) | (3 << (3*2)));<br />
GPIOA->MODER |= (2 << (2*2)) | (2 << (3*2));<br />
GPIOA->AFR[0] &= ~((0xF << (4*2)) | (0xF << (4*3))); //efface registre alternate function<br />
GPIOA->AFR[0] |= (7 << (4*2)) | (7 << (4*3)); //attribue AF7 dédié à usart2<br />
USART2->BRR = 0x0683; //baudrate à 9600<br />
USART2->CR1 = USART_CR1_TE | USART_CR1_RE; //transmit et receive enable pour tx et rx<br />
USART2->CR1 |= USART_CR1_UE; //usart enable<br />
}<br />
<br />
void usart2_send_char(char c){<br />
while (!(USART2->SR & USART_SR_TXE)); //qd le bit transmit data register empty est à 0 (donc data register possède des données)<br />
USART2->DR = c; //écrire le caractère<br />
}<br />
<br />
void usart2_send_string(char *s){<br />
while (*s){<br />
usart2_send_char(*s++);<br />
}<br />
}<br />
<br />
char usart2_receive(void){<br />
while (!(USART2->SR & USART_SR_RXNE)); //qd caractère<br />
return (char)(USART2->DR & 0xFF); //char sur 16bits on garde que bits de données<br />
}<br />
<br />
void led2_blink_serial(void){<br />
for (int i=0; i<10; i++){<br />
GPIOA->ODR ^= (1 << 5);<br />
delay(1000000);<br />
}<br />
}<br />
<br />
void led_serial(void){<br />
while(1){<br />
char c = usart2_receive();<br />
usart2_send_char(c); //echo vers Minicom<br />
if(c == 'a')<br />
led2_blink_serial();<br />
}<br />
}<br />
</syntaxhighlight>Commande minicom à taper dans le terminal (-o permet d'éviter que minicom envoie des commandes d'initialisation) :<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>Exemple de tâche (non ordonnancée pour le moment) où l'on affiche un message voulu, ici "heyyy" sur minicom[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
# Tâche avec le bouton : allumer la led LD2 quand on appuie sur le bouton user (en bleu, le noir étant dédié au reset).<syntaxhighlight lang="c"><br />
void init_user_button(void){<br />
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN;<br />
GPIOC->MODER &= ~(0x3 << (13 * 2)); //PC13 en entrée<br />
//pull up<br />
GPIOC->PUPDR &= ~(0x3 << (13 * 2));<br />
GPIOC->PUPDR |= (0x1 << (13 * 2)); //01 : pull up<br />
}<br />
<br />
uint8_t user_button_pressed(void){<br />
return (GPIOC->IDR & (1 << 13)) == 0; //bouton actif à 0<br />
}<br />
<br />
void task_button_led(void){<br />
while(1){<br />
if(user_button_pressed()){<br />
led2_on();<br />
} else {<br />
led2_off();<br />
}<br />
}<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" /><br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies, processus.h et la liste des fonctions implémentées dans ordonnanceur.c.<br />
<br />
* ordonnanceur.c :<br />
Ce fichier gère le minuteur, les interruptions, la gestion des tâches.<br />
<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps. <syntaxhighlight lang="c"><br />
extern uint32_t SystemCoreClock; //freq horloge<br />
<br />
void init_minuteur(uint16_t prescaler, uint16_t periode_ms){<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM6EN; //active l'horloge de TIM6<br />
TIM6->PSC = prescaler - 1; //prescaler<br />
uint32_t tick_freq = SystemCoreClock/prescaler; //période<br />
//TIM6->ARR = (tick_freq * periode_ms)/1000-1; //Auto-Reload Register est la période avant que le timer fasse une interruption. (tick_freq * periode_ms)/1000 correspond au nb de ticks durant cette période.<br />
TIM6->ARR = (uint32_t)(((uint64_t)tick_freq * periode_ms)/1000 - 1);<br />
TIM6->CNT = 0; //reset compteur<br />
TIM6->DIER |= TIM_DIER_UIE; //interruption activée quand compteur atteint nb de ticks de ARR<br />
TIM6->CR1 |= TIM_CR1_CEN; //compteur<br />
NVIC_SetPriority(TIM6_DAC_IRQn, 0x1); //prio haute<br />
NVIC_EnableIRQ(TIM6_DAC_IRQn); //active l'interruption dans le NVIC (Nested Vector Interrupt Controller)<br />
}<br />
</syntaxhighlight><br />
On ajoute ensuite le shield sur la nucleo afin de pouvoir tester l'ordonnanceur avec plus de tâches puisque la nucleo seule possède très peu de leds.[[Fichier:Nucleo ordonnanceur.jpg|center|500px|alt=nucleo_ordonnanceur|vignette|nucleo_ordonnanceur]]<br />
====== Système de fichier ======<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" /><br />
<br />
'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<br />
<br />
La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
===== Test led =====<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
===== Test écran =====<br />
L'idée est d'afficher un compteur sur un afficheur 7 segments, notre "carte écran" : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_mere/Notre_PCB/02-Compteur.<br />
<br />
Notre test écran est structuré de la manière suivante :<br />
* un main.c<br />
* un dossier pour la carte écran<br />
* un dossier hardware_setup<br />
* un dossier pour le spi<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== hardware_setup ======<br />
<br />
On reprend notre fonction setupPin que l'on adapte à arm afin d'initialiser les pins de notre carte :<syntaxhighlight lang="c"><br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
</syntaxhighlight>On implémente également des fonctions qui permettent d'activer, de désactiver ou de faire clignoter (une led en l'occurence) des pins.<syntaxhighlight lang="c"><br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (GPIOx->ODR & (1 << PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
</syntaxhighlight>On possède également une fonction qui initialise notre carte mère, en activant les différents ports des cartes filles, le spi, les leds et les boutons.<syntaxhighlight lang="c"><br />
void setupCarte() {<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, OUTPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// Test LEDs allumé<br />
offPin(GPIOC, 0); // PC0, CS1<br />
offPin(GPIOB, 1); // PA7, CS2<br />
offPin(GPIOC, 9); // PC9, CS3<br />
offPin(GPIOA, 2); // PA2, CS4<br />
offPin(GPIOB, 0); // PB0, CS_FPGA<br />
<br />
onPin(GPIOC, 12); // PB0, CS_FPGA<br />
// Setup SPI => MOSI, MISO et SCK<br />
spiInit();<br />
<br />
// Ecran<br />
ecran_init();<br />
}<br />
</syntaxhighlight><br />
<br />
====== spi ======<br />
On initialise également les fonctions pour le SPI, à retrouver ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_mere/Notre_PCB/02-Compteur/lib/SPI.<br />
<br />
On implémente les fonctions suivantes, commentées en détail dans le spi.c :<syntaxhighlight lang="c"><br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
====== écran ======<br />
On écrit plusieurs fonctions pour notre carte écran, qui est pour l'instant testée par le biais de l'afficheur 7 segments d'où certainess lignes commentées. <br />
<br />
Ces fonctions servent à :<br />
<br />
* initialiser l'écran<br />
* écrire dessus en activant le spi<br />
* régler l'intensité de l'écran<br />
* nettoyer l'écran<br />
<syntaxhighlight lang="c"><br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
void ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
// setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
onPin(CS5_GPIO, CS5_PIN); // S'active à l'etat bas<br />
// offPin(RST5_GPIO, RST5_PIN); // S'active à l'etat bas<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
</syntaxhighlight>On écrit ensuite le code du compteur :<syntaxhighlight lang="c"><br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== main ======<br />
<syntaxhighlight lang="c"><br />
int main(void) {<br />
setupCarte();<br />
ecran_brightness(100);<br />
int j = 0;<br />
<br />
while (1) {<br />
ecran_compteur();<br />
j++;<br />
<br />
if (j > 10) {<br />
j = 0;<br />
togglePin(GPIOB, 8); // LED1<br />
togglePin(GPIOA, 6); // LED2<br />
togglePin(GPIOB, 7); // LED3<br />
}<br />
<br />
for (volatile uint32_t i = 0; i < 25000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
Nous avons soudé le stricte minimum sur notre carte pour le faire fonctioner avant tout puisque que nous souhaitons trouvé les éventuelles anomalies de soudure ou de conception avant chaque grosse étape. Sur la PCB rouge et la 1ère pcb verte tout est ok. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]La seconde PCB verte en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope. On se rend compte que l'on obtient que du bruit par rapport au pcb rouge. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Bouton<br />
//setupPin(BTNs_PORT, BTNs_DDR, BTN_Right, INPUT_PULL_UP);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Détection de notre matrice de boutons ====<br />
<br />
On créer un fichier qui pourra être facilement importer dans nos différents projets afin d'avoir une détection de touche facilement importer dans la suite : la LUFA.<br />
<br />
Voici alors clavier.c :<syntaxhighlight lang="c"><br />
#include "clavier.h"<br />
<br />
#include "../lib/HARDWARE/hardware.h"<br />
#include <avr/io.h><br />
<br />
// --------- Colonnes ---------<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_pins_reg[TOTAL_COL] = {<br />
[0 ... 5] = &PINF, // COL0 à COL5<br />
[6 ... 7] = &PINC, // COL6 à COL7<br />
[8 ... 10] = &PINB, // COL8 à COL10<br />
[11 ... 13] = &PIND, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
<br />
// --------- Lignes ---------<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
void init_matrix_button(void) {<br />
// Configuration colonnes en entrée avec pull-up<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], INPUT_PULL_UP);<br />
}<br />
<br />
// Configuration ligne en sortie<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], OUTPUT);<br />
onPin(row_ports[r], row_pins[r]); // mettre toutes les lignes à 1 pour les desactiver<br />
}<br />
}<br />
<br />
void scan() {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
offPin(row_ports[r], row_pins[r]); // activer ligne (LOW)<br />
<br />
for (uint8_t c = 0; c < TOTAL_COL; c++)<br />
key_state[c][r] = !(*col_pins_reg[c] & (1 << col_pins[c]));<br />
<br />
onPin(row_ports[r], row_pins[r]); // désactiver ligne (HIGH)<br />
}<br />
}<br />
<br />
</syntaxhighlight>Et clavier.h : <syntaxhighlight lang="c"><br />
#ifndef CLAVIER_H<br />
#define CLAVIER_H<br />
<br />
#include "keyswitch.h"<br />
#include <stdint.h><br />
#include "clavier_conversion.h"<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
void init_matrix_button(void);<br />
void scan(void);<br />
<br />
#endif<br />
</syntaxhighlight>Et ensuite nous avons pleins de define afin de lire chaque bouton individuellement au lieu d'appeler un tableau (pas intuitif pour l'utilisateur) dans un fichier keyswitch.h :<syntaxhighlight lang="c"><br />
#ifndef KEYSWITCH_H<br />
#define KEYSWITCH_H<br />
<br />
#include <stdint.h><br />
<br />
#define TOTAL_KEYSWITCH 62<br />
#define TOTAL_COL 14<br />
#define TOTAL_ROW 5<br />
<br />
<br />
// COL0 PF0 | COL1 PF1 | COL2 PF4 | COL3 PF5 | COL4 PF6 | COL5 PF7 | COL6 PC7 | <br />
// COL7 PC6 | COL8 PB6 | COL9 PB5 | COL10 PB4 | COL11 PD7 | COL12 PD6 | COL13 PD4<br />
typedef enum{<br />
COL0 = 0,<br />
COL1 = 1,<br />
COL2 = 2,<br />
COL3 = 3,<br />
COL4 = 4,<br />
COL5 = 5,<br />
COL6 = 6,<br />
COL7 = 7,<br />
COL8 = 8,<br />
COL9 = 9,<br />
COL10 = 10,<br />
COL11 = 11,<br />
COL12 = 12,<br />
COL13 = 13,<br />
} COLs;<br />
<br />
// ROW0 PD5 | ROW1 PD3 | ROW2 PD2 | ROW3 PD1 | ROW4 PD0<br />
typedef enum{<br />
ROW0 = 0,<br />
ROW1 = 1,<br />
ROW2 = 2,<br />
ROW3 = 3,<br />
ROW4 = 4,<br />
} ROWs;<br />
<br />
extern uint8_t key_state[TOTAL_COL][TOTAL_ROW];<br />
<br />
#define btn1 key_state[COL0][ROW0]<br />
#define btn2 key_state[COL1][ROW0]<br />
#define btn3 key_state[COL2][ROW0]<br />
#define btn4 key_state[COL3][ROW0]<br />
#define btn5 key_state[COL4][ROW0]<br />
#define btn6 key_state[COL5][ROW0]<br />
#define btn7 key_state[COL6][ROW0]<br />
#define btn8 key_state[COL7][ROW0]<br />
#define btn9 key_state[COL8][ROW0]<br />
#define btn10 key_state[COL9][ROW0]<br />
#define btn11 key_state[COL10][ROW0]<br />
#define btn12 key_state[COL11][ROW0]<br />
#define btn13 key_state[COL12][ROW0]<br />
#define btn14 key_state[COL13][ROW0]<br />
<br />
#define btn15 key_state[COL0][ROW1]<br />
#define btn16 key_state[COL1][ROW1]<br />
#define btn17 key_state[COL2][ROW1]<br />
#define btn18 key_state[COL3][ROW1]<br />
#define btn19 key_state[COL4][ROW1]<br />
#define btn20 key_state[COL5][ROW1]<br />
#define btn21 key_state[COL6][ROW1]<br />
#define btn22 key_state[COL7][ROW1]<br />
#define btn23 key_state[COL8][ROW1]<br />
#define btn24 key_state[COL9][ROW1]<br />
#define btn25 key_state[COL10][ROW1]<br />
#define btn26 key_state[COL11][ROW1]<br />
#define btn27 key_state[COL12][ROW1]<br />
#define btn28 key_state[COL13][ROW1]<br />
<br />
#define btn29 key_state[COL0][ROW2]<br />
#define btn30 key_state[COL1][ROW2]<br />
#define btn31 key_state[COL2][ROW2]<br />
#define btn32 key_state[COL3][ROW2]<br />
#define btn33 key_state[COL4][ROW2]<br />
#define btn34 key_state[COL5][ROW2]<br />
#define btn35 key_state[COL6][ROW2]<br />
#define btn36 key_state[COL7][ROW2]<br />
#define btn37 key_state[COL8][ROW2]<br />
#define btn38 key_state[COL9][ROW2]<br />
#define btn39 key_state[COL10][ROW2]<br />
#define btn40 key_state[COL11][ROW2]<br />
#define btn41 key_state[COL12][ROW2]<br />
<br />
#define btn42 key_state[COL0][ROW3]<br />
#define btn43 key_state[COL1][ROW3]<br />
#define btn44 key_state[COL2][ROW3]<br />
#define btn45 key_state[COL3][ROW3]<br />
#define btn46 key_state[COL4][ROW3]<br />
#define btn47 key_state[COL5][ROW3]<br />
#define btn48 key_state[COL6][ROW3]<br />
#define btn49 key_state[COL7][ROW3]<br />
#define btn50 key_state[COL8][ROW3]<br />
#define btn51 key_state[COL9][ROW3]<br />
#define btn52 key_state[COL10][ROW3]<br />
#define btn53 key_state[COL11][ROW3]<br />
#define btn54 key_state[COL13][ROW3]<br />
<br />
#define btn55 key_state[COL0][ROW4]<br />
#define btn56 key_state[COL1][ROW4]<br />
#define btn57 key_state[COL2][ROW4]<br />
#define btn58 key_state[COL6][ROW4]<br />
#define btn59 key_state[COL10][ROW4]<br />
#define btn60 key_state[COL11][ROW4]<br />
#define btn61 key_state[COL12][ROW4]<br />
#define btn62 key_state[COL13][ROW4]<br />
<br />
#endif<br />
</syntaxhighlight>La bivliothèque à été penser pour être facilement réadaptable et lisible pour un utilisateur souhaitant re coder un clavier mais également pour quelqu'un ne souhaitant pas refaire l'hardware et juste plug and play celui déjà fait.<br />
<br />
==== LUFA ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA. Rien de bien compliqué, on retrouve le projet LUFA sur ce lien github : https://github.com/abcminiuser/lufa<br />
<br />
On télécharge le projet et on vient extraire la librairie LUFA et l'exemple Keyboard présent dans le dossier Démo. On modifie le Makefile présent ainsi : <syntaxhighlight lang="makefile"><br />
MES_LIBS = lib/HARDWARE/hardware.c lib/CLAVIER/clavier.c<br />
<br />
MCU = atmega32u4<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = Keyboard<br />
SRC = $(TARGET).c Descriptors.c $(MES_LIBS) $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)<br />
LUFA_PATH = ../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
<br />
# Default target<br />
all:<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_PORT = /dev/ttyACM0<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = avr109<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(MCU) -c $(AVRDUDE_PROGRAMMER) \<br />
-P $(AVRDUDE_PORT) -b $(AVRDUDE_BAUD) -D \<br />
-U flash:w:$(TARGET).hex:i<br />
</syntaxhighlight>La ligne upload est necessaire seulement si vous avez un bootloader personnalisé, auquel cas faite un simple make dfu pour téléverser.<br />
<br />
<br />
Ensuite on vient ajouter nos libraries aux fichiers Keyboard.c : <syntaxhighlight lang="c"><br />
#include "./lib/CLAVIER/clavier.h"<br />
#include "./lib/HARDWARE/hardware.h"<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
void SetupHardware() {<br />
/* Disable watchdog if enabled by bootloader/fuses */<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
<br />
/* Disable clock division */<br />
clock_prescale_set(clock_div_1);<br />
<br />
/* Hardware Initialization */<br />
setupHardware();<br />
init_matrix_button();<br />
<br />
// Initialisation USB obligatoire<br />
USB_Init();<br />
}<br />
<br />
// ... je passe les détails basique du fichier<br />
<br />
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
uint8_t *const ReportID,<br />
const uint8_t ReportType,<br />
void *ReportData,<br />
uint16_t *const ReportSize) {<br />
<br />
USB_KeyboardReport_Data_t *KeyboardReport = (USB_KeyboardReport_Data_t *)ReportData;<br />
uint8_t UsedKeyCodes = 0;<br />
<br />
scan();<br />
<br />
// ROW0<br />
if (btn1) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ESCAPE);<br />
if (btn2 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_1_AND_EXCLAMATION);<br />
if (btn3 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_2_AND_AT);<br />
if (btn4 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_3_AND_HASHMARK);<br />
if (btn5 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_4_AND_DOLLAR);<br />
if (btn6 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_5_AND_PERCENTAGE);<br />
if (btn7 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_6_AND_CARET);<br />
if (btn8 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_7_AND_AMPERSAND);<br />
if (btn9 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_8_AND_ASTERISK);<br />
if (btn10 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);<br />
if (btn11 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);<br />
if (btn12 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE); // ) ° ]<br />
if (btn13 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_EQUAL_AND_PLUS); // = + }<br />
if (btn14) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_BACKSPACE);<br />
<br />
// ROW1<br />
if (btn15) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_TAB);<br />
if (btn16) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_A);<br />
if (btn17) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Z);<br />
if (btn18) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_E);<br />
if (btn19) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_R);<br />
if (btn20) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_T);<br />
if (btn21) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Y);<br />
if (btn22) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_U);<br />
if (btn23) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_I);<br />
if (btn24) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_O);<br />
if (btn25) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_P);<br />
if (btn26) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE); // ^¨<br />
if (btn27) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE); // $£¤<br />
if (btn28) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_ENTER);<br />
<br />
// ROW2<br />
if (btn29) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_CAPS_LOCK);<br />
if (btn30) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_Q);<br />
if (btn31) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_S);<br />
if (btn32) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_D);<br />
if (btn33) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F); <br />
if (btn34) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_G);<br />
if (btn35) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_H);<br />
if (btn36) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_J);<br />
if (btn37) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_K);<br />
if (btn38) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_L);<br />
if (btn39) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_M);<br />
if (btn40) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE); // % ù<br />
if (btn41) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE); // µ * <br />
<br />
// ROW3<br />
if (btn42) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_SHIFT);<br />
if (btn43) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE);<br />
if (btn44) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_W);<br />
if (btn45) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_X);<br />
if (btn46) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_C);<br />
if (btn47) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_V);<br />
if (btn48) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_B);<br />
if (btn49) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_N);<br />
if (btn50) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN); // ,?<br />
// if (btn51) KeyboardReport->KeyCode[UsedKeyCodes++] = ; // ;.<br />
if (btn52) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN); // :/<br />
if (btn53 && !btn62) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK); // !§<br />
if (btn54) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_SHIFT);<br />
<br />
// ROW4<br />
if (btn55) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTCTRL);<br />
if (btn56) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_LEFTGUI);<br />
if (btn57) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ALT);<br />
if (btn58) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_SPACE);<br />
if (btn59 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTALT);<br />
// if (btn60 && !btn62) KeyboardReport->Keyboard |= QWERTY_to_AZERTY(); // Trouver une fonction a celui ci<br />
if (btn61 && !btn62) KeyboardReport->Modifier |= QWERTY_to_AZERTY(HID_KEYBOARD_MODIFIER_RIGHTCTRL);<br />
<br />
// Fonction spéciale du clavier côté HARDWARE<br />
if(btn62){<br />
// Fonction F1 à F12<br />
if (btn2) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F1);<br />
if (btn3) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F2);<br />
if (btn4) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F3);<br />
if (btn5) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F4);<br />
if (btn6) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F5);<br />
if (btn7) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F6);<br />
if (btn8) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F7);<br />
if (btn9) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F8);<br />
if (btn10) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F9);<br />
if (btn11) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F10);<br />
if (btn12) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F11);<br />
if (btn13) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_F12);<br />
<br />
// Déplacement<br />
if (btn60) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_DOWN_ARROW);<br />
if (btn59) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_LEFT_ARROW);<br />
if (btn61) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_RIGHT_ARROW);<br />
if (btn53) KeyboardReport->KeyCode[UsedKeyCodes++] = QWERTY_to_AZERTY(HID_KEYBOARD_SC_UP_ARROW);<br />
<br />
}<br />
<br />
*ReportSize = sizeof(USB_KeyboardReport_Data_t);<br />
return false;<br />
}<br />
<br />
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t *const HIDInterfaceInfo,<br />
const uint8_t ReportID,<br />
const uint8_t ReportType,<br />
const void *ReportData,<br />
const uint16_t ReportSize) {<br />
<br />
uint8_t *LEDReport = (uint8_t *)ReportData;<br />
<br />
if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)<br />
onPin(LEDs_PORT,LED_CapsLock);<br />
else<br />
offPin(LEDs_PORT,LED_CapsLock);<br />
<br />
}<br />
<br />
<br />
</syntaxhighlight><br />
<br />
<br />
J'ai fais une petite macro (repris de l'année dernière, projet manette) pour convertir les caractères sur un clavier AZERTY dans le fichier clavier_conversion.h :<syntaxhighlight lang="c"><br />
#ifndef CLAVIER_CONVERSION_H<br />
#define CLAVIER_CONVERSION_H<br />
<br />
#include <../../LUFA/Drivers/USB/USB.h><br />
<br />
static inline uint8_t QWERTY_to_AZERTY(uint8_t qwerty_code) {<br />
switch (qwerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_SEMICOLON_AND_COLON; <br />
case HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN: return HID_KEYBOARD_SC_M; <br />
default: return qwerty_code; <br />
}<br />
}<br />
<br />
static inline uint8_t AZERTY_to_QWERTY(uint8_t azerty_code) {<br />
switch (azerty_code) {<br />
// Lettres<br />
case HID_KEYBOARD_SC_A: return HID_KEYBOARD_SC_Q;<br />
case HID_KEYBOARD_SC_Z: return HID_KEYBOARD_SC_W;<br />
case HID_KEYBOARD_SC_Q: return HID_KEYBOARD_SC_A;<br />
case HID_KEYBOARD_SC_W: return HID_KEYBOARD_SC_Z;<br />
case HID_KEYBOARD_SC_SEMICOLON_AND_COLON: return HID_KEYBOARD_SC_M; <br />
case HID_KEYBOARD_SC_M: return HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN;<br />
default: return azerty_code;<br />
}<br />
}<br />
<br />
#endif<br />
<br />
</syntaxhighlight>J'ai eu beaucoup de mal a trouver certains caractères mais le document présent ci dessous m'as grandement aidé :<br />
[[Fichier:HID Usage Tables.pdf|centré|vignette|HID Usage Tables]]<br />
A partir de la page 89 nous avons l'ensemble des codes et certains détails pour certains d'entre eux. Malgré tout une touche n'as pas réussi à être mapper (je n'ai pas trouvé le code équivalent pour mon clavier AZERTY), cette touche correspond au point virgule / point (;.). <br />
<br />
Cependant le code reste fonctionnelle, j'y ai ajouté la possiblité de se deplacer via la touche FN qui correspond aux fonctionnalité spéciale, comme toutes les touches F1,F2,...F10,F11,F12 qui sont mappé aux touches 1,2,...,0,°,+.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:HID_Usage_Tables.pdf&diff=8679Fichier:HID Usage Tables.pdf2025-12-30T20:19:46Z<p>Cpayet : </p>
<hr />
<div>HID Usage Tables</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8678SE4Binome2025-62025-12-30T20:05:17Z<p>Cpayet : /* Carte mère */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
[[Fichier:Correction pcb.jpg|right|alt=correction_pcb|vignette|correction_pcb]]<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment dû mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
On ne programme pas la carte SD ici, on le fait directement sur la nucleo.<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_shield/ordonnanceur<br />
<br />
Notre ordonnanceur est structuré de la manière suivante :<br />
<br />
* un main.c<br />
* lib qui contient les fichiers nécéssaires pour le main.c<br />
*# Un dossier Hardware <br />
*# Un dossier ordonnanceur<br />
*# Un dossier Task<br />
*# Un dossier USART<br />
* build : un dossier qui stocke les exécutables à part<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== HARWARE ======<br />
La première étape est de faire clignoter les leds qui serviront de futures tâches. On implémente donc les fonctions suivantes : <syntaxhighlight lang="c"><br />
#define LEDs_PORT &PORTD<br />
<br />
#define LED_CS1 3<br />
#define LED_CS2 2<br />
#define LED_CS3 1<br />
#define LED_CS4 0<br />
<br />
void toggleLedCS1(){<br />
*LEDs_PORT ^= (1 << LED_CS1);<br />
}<br />
<br />
void toggleLedCS2(){<br />
*LEDs_PORT ^= (1 << LED_CS2);<br />
}<br />
<br />
void toggleLedCS3(){<br />
*LEDs_PORT ^= (1 << LED_CS3);<br />
}<br />
<br />
void toggleLedCS4(){<br />
*LEDs_PORT ^= (1 << LED_CS4);<br />
}<br />
<br />
</syntaxhighlight>On réutilise ensuite la fonction setupPin qui permet d'initialiser nos leds.<syntaxhighlight lang="c"><br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
#define LEDs_DDR &DDRD<br />
<br />
void setupPin(volatile uint8_t *PORTx, volatile uint8_t *DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode) {<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight>On initialise ensuite l'horloge :<syntaxhighlight lang="c"><br />
void setupClock() {<br />
// Activer possibilité de changer le prescaler<br />
CLKPR = (1 << CLKPCE);<br />
// Choix diviseur<br />
CLKPR = 0; <br />
}<br />
</syntaxhighlight>Puis l'hardware complet :<syntaxhighlight lang="c"><br />
void setupHardware(){<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS1, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS2, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS3, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED_CS4, OUTPUT);<br />
<br />
init_usart();<br />
}<br />
</syntaxhighlight><br />
<br />
====== USART ======<br />
Dans le dossier USART, on définit les fonctions basiques pour initialiser, envoyer et recevoir depuis l'usart. L'usart nous servira par la suite pour certaines tâches.<syntaxhighlight lang="c"><br />
#define BAUD_RATE 9600<br />
#define F_CPU 16000000UL<br />
#define UBRR_VALUE ((F_CPU/16/BAUD_RATE)-1)<br />
<br />
void init_usart() {<br />
// Serial Initialization<br />
/*Set baud rate 9600 */<br />
UBRR0H = (unsigned char)(UBRR_VALUE >> 8);<br />
UBRR0L = (unsigned char)UBRR_VALUE;<br />
<br />
/* Enable receiver and transmitter */<br />
UCSR0B = (1 << RXEN0) | (1 << TXEN0);<br />
<br />
/* Frame format: 8data, No parity, 1stop bit */<br />
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);<br />
}<br />
<br />
void usart_send(unsigned char data) {<br />
while (!(UCSR0A & (1 << UDRE0)));<br />
UDR0 = data;<br />
}<br />
<br />
unsigned char usart_receive() {<br />
while (!(UCSR0A & (1 << RXC0)));<br />
return UDR0;<br />
}<br />
</syntaxhighlight><br />
<br />
====== TASK ======<br />
On pense ensuite aux tâches que l'on va implémenter dans notre ordonnanceur.<br />
<br />
On implémente des tâches pour les leds :<syntaxhighlight lang="c"><br />
<br />
void taskCS1() {<br />
while(1){ <br />
toggleLedCS1();<br />
_delay_ms(1000);<br />
} <br />
}<br />
<br />
void taskCS2() { <br />
while(1){ <br />
toggleLedCS2();<br />
_delay_ms(500);<br />
} <br />
}<br />
<br />
void taskCS3() { <br />
while(1){ <br />
toggleLedCS3();<br />
_delay_ms(500);<br />
} <br />
}<br />
<br />
void taskCS4() {<br />
while(1){ <br />
toggleLedCS4();<br />
_delay_ms(250);<br />
} <br />
} <br />
</syntaxhighlight>et pour le série :<syntaxhighlight lang="c"><br />
<br />
void taskSendSerialA() {<br />
while (1) {<br />
usart_send('A');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
void taskSendSerialB() {<br />
while (1) {<br />
usart_send('B');<br />
usart_send('\n');<br />
usart_send('\r');<br />
_delay_ms(250);<br />
}<br />
}<br />
</syntaxhighlight>On définit ensuite la structure générale pour les tâches. <br />
<br />
Une tâche possède :<br />
<br />
* un pointeur de fonction avec le nom de la tâche<br />
* un pointeur pour l'adresse mémoire afin de savoir où est située la tâche dans la pile<br />
* l'état de la tâche : actif ou non (endormi)<br />
* le temps pour lequel la tâche reste endormie<br />
<syntaxhighlight lang="c"><br />
typedef enum{<br />
AWAKE,<br />
SLEEP,<br />
} state_task;<br />
<br />
typedef struct {<br />
void (*taskAddress)(void); // fonction de la tache<br />
uint16_t stackPointer; // pointeur de pile<br />
state_task state; // AWAKE ou SLEEP<br />
uint16_t sleepTime; // temps restant en ms<br />
} process;<br />
<br />
<br />
</syntaxhighlight>On définit donc un tableau de tâches et une constante pour savoir le nombre de tâches que l'on a. <syntaxhighlight lang="c"><br />
process task[] = {<br />
// {taskSendSerialA, 0x0780, AWAKE, 0},<br />
{taskCS1, 0x0730, AWAKE, 0},<br />
// {taskSendSerialB, 0x06E0 , AWAKE, 0},<br />
// {taskCS2, 0x0690, AWAKE, 0},<br />
// {taskCS3, 0x06E0, AWAKE, 0},<br />
// {taskCS4, 0x0620, AWAKE, 0},<br />
};<br />
<br />
const uint8_t nbTasks = sizeof(task)/sizeof(task[0]);<br />
</syntaxhighlight><br />
<br />
====== ORDONNANCEUR ======<br />
Pour débuter notre ordonnanceur, on commence par créér un minuteur afin de faire clignoter deux leds à des périodes différentes. <syntaxhighlight lang="c"><br />
void init_timer1(int diviseur, long periode_ms){<br />
tick_ms = periode_ms; <br />
<br />
TCCR1A = 0;<br />
TCCR1B = (1 << WGM12); // CTC mode<br />
<br />
switch(diviseur){<br />
case 64: TCCR1B |= (1<<CS11)|(1<<CS10); break;<br />
case 256: TCCR1B |= (1<<CS12); break;<br />
}<br />
<br />
OCR1A = (F_CPU / diviseur) * periode_ms / 1000;<br />
TCNT1 = 0;<br />
TIMSK1 = (1 << OCIE1A);<br />
}<br />
</syntaxhighlight>Une fois que le minuteur a atteint son nombre de "ticks", il appelle l'ISR : Interrupt Service Routine, qui prend le relai. <br />
<br />
L'ISR a besoin de la pile, on implémente donc une fonction afin d'initialiser la pile. <syntaxhighlight lang="c"><br />
void init_pile(int n){<br />
uint16_t savedSP = SP;<br />
uint16_t addr = (uint16_t)task[n].taskAddress;<br />
<br />
SP = task[n].stackPointer;<br />
<br />
// PC (low puis high)<br />
asm volatile("push %A0" :: "r"(addr));<br />
asm volatile("push %B0" :: "r"(addr));<br />
<br />
// r0-r31<br />
for(int i=0; i<32; i++)<br />
asm volatile("push __zero_reg__");<br />
<br />
// SREG = I=1<br />
uint8_t s = 0x80;<br />
asm volatile("push %0" :: "r"(s));<br />
<br />
task[n].stackPointer = SP;<br />
SP = savedSP;<br />
}<br />
</syntaxhighlight><br />
<br />
L'ISR procède ainsi :<br />
<br />
* Elle commence par sauvegarder les registres grâce à la fonction assembleur SAVE_REGISTERS définie dans ordonnanceur.h, qui permet de sauvegarder les registres de la tâche interrompue<br />
* On appelle ensuite l'ordonnanceur qui définit la manière dont les tâches sont exécutées.<br />
* On restore ensuite le contexte, et tous les registres de la tâche que l'on va exécuter.<br />
<syntaxhighlight lang="c"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTERS();<br />
task[currentTask].stackPointer = SP;<br />
<br />
/* Appel à l'ordonnanceur qui choisi la prochaine tache */<br />
scheduler();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = task[currentTask].stackPointer;<br />
RESTORE_REGISTERS();<br />
<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight>L'ordonnanceur est ici round-robin, il exécute donc les tâches les unes après les autres sans priorité pour certaines tâches.<syntaxhighlight lang="c"><br />
void scheduler(void){<br />
currentTask = (currentTask + 1) % nbTasks;<br />
}<br />
<br />
</syntaxhighlight>Fonction afin de mettre une tâche en sommeil :<syntaxhighlight lang="c"><br />
void sleep_ms(uint16_t t) {<br />
task[currentTask].state = SLEEP;<br />
task[currentTask].sleepTime = t / tick_ms;<br />
} <br />
</syntaxhighlight><br />
<br />
====== MAIN ======<br />
Dans le fichier main.c, on appelle diverses fonctions notamment le timer, qui appellera donc l'ISR puis le scheduler. On commence également par charger la première tâche sur la pile.<syntaxhighlight lang="c"><br />
int main(void) {<br />
cli(); // désactiver interruptions<br />
setupHardware();<br />
// initialisation des piles<br />
init_tasks();<br />
// TIMER1 config à 20 ms<br />
init_timer1(64, 20);<br />
// charger la pile de la premi??re t??che<br />
SP = task[0].stackPointer;<br />
RESTORE_REGISTERS();<br />
asm volatile("reti");<br />
return 0;<br />
}<br />
</syntaxhighlight><br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant : https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On a ici deux horloges : <br />
<br />
* Première horloge : on peut soit choisir l'oscillateur RC de 16 MHz ou une horloge externe comprise entre 4 et 26 MHz (p18/142) <br />
* Deuxième horloge : horloge pour le temps réel de 32kHZ (donc pas une application qu'on vise) (p22/142)<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
INSERER PHOTO<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><br />
Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
====== Ordonnanceur ======<br />
<p style="clear: both;" /><br />
<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm. Notre ordonnanceur était originellement composé uniquement des fichiers ordonnanceur.c et ordonnanceur.h mais on a implémenté pas mal de fonctions donc on place celles-ci dans un nouveau fichier processus.c accompagné de son processus.h. Ci-dessous la description du contenu de ces 4 fichiers.<br />
* processus.h :<br />
Il inclut les librairies nécéssaires et les prototypes des fonctions implémentées dans processus.c<br />
* processus.c :<br />
<br />
# Fonction Delay : la fonction delay n'est pas présente sous arm donc on l'implémente ici.<syntaxhighlight lang="c"><br />
void delay(volatile uint32_t t){<br />
while (t--){<br />
__asm__("nop");<br />
}<br />
}<br />
</syntaxhighlight><br />
# Tâches pour la led : ci-dessous des fonctions permettant d'allumer, éteindre et faire clignoter la led LD2 de la nucleo. <syntaxhighlight lang="c"><br />
void init_led2(void){<br />
//active l’horloge pour GPIOA car ds les stm32, les peripheriques sont eteints pr economiser de l energie et on doit appeler la clock pr réveiller les gpio<br />
RCC->AHB1ENR |= (1 << 0);<br />
//on veut écrire 01 (état haut) et pas 11 (analogique) pour les broches 10 et 11 donc on doit procéder en deux étapes : d'abord effacer puis mettre en sortie<br />
GPIOA->MODER &= ~(0x3 << (5*2));<br />
GPIOA->MODER |= (0x1 << (5*2));<br />
}<br />
<br />
void led2_on(void){<br />
GPIOA->ODR |= (1 << 5);<br />
}<br />
<br />
void led2_off(void){<br />
GPIOA->ODR &= ~(1 << 5);<br />
}<br />
<br />
void led2_blink(void){<br />
while(1){<br />
GPIOA->ODR ^= (1 << 5);<br />
delay(1000000);<br />
}<br />
}<br />
<br />
void led2_blink_task(void){<br />
static uint32_t counter = 0;<br />
counter++;<br />
if(counter >= 10){ // clignote toutes les 10 interruptions<br />
GPIOA->ODR ^= (1 << 5);<br />
counter = 0;<br />
}<br />
}<br />
</syntaxhighlight><br />
# Tâches pour le série : envoyer un caractère, une chaîne de caractère, recevoir et allumer une led quand l'utilisateur écrit la lettre 'a' dans le minicom.<syntaxhighlight lang="c"><br />
void init_usart2(void){<br />
RCC->APB1ENR |= RCC_APB1ENR_USART2EN;<br />
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;<br />
//PA2 pour tx et PA3 pour rx<br />
GPIOA->MODER &= ~((3 << (2*2)) | (3 << (3*2)));<br />
GPIOA->MODER |= (2 << (2*2)) | (2 << (3*2));<br />
GPIOA->AFR[0] &= ~((0xF << (4*2)) | (0xF << (4*3))); //efface registre alternate function<br />
GPIOA->AFR[0] |= (7 << (4*2)) | (7 << (4*3)); //attribue AF7 dédié à usart2<br />
USART2->BRR = 0x0683; //baudrate à 9600<br />
USART2->CR1 = USART_CR1_TE | USART_CR1_RE; //transmit et receive enable pour tx et rx<br />
USART2->CR1 |= USART_CR1_UE; //usart enable<br />
}<br />
<br />
void usart2_send_char(char c){<br />
while (!(USART2->SR & USART_SR_TXE)); //qd le bit transmit data register empty est à 0 (donc data register possède des données)<br />
USART2->DR = c; //écrire le caractère<br />
}<br />
<br />
void usart2_send_string(char *s){<br />
while (*s){<br />
usart2_send_char(*s++);<br />
}<br />
}<br />
<br />
char usart2_receive(void){<br />
while (!(USART2->SR & USART_SR_RXNE)); //qd caractère<br />
return (char)(USART2->DR & 0xFF); //char sur 16bits on garde que bits de données<br />
}<br />
<br />
void led2_blink_serial(void){<br />
for (int i=0; i<10; i++){<br />
GPIOA->ODR ^= (1 << 5);<br />
delay(1000000);<br />
}<br />
}<br />
<br />
void led_serial(void){<br />
while(1){<br />
char c = usart2_receive();<br />
usart2_send_char(c); //echo vers Minicom<br />
if(c == 'a')<br />
led2_blink_serial();<br />
}<br />
}<br />
</syntaxhighlight>Commande minicom à taper dans le terminal (-o permet d'éviter que minicom envoie des commandes d'initialisation) :<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>Exemple de tâche (non ordonnancée pour le moment) où l'on affiche un message voulu, ici "heyyy" sur minicom[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
# Tâche avec le bouton : allumer la led LD2 quand on appuie sur le bouton user (en bleu, le noir étant dédié au reset).<syntaxhighlight lang="c"><br />
void init_user_button(void){<br />
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN;<br />
GPIOC->MODER &= ~(0x3 << (13 * 2)); //PC13 en entrée<br />
//pull up<br />
GPIOC->PUPDR &= ~(0x3 << (13 * 2));<br />
GPIOC->PUPDR |= (0x1 << (13 * 2)); //01 : pull up<br />
}<br />
<br />
uint8_t user_button_pressed(void){<br />
return (GPIOC->IDR & (1 << 13)) == 0; //bouton actif à 0<br />
}<br />
<br />
void task_button_led(void){<br />
while(1){<br />
if(user_button_pressed()){<br />
led2_on();<br />
} else {<br />
led2_off();<br />
}<br />
}<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" /><br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies, processus.h et la liste des fonctions implémentées dans ordonnanceur.c.<br />
<br />
* ordonnanceur.c :<br />
Ce fichier gère le minuteur, les interruptions, la gestion des tâches.<br />
<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps. <syntaxhighlight lang="c"><br />
extern uint32_t SystemCoreClock; //freq horloge<br />
<br />
void init_minuteur(uint16_t prescaler, uint16_t periode_ms){<br />
RCC->APB1ENR |= RCC_APB1ENR_TIM6EN; //active l'horloge de TIM6<br />
TIM6->PSC = prescaler - 1; //prescaler<br />
uint32_t tick_freq = SystemCoreClock/prescaler; //période<br />
//TIM6->ARR = (tick_freq * periode_ms)/1000-1; //Auto-Reload Register est la période avant que le timer fasse une interruption. (tick_freq * periode_ms)/1000 correspond au nb de ticks durant cette période.<br />
TIM6->ARR = (uint32_t)(((uint64_t)tick_freq * periode_ms)/1000 - 1);<br />
TIM6->CNT = 0; //reset compteur<br />
TIM6->DIER |= TIM_DIER_UIE; //interruption activée quand compteur atteint nb de ticks de ARR<br />
TIM6->CR1 |= TIM_CR1_CEN; //compteur<br />
NVIC_SetPriority(TIM6_DAC_IRQn, 0x1); //prio haute<br />
NVIC_EnableIRQ(TIM6_DAC_IRQn); //active l'interruption dans le NVIC (Nested Vector Interrupt Controller)<br />
}<br />
</syntaxhighlight><br />
On ajoute ensuite le shield sur la nucleo afin de pouvoir tester l'ordonnanceur avec plus de tâches puisque la nucleo seule possède très peu de leds.[[Fichier:Nucleo ordonnanceur.jpg|center|500px|alt=nucleo_ordonnanceur|vignette|nucleo_ordonnanceur]]<br />
====== Système de fichier ======<br />
Afin de débuter le système de fichiers, on connecte notre mémoire (la carte SD) à notre nucleo.[[Fichier:Nulceo sd.jpg|center|500px|alt=nucleo_sd|vignette|nucleo_sd]]<br />
<p style="clear: both;" /><br />
<br />
'''Test d'initialisation'''<br />
<br />
On commence par initialiser notre carte SD grâce à fichier.c et en premier lieu cela ne fonctionnait pas on avait status=1 et erreur=8 (et en conséquent une taille nulle puisqu'il n'arrive pas à initialiser la carte). La carte n'était pas de bonne qualité et ne communiquait pas en SPI mais sans doute avec un autre protocole. Mais par la suite avec la carte SD donnée par M. Redon, on a réussi à la phase d'initialisation. <br />
<br />
On obtient alors :<br />
<br />
* son type, ici 2 (l'autre type étant 1 pour les micro cartes sd moins performantes) <br />
* ainsi que sa taille : 3 911 860 secteurs. Un secteur étant de 512 octets, on retrouve bien la taille écrite sur notre carte à savoir 2Gb.<br />
<br />
[[Fichier:Sd init.png|center|600px|alt=Sd init|vignette|Sd init]]<br />
<p style="clear: both;" /><br />
<br />
Suite à cela, on teste l'écriture, qui s'avère opérationelle (status = 1) puis l'écriture, elle aussi fonctionnelle puisque l'on affiche bien les 3 "blocs" voulus.<br />
<br />
[[Fichier:Sd read test.png|600px|alt=Sd read test|vignette|Sd read test]]<br />
[[Fichier:Sd write test.png|600px|alt=Sd write test|vignette|Sd write test|gauche]]<br />
<p style="clear: both;" />'''Commandes pour le système de fichier'''<br />
<br />
La prochaine étape est de coder les commandes nécéssaires telles que append, read, remove, rename, copy.<br />
<br />
# format : efface l'entièreté du système de fichier.<br />
# list : liste les noms des fichiers contenus dans le système de fichier, équivalent du "ls" sous linux.<br />
# append : créé un fichier si non existant et ajoute du texte si le fichier existe déjà. Commande de la forme append fichier/données. Combine le "touch" (create dans l'énoncé) et l'écriture de données.<br />
# read : permet de lire le contenu d'un fichier, équivalent du "cat".<br />
# remove : supprime le fichier en paramètre, équivalent du "rm".<br />
# rename : renommer un fichier, équivalent du "mv" en moins puissant.<br />
# copy : copie un fichier et ses données dans un second fichier, équivalent du "cp".<br />
<br />
[[Fichier:Demo fileSystem.webm|center|500px|vignette|demo_fileSystem]]<br />
<p style="clear: both;" /><br />
<br />
==== Notre carte mère ====<br />
<br />
===== Test led =====<br />
Afin de vérifier que notre PCB reçu fonctionne, on teste notre carte en faisant clignoter une led.<syntaxhighlight lang="c"><br />
#define LED_PIN 9<br />
<br />
int main(void) {<br />
// Activer horloge GPIOC<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOCEN_Pos);<br />
<br />
GPIOC->MODER &= ~(0x3 << (LED_PIN * 2)); // Clear<br />
GPIOC->MODER |= 0x1 << (LED_PIN * 2); // Output<br />
GPIOC->OTYPER &= ~(1 << LED_PIN); // Push-pull<br />
GPIOC->PUPDR &= ~(0x3 << (LED_PIN * 2)); // No pull<br />
<br />
while (1) {<br />
GPIOC->ODR ^= (1 << LED_PIN);<br />
for (volatile uint32_t i = 0; i < 1000000; i++)<br />
;<br />
}<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
===== Test écran =====<br />
L'idée est d'afficher un compteur sur un afficheur 7 segments, notre "carte écran" : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_mere/Notre_PCB/02-Compteur.<br />
<br />
Notre test écran est structuré de la manière suivante :<br />
* un main.c<br />
* un dossier pour la carte écran<br />
* un dossier hardware_setup<br />
* un dossier pour le spi<br />
<br />
Description des fichiers et fonctions implémentées :<br />
<br />
====== hardware_setup ======<br />
<br />
On reprend notre fonction setupPin que l'on adapte à arm afin d'initialiser les pins de notre carte :<syntaxhighlight lang="c"><br />
#define OFFSET_BSRR_OFF 16<br />
<br />
#define MODER_CLEAR 0x3<br />
#define MODER_NumberBitParPin 0x2<br />
<br />
#define PUPDR_CLEAR 0x3<br />
#define PUPDR_NumberBitParPin 0x2<br />
<br />
#define OTYPER_CLEAR 0x1<br />
<br />
typedef enum {<br />
INPUT,<br />
OUTPUT,<br />
ALTERNATE_FUNCTION,<br />
ANALOG,<br />
} portModeRegister;<br />
<br />
typedef enum {<br />
NO_PULL,<br />
PULL_UP,<br />
PULL_DOWN,<br />
} portPullUpPullDownRegister;<br />
<br />
void setupPin(GPIO_TypeDef *GPIOx, uint8_t PINx, portModeRegister portMode) {<br />
// ACTIVATION DE L'HORLOGE GPIO SPECIFIQUE<br />
uint32_t RCC_AHB1ENR_GPIOxEN_Pos;<br />
<br />
if (GPIOx == GPIOA)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOAEN_Pos;<br />
else if (GPIOx == GPIOB)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOBEN_Pos;<br />
else if (GPIOx == GPIOC)<br />
RCC_AHB1ENR_GPIOxEN_Pos = RCC_AHB1ENR_GPIOCEN_Pos;<br />
else<br />
return; // GPIO non existant sur ce microcontroleur<br />
<br />
if (!(RCC->AHB1ENR & (1 << RCC_AHB1ENR_GPIOxEN_Pos)))<br />
RCC->AHB1ENR |= (1 << RCC_AHB1ENR_GPIOxEN_Pos);<br />
<br />
// CLEAR AVANT MODIFICATION<br />
// On clear après l'activation d'horloge !<br />
GPIOx->MODER &= ~(MODER_CLEAR << (PINx * MODER_NumberBitParPin));<br />
GPIOx->PUPDR &= ~(PUPDR_CLEAR << (PINx * PUPDR_NumberBitParPin));<br />
GPIOx->OTYPER &= ~(OTYPER_CLEAR << PINx); // Push-pull<br />
<br />
// TYPE DE PORT (Input, Output, Alternative, Analogique)<br />
portPullUpPullDownRegister typePull = NO_PULL;<br />
uint8_t optionPort = 0x00;<br />
<br />
switch (portMode) {<br />
case INPUT:<br />
optionPort = 0x00;<br />
typePull = PULL_UP;<br />
break;<br />
<br />
case OUTPUT:<br />
optionPort = 0x01;<br />
typePull = NO_PULL;<br />
<br />
if (1)<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
else<br />
GPIOx->OTYPER |= (1 << PINx); // Open-drain<br />
<br />
break;<br />
<br />
case ALTERNATE_FUNCTION:<br />
optionPort = 0x02;<br />
<br />
if (1) {<br />
typePull = NO_PULL;<br />
GPIOx->OTYPER &= ~(1 << PINx); // Push-pull<br />
GPIOx->OSPEEDR |= 11 << (PINx * 2);<br />
// Very high speed => Cf STM32F410 datasheet tableau p95/142<br />
}<br />
<br />
break;<br />
<br />
case ANALOG:<br />
optionPort = 0x03;<br />
break;<br />
<br />
default:<br />
optionPort = 0x00;<br />
typePull = NO_PULL;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->MODER |= optionPort << (PINx * MODER_NumberBitParPin);<br />
<br />
// TYPE DE PULL (No pull, Pull Down, Pull Up)<br />
uint8_t optionPull = 0x00;<br />
<br />
// Ecriture type pull<br />
switch (typePull) {<br />
case NO_PULL:<br />
optionPull = 0x00;<br />
break;<br />
case PULL_UP:<br />
optionPull = 0x01;<br />
break;<br />
case PULL_DOWN:<br />
optionPull = 0x02;<br />
break;<br />
default:<br />
optionPull = 0x00;<br />
break;<br />
}<br />
<br />
// Ecriture<br />
GPIOx->PUPDR |= optionPull << (PINx * PUPDR_NumberBitParPin);<br />
}<br />
</syntaxhighlight>On implémente également des fonctions qui permettent d'activer, de désactiver ou de faire clignoter (une led en l'occurence) des pins.<syntaxhighlight lang="c"><br />
void onPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << PINx); // set<br />
}<br />
<br />
void offPin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
GPIOx->BSRR = (1 << (PINx + OFFSET_BSRR_OFF)); // reset<br />
}<br />
<br />
void togglePin(GPIO_TypeDef *GPIOx, uint8_t PINx) {<br />
// Après sa lecture, le registre BSRR reset à 0 automatiquement<br />
if (GPIOx->ODR & (1 << PINx)) // Lecture pin, si 1 alors eteindre<br />
offPin(GPIOx, PINx);<br />
else // Sinon allumer<br />
onPin(GPIOx, PINx);<br />
}<br />
</syntaxhighlight>On possède également une fonction qui initialise notre carte mère, en activant les différents ports des cartes filles, le spi, les leds et les boutons.<syntaxhighlight lang="c"><br />
void setupCarte() {<br />
// 1<br />
setupPin(GPIOC, 0, OUTPUT); // PC0, CS1<br />
setupPin(GPIOC, 1, OUTPUT); // PC1, RST1<br />
setupPin(GPIOC, 2, OUTPUT); // PC2, INT1<br />
<br />
// 2<br />
setupPin(GPIOA, 7, OUTPUT); // PA7, CS2<br />
setupPin(GPIOB, 1, OUTPUT); // PB1, RST2<br />
setupPin(GPIOC, 4, OUTPUT); // PC4, INT2<br />
<br />
// 3<br />
setupPin(GPIOC, 9, OUTPUT); // PC9, CS3<br />
setupPin(GPIOB, 6, OUTPUT); // PB6, RST3<br />
setupPin(GPIOB, 5, OUTPUT); // PB5, INT3<br />
<br />
// 4<br />
setupPin(GPIOA, 2, OUTPUT); // PA2, CS4<br />
setupPin(GPIOA, 1, OUTPUT); // PA1, RST4<br />
setupPin(GPIOA, 0, OUTPUT); // PA0, INT4<br />
<br />
// 6<br />
setupPin(GPIOA, 4, OUTPUT); // PA4, CS6<br />
<br />
// FPGA<br />
setupPin(GPIOB, 0, OUTPUT); // PB0, CS_FPGA<br />
<br />
// LEDs<br />
setupPin(GPIOB, 8, OUTPUT); // PB8, LED1<br />
setupPin(GPIOA, 6, OUTPUT); // PA6, LED2<br />
setupPin(GPIOB, 7, OUTPUT); // PB7, LED3<br />
<br />
// BTNs<br />
setupPin(GPIOC, 12, OUTPUT); // PC12, SW_1<br />
setupPin(GPIOB, 11, INPUT); // PB11, SW_2<br />
setupPin(GPIOC, 10, INPUT); // PC10, SW_3<br />
<br />
// Test LEDs allumé<br />
offPin(GPIOC, 0); // PC0, CS1<br />
offPin(GPIOB, 1); // PA7, CS2<br />
offPin(GPIOC, 9); // PC9, CS3<br />
offPin(GPIOA, 2); // PA2, CS4<br />
offPin(GPIOB, 0); // PB0, CS_FPGA<br />
<br />
onPin(GPIOC, 12); // PB0, CS_FPGA<br />
// Setup SPI => MOSI, MISO et SCK<br />
spiInit();<br />
<br />
// Ecran<br />
ecran_init();<br />
}<br />
</syntaxhighlight><br />
<br />
====== spi ======<br />
On initialise également les fonctions pour le SPI, à retrouver ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03-Code/Carte_mere/Notre_PCB/02-Compteur/lib/SPI.<br />
<br />
On implémente les fonctions suivantes, commentées en détail dans le spi.c :<syntaxhighlight lang="c"><br />
void spiInit();<br />
void spi_cs_on(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_cs_off(GPIO_TypeDef *GPIOx, uint8_t PINx);<br />
void spi_write(uint8_t data, GPIO_TypeDef *CS_GPIOx, uint8_t CS_PINx);<br />
</syntaxhighlight><br />
<br />
====== écran ======<br />
On écrit plusieurs fonctions pour notre carte écran, qui est pour l'instant testée par le biais de l'afficheur 7 segments d'où certainess lignes commentées. <br />
<br />
Ces fonctions servent à :<br />
<br />
* initialiser l'écran<br />
* écrire dessus en activant le spi<br />
* régler l'intensité de l'écran<br />
* nettoyer l'écran<br />
<syntaxhighlight lang="c"><br />
// PC11, CS5<br />
#define CS5_GPIO GPIOC<br />
#define CS5_PIN 11<br />
<br />
// PB9, RST5<br />
#define RST5_GPIO GPIOB<br />
#define RST5_PIN 9<br />
<br />
// PC13, INT5<br />
#define INT5_GPIO GPIOC<br />
#define INT5_PIN 13<br />
<br />
void ecran_init() {<br />
setupPin(CS5_GPIO, CS5_PIN, OUTPUT);<br />
// setupPin(RST5_GPIO, RST5_PIN, OUTPUT);<br />
// setupPin(INT5_GPIO, INT5_PIN, OUTPUT);<br />
<br />
onPin(CS5_GPIO, CS5_PIN); // S'active à l'etat bas<br />
// offPin(RST5_GPIO, RST5_PIN); // S'active à l'etat bas<br />
}<br />
<br />
void ecran_spi_write(uint8_t data) {<br />
spi_write(data, CS5_GPIO, CS5_PIN);<br />
}<br />
<br />
void ecran_brightness(uint8_t intensite) {<br />
ecran_spi_write(0x7A); // Commande "Brightness"<br />
ecran_spi_write(intensite); // Sécurité passive 2^8-1 = 255 qui est le maximum<br />
}<br />
<br />
void ecran_clear() {<br />
ecran_spi_write(0x76); // Commande "Clear"<br />
}<br />
<br />
</syntaxhighlight>On écrit ensuite le code du compteur :<syntaxhighlight lang="c"><br />
uint8_t isChange = 0b1111;<br />
<br />
int unite = 0;<br />
int decimal = 0;<br />
int centaine = 0;<br />
int mil = 0;<br />
<br />
void ecran_compteur() {<br />
<br />
ecran_select_digit(3);<br />
ecran_spi_write(unite); // Data<br />
<br />
if (isChange & 0b0010) {<br />
isChange &= ~0b0010;<br />
ecran_select_digit(2);<br />
ecran_spi_write(decimal); // Data<br />
}<br />
<br />
if (isChange & 0b0100) {<br />
isChange &= ~0b0100;<br />
ecran_select_digit(1);<br />
ecran_spi_write(centaine); // Data<br />
}<br />
<br />
if (isChange & 0b1000) {<br />
isChange &= ~0b1000;<br />
ecran_select_digit(0);<br />
ecran_spi_write(mil); // Data<br />
}<br />
<br />
if (unite < 9) {<br />
unite++;<br />
} else {<br />
isChange |= 0b0010;<br />
unite = 0;<br />
if (decimal < 9)<br />
decimal++;<br />
else {<br />
decimal = 0;<br />
isChange |= 0b0100;<br />
<br />
if (centaine < 9) {<br />
centaine++;<br />
} else {<br />
centaine = 0;<br />
isChange |= 0b1000;<br />
<br />
if (mil < 9) {<br />
mil++;<br />
} else {<br />
mil = 0;<br />
}<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== main ======<br />
<syntaxhighlight lang="c"><br />
int main(void) {<br />
setupCarte();<br />
ecran_brightness(100);<br />
int j = 0;<br />
<br />
while (1) {<br />
ecran_compteur();<br />
j++;<br />
<br />
if (j > 10) {<br />
j = 0;<br />
togglePin(GPIOB, 8); // LED1<br />
togglePin(GPIOA, 6); // LED2<br />
togglePin(GPIOB, 7); // LED3<br />
}<br />
<br />
for (volatile uint32_t i = 0; i < 25000; i++)<br />
;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
== Carte fille Clavier ==<br />
<br />
=== Hardware ===<br />
<br />
==== Boutons utilisés ====<br />
Nous voulions implémenter un clavier à touches mécaniques. Monsieur Redon avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh.jpg|alt=Boite Kailh|vignette|center|Boite Kailh Switch]]<br />
<p style="clear: both;" /><br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo de droite, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
[[Fichier:Kailh Hot swap socket.png|left|300px|vignette|Kailh Hot swap socket|300x300px]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|right|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<p style="clear: both;" /><br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><br />
<br />
L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fait gagner un temps précieux sur le routage.<br />
<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoqué avec Monsieur Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasure ====<br />
On brase les composants sur nos deux PCB. On commence par le clavier rouge, qui s'avère bien reconnu par lsusb. <br />
<br />
[[Fichier:Clavier brasé.jpg|500px|alt=clavier brasé|vignette|clavier brasé|centré]]Le PCB vert en revanche n'est pas reconnu. On teste les différentes connexions au multimètre. Le 5V est bien là. On teste alors le quartz à l'oscilloscope. On se rend compte que l'on obtient que du bruit par rapport au pcb rouge. Cependant après avoir changé le quartz, le problème est toujours présent. On finit alors par se rendre compte que l'on a inversé une capacité avec une resistance, le problème est donc résolu rapidement.<p style="clear: both;" /><br />
<br />
[[Fichier:Test oscillo.jpg|left|400px|alt=test_oscillo|vignette|test_oscillo]]<br />
[[Fichier:Oscillo vert.jpg|right|300px|alt=oscillo_vert|vignette|oscillo_vert]]<br />
[[Fichier:Oscillo rouge.jpg|right|300px|alt=oscillo_rouge|vignette|oscillo_rouge]]<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== Test Led ====<br />
Afin de vérifier que notre clavier fonctionne, on fait un test afin de faire clignoter nos deux leds : led d'alimentation et led pour Cap Lock (qui nous servira par la suite pour savoir si notre carte est en mode majuscule ou non).<br />
<br />
Remarque : la fonction setupPin est la même que celle présentée dans la section ordonnanceur de la carte shield.<syntaxhighlight lang="c"><br />
#define F_CPU 16000000UL<br />
<br />
#define LEDs_PORT PORTE<br />
#define LEDs_DDR DDRE<br />
#define LEDs_PIN PINE<br />
#define LED_CapsLock PE6<br />
<br />
void setupHardware() {<br />
setupClock();<br />
// Leds<br />
setupPin(&LEDs_PORT, &LEDs_DDR, LED_CapsLock, OUTPUT);<br />
<br />
// Bouton<br />
//setupPin(BTNs_PORT, BTNs_DDR, BTN_Right, INPUT_PULL_UP);<br />
<br />
// Permet de liberer le portF pour utiliser les boutons !<br />
MCUCR |= (1 << JTD); // 1ère écriture<br />
MCUCR |= (1 << JTD); // Désactiver JTAG (2ème écriture obligatoire !)<br />
}<br />
<br />
int main() {<br />
setupHardware();<br />
while (1) {<br />
LEDs_PORT |= (1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
LEDs_PORT &= ~(1 << LED_CapsLock); // toggle LED<br />
_delay_ms(500);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== Matrice de boutons ====<br />
Suite à cela, on définit une matrice de boutons. L'objectif est de reconnaître quand une touche est activée (les touches étant pour le moment sans signification).<br />
<br />
On définit les colonnes :<syntaxhighlight lang="c"><br />
#define TOTAL_COL 14<br />
<br />
// --- Colonnes ---<br />
volatile uint8_t *col_ports[TOTAL_COL] = {<br />
[0 ... 5] = &PORTF, // COL0 à COL5<br />
[6 ... 7] = &PORTC, // COL6 à COL7<br />
[8 ... 10] = &PORTB, // COL8 à COL10<br />
[11 ... 13] = &PORTD, // COL11 à COL13<br />
};<br />
<br />
volatile uint8_t *col_ddr[TOTAL_COL] = {<br />
[0 ... 5] = &DDRF, // COL0 à COL5<br />
[6 ... 7] = &DDRC, // COL6 à COL7<br />
[8 ... 10] = &DDRB, // COL8 à COL10<br />
[11 ... 13] = &DDRD, // COL11 à COL13<br />
};<br />
<br />
uint8_t col_pins[TOTAL_COL] = {0, 1, 4, 5, 6, 7, 7, 6, 6, 5, 4, 7, 6, 4};<br />
</syntaxhighlight>puis les lignes :<syntaxhighlight lang="c"><br />
#define TOTAL_ROW 5<br />
<br />
// --- Lignes ---<br />
volatile uint8_t *row_ports[TOTAL_ROW] = {<br />
[0 ... 4] = &PORTD,<br />
};<br />
<br />
volatile uint8_t *row_ddr[TOTAL_ROW] = {<br />
[0 ... 4] = &DDRD,<br />
};<br />
volatile uint8_t *row_pins_reg[TOTAL_ROW] = {<br />
[0 ... 4] = &PIND,<br />
};<br />
<br />
uint8_t row_pins[TOTAL_ROW] = {5, 3, 2, 1, 0};<br />
</syntaxhighlight>Par la suite, on configure les colonnes en sortie, les lignes en entrées avec pull-up puis on procède au scan matriciel. Pour vérifier que l'appui sur un bouton est bien detecté, on allume la led CapLock.<syntaxhighlight lang="c"><br />
#define TOTAL_KEYSWITCH 62<br />
uint8_t key_state[TOTAL_COL][TOTAL_ROW] = {0};<br />
<br />
int main(void) {<br />
setupHardware();<br />
<br />
// Configuration colonnes en sortie<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
setupPin(col_ports[c], col_ddr[c], col_pins[c], OUTPUT);<br />
onPin(col_ports[c], col_pins[c]); // mettre toutes les colonnes à 1 pour les desactiver<br />
}<br />
<br />
// Configuration ligne ROW0 en entrée avec pull-up<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
setupPin(row_ports[r], row_ddr[r], row_pins[r], INPUT_PULL_UP);<br />
}<br />
<br />
while (1) {<br />
// Scan matriciel<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
offPin(col_ports[c], col_pins[c]); // activer colonne (LOW)<br />
<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++)<br />
key_state[c][r] = !(*row_pins_reg[r] & (1 << row_pins[r]));<br />
<br />
onPin(col_ports[c], col_pins[c]); // désactiver colonne (HIGH)<br />
}<br />
<br />
int isPressed = 0;<br />
for (uint8_t c = 0; c < TOTAL_COL; c++) {<br />
for (uint8_t r = 0; r < TOTAL_ROW; r++) {<br />
if (key_state[c][r] == 1) {<br />
isPressed = 1;<br />
}<br />
}<br />
}<br />
<br />
if (isPressed)<br />
onPin(LEDs_PORT, LED_CapsLock);<br />
else {<br />
offPin(LEDs_PORT, LED_CapsLock);<br />
}<br />
}<br />
<br />
return 0;<br />
}<br />
</syntaxhighlight><br />
<br />
==== Lufa ====<br />
Afin que nos touches soient reconnus comme des lettres de l'alphabet que l'on peut voir sur notre écran, on utilise la LUFA.<br />
<br />
== Carte Fille FPGA ==<br />
<br />
=== Objectif ===<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Schématique ===<br />
Les notes liées à la conception de la schématique se trouvent dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
==== Puce ====<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes :<br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<br />
==== Liste et Description des sheets ====<br />
'''''FPGA_Power :'''''<br />
<br />
Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposée donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonnée car non supportée par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquençage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.<br />
<br />
<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8348SE4Binome2025-62025-10-30T15:43:23Z<p>Cpayet : /* Notre carte fille comporte plusieurs éléments : */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Concevons un clavier ! ===<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<p style="clear: both;" />On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fais gagner un peu de temps précieux sur le routage.<br />
<br />
=== Kicad - Schématique ===<br />
'''<u>Notre carte fille comporte plusieurs éléments :</u>'''<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
=== Kicad - Vue 3D ===<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Kicad - Schématique ===<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
Les notes liées à la conception de la schématique se trouve dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
===== Liste et Description des sheets =====<br />
'''''FPGA_Power :''''' Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposé et étant donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonné car non supporté par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquencage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8347SE4Binome2025-62025-10-30T15:42:47Z<p>Cpayet : /* Kicad - Schématique Notre carte fille comporte plusieurs éléments : */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Concevons un clavier ! ===<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<p style="clear: both;" />On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fais gagner un peu de temps précieux sur le routage.<br />
<br />
=== Kicad - Schématique ===<br />
<br />
==== Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
=== Kicad - Vue 3D ===<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Kicad - Schématique ===<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
Les notes liées à la conception de la schématique se trouve dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
===== Liste et Description des sheets =====<br />
'''''FPGA_Power :''''' Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposé et étant donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonné car non supporté par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquencage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8346SE4Binome2025-62025-10-30T15:42:14Z<p>Cpayet : /* Boutons utilisés */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Concevons un clavier ! ===<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<p style="clear: both;" />On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fais gagner un peu de temps précieux sur le routage.<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
=== Kicad - Vue 3D ===<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Kicad - Schématique ===<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
Les notes liées à la conception de la schématique se trouve dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
===== Liste et Description des sheets =====<br />
'''''FPGA_Power :''''' Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposé et étant donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonné car non supporté par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquencage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8338SE4Binome2025-62025-10-28T23:57:37Z<p>Cpayet : /* Kicad - Schématique Notre carte fille comporte plusieurs éléments : */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<p style="clear: both;" />On peut également sauvegarder notre configuration en exportant sous format "json". Via ce format on peut utiliser une extension de kicad qui se prénomme "'''Keyboard footprints placer'''" et qui permet de placer automatiquement les boutons si on les intancie dans le bon ordre (exemple : bouton 1 => SW1 , etc...). L'outil est un peu capricieux mais fais gagner un peu de temps précieux sur le routage.<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Kicad - Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
Une '''carte FPGA''' est actuellement en développement en parallèle. Il s’agit d’un '''défi technique majeur''' visant à faire évoluer le projet de '''pico-ordinateur''' vers une nouvelle étape.<br />
<br />
L’objectif, à terme, est de concevoir un '''pico-ordinateur complet''' capable de '''gérer des flux vidéo et audio''', ainsi que différents '''protocoles HID''', notamment en intégrant un '''microcontrôleur''' (comme sur la carte '''Nexys A7''', par exemple). Dans cette optique, le développement de la carte FPGA doit '''progresser au mieux''', mais il est '''possible que le travail se poursuive sur le semestre S8''', comme convenu avec '''M. Boé'''.<br />
=== Kicad - Schématique ===<br />
La référence de la puce FPGA à router est celle ci : XC7A15T-1FTG256C. C'est une puce de la famille Artix-7.<br />
Les notes liées à la conception de la schématique se trouve dans ce répertoire : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA .<br />
<br />
<br />
La schématique comporte elle même toutes les explications, il est donc inutile de revenir sur chacun de ces points ici.<br />
<br />
===== Liste et Description des sheets =====<br />
'''''FPGA_Power :''''' Feuille regroupant l'alimentation critique de notre puce :<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
'''''FPGA_Banks_14-15''''' et '''''FPGA_Banks_34-35''''' ''':''' Feuille disposant de l'ensemble des entrées et sorties du FPGA n'ayant pas de fonction prédisposé et étant donc libre pour ajouter nos composants.<br />
<br />
'''''FPGA_Config :''''' Feuille regroupant les pins de programmation de la puce en fonction du mode choisi au préalable ainsi que la logique data USB-C (2.0 ici) .<br />
<br />
'''''Switch&Button :''''' ''Feuille contenant les boutons et les switchs.'' Joue le rôle de la carte matrice de boutons''.''<br />
<br />
'''''LEDs&7seg :''''' ''Feuille contenant les LEDs et le 7 segments.''<br />
<br />
'''''Ethernet :''''' ''Feuille contenant la logique Ethernet de notre carte.'' Joue le rôle de la carte réseau.<br />
<br />
'''''VGA :''''' ''Feuille contenant toute la logique du VGA.'' Joue le rôle de la carte écran.<br />
<br />
'''''HDMI :''''' ''Feuille abandonné car non supporté par notre puce FPGA.''<br />
<br />
'''''Power :''''' Feuille sur la gestion de l'alimentation avec son séquencage.<br />
<br />
'''''Memory :''''' Feuille contenant la mémoire SRAM de notre carte. Joue le rôle de la carte mémoire.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8337SE4Binome2025-62025-10-28T23:26:42Z<p>Cpayet : /* Vue 3D */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Kicad - Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8336SE4Binome2025-62025-10-28T23:26:06Z<p>Cpayet : /* Kicad - Schématique Notre carte fille comporte plusieurs éléments : */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles. Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8335SE4Binome2025-62025-10-28T23:25:29Z<p>Cpayet : </p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8334SE4Binome2025-62025-10-28T23:23:50Z<p>Cpayet : /* Concevons un clavier ! */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8333SE4Binome2025-62025-10-28T23:22:59Z<p>Cpayet : /* Concevons un clavier ! */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8332SE4Binome2025-62025-10-28T23:22:37Z<p>Cpayet : /* Concevons un clavier ! */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
<br />
<br />
<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8331SE4Binome2025-62025-10-28T23:22:12Z<p>Cpayet : /* Concevons un clavier ! */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
<br />
<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8330SE4Binome2025-62025-10-28T23:21:35Z<p>Cpayet : /* Boutons utilisés */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
<br />
<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2025-6&diff=8329SE4Binome2025-62025-10-28T23:21:09Z<p>Cpayet : /* Carte fille Clavier */</p>
<hr />
<div>== Cahier des charges ==<br />
L'objectif pour notre groupe est de réaliser une carte mère.<br />
<p style="clear: both;" /><br />
<br />
== Lien GIT==<br />
Lien du git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6<br />
<p style="clear: both;" /><br />
<br />
== Carte Shield ==<br />
La première étape est de réaliser un shield au cas où notre carte mère s'avérerait non fonctionnelle, afin de ne pas bloquer l'avancée des groupes des cartes filles.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Composants ====<br />
Afin de réaliser notre bouclier qui combiné à un arduino uno fera guise de carte mère, nous utilisons les composants suivants :<br />
<br />
- Puce ATMega328-A en tant que microprocesseur<br />
<br />
- 5 connecteurs 2*4 pour les cartes filles (clavier, écran, réseau, son) et un connecteur 2*4 pour connecter la carte mémoire.<br />
<br />
- Des convertisseurs de niveaux logiques 5V vers 3,3V pour l'utilisation de la carte mémoire (même si il aurait été préférable de mettre la partie conversion directement sur la carte mémoire).<br />
<p style="clear: both;" /><br />
<br />
==== Schématique et vue 3D ====<br />
[[Fichier:Pico-shield schematique.pdf|left|600px|alt=Pico-shield_schematique|vignette|Pico-shield_schematique]]<br />
[[Fichier:CarteShield 3D.png|right|800px|alt=CarteShield 3D|vignette|CarteShield 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Carte mémoire ====<br />
En extension de notre shield ou de notre future carte mère, on ajoute la gestion de la mémoire avec la carte SD sur une carte mémoire distincte.[[Fichier:Memoire schematic.pdf|left|600px|alt=Memoire_schematic|vignette|Memoire_schematic]]<br />
[[Fichier:Memoire 3D.png|right|800px|alt=Memoire 3D|vignette|Memoire 3D]]<br />
<p style="clear: both;" /><br />
<br />
==== Brasage ====<br />
<br />
On procède au brasage des cartes shield et mémoire.[[Fichier:Cartes shield et memoire brasées.jpg|left|600px|alt=cartes shield et memoire brasées|vignette|cartes shield et memoire brasées]]<br />
[[Fichier:Cartes shield et memoire brasées 2.jpg|right|600px|alt=cartes shield et memoire brasées 2|vignette|cartes shield et memoire brasées 2]]<br />
<p style="clear: both;" /><br />
<br />
==== Tests ====<br />
<br />
===== Test leds =====<br />
<br />
On teste les leds et on constate que notre carte shield est fonctionelle. [[Fichier:Carte shield test leds.jpg|alt=carte shield test leds|left|600px|vignette|carte shield test leds]]<br />
<p style="clear: both;" /><br />
<br />
===== Test carte SD =====<br />
On teste ensuite un programme arduino simple au préalable pour voir si la carte SD est détectée. La carte n'étant pas détectée, on regarde alors :<br />
<br />
# que la connexion série est bien établie pour voir si le problème ne vient pas de l'IDE Arduino -> ce n'est pas le cas.<br />
# si la carte SD est défaillante en testant le programme avec une autre carte SD. On teste aussi sur un lecteur de carte SD pour voir si elle est détectée sur le pc ce qui est le cas -> le pb ne vient pas de là non plus.<br />
# on s'intéresse maintenant à l'aspect matériel, on vérifie les soudures -> toujours pas de souci particulier.<br />
# schématique et routage de la carte : on s'aperçoit alors que l'on a inversé le sens du 74LVC125 de l'unité U1A pour la conversion de niveau logique du MOSI en appuyant par erreur sur le raccourci clavier x qui inverse en "miroir" le sens du composant. Remarque : on aurait aussi vraiment du mettre le convertisseur de niveau logique sur la carte mémoire pour voir le problème plus vite. Conséquence : le routage n'est pas correct, on rajoute donc des fils pour faire les bonnes connexions et on coupe au cutter les mauvaises.<br />
<br />
[INSERER PHOTO]<br />
<br />
=== Software ===<br />
<br />
===== Programmation carte SD =====<br />
Maintenant que la carte SD fonctionne, on va s'atteler à essayer de comprendre son fonctionnement en stockant des données dedans à l'aide de code en C.<br />
<br />
[CONTINUER LA PROG]<br />
<br />
===== Ordonnanceur =====<br />
Maintenant que notre shield est fonctionnel, nous pouvons réaliser notre ordonnanceur. A voir ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/03%20-%20Code/Carte%20Shield/ordonnanceur.<br />
<br />
[EXPLICATIONS A DETAILLER]<br />
<br />
==Carte mère==<br />
La deuxième carte à réaliser est la carte mère avec une spécificité cependant, à savoir une puce STM32F410R8T6 en tant que microprocesseur.<br />
<br />
Remarque : M. Redon a également fait une carte mère mais basée sur un ATSAMD21G8A-A. Celle-ci pourra nous être utile si on rencontre des soucis pour le code avec notre stm32.<br />
=== Hardware ===<br />
<br />
==== Microprocesseur ====<br />
On utilise la puce STM32F410R8T6.<br />
<br />
===== Signification du nom de la puce =====<br />
Signification (cf p 134 de la short datasheet) :<br />
<br />
Arm based 32-bit microcontroller<br />
<br />
* F = General-purpose<br />
* R = 64 pins<br />
* 8 = 64 Kbytes of Flash memory<br />
* T = package LQFP<br />
* 6 = Industrial temperature range, - 40 to 85 °C<br />
<br />
===== Datasheets =====<br />
Datasheet de la puce STM32F410R8T6 :<br />
[[Fichier:STM32 datasheet.pdf|left|400px|alt=STM32_datasheet|vignette|STM32_datasheet]]<br />
<p style="clear: both;" />On peut également retrouver des pages supplémentaires afin de bien dimensionner notre quartz et les capacités aux alentours.<br />
<br />
Document AN2867- Guidelines for oscillator design on STM8AF/AL/S and STM32 MCUs/MPUs à retrouver sur le lien suivant :<br />
https://www.st.com/en/microcontrollers-microprocessors/stm32f410/documentation.html<br />
<p style="clear: both;" /><br />
<br />
==== Schématique ====<br />
Notre schématique est composée de quatres sous feuilles, respectivement pour l'alimentation, le microcontrôleur, la carte mémoire et les cartes filles.<br />
<br />
===== Alimentation =====<br />
L'alimentation se fait via du 5V et est ensuite directement convertie en 3,3V par le biais du régulateur afin d'alimenter le microcontrôleur. C'est pourquoi les bus de données USB ne sont pas utilisées car l'USB servira ici uniquement à l'alimentation et pas à la transmission de données. On ajouté également des mounting holes pour fixer la carte.<br />
<br />
===== Carte mémoire =====<br />
La carte mémoire ou carte fille SD est sensiblement la même que celle pour le shield. On a juste rajouté une capacité de découplage car la carte SD va recevoir et envoyer beaucoup de données rapidement.<br />
<br />
===== Microcontrôleur =====<br />
Le microcontrôleur est composé de beaucoup de broches dédiées à l'alimentation, aux horloges, aux boots, à la communication, aux cartes filles, aux switchs, aux leds et au JTAG (voir sections suivantes).<br />
<br />
====== Alimentation ======<br />
Les broches VDD servent à l'alimentation numérique et VDDA à l'alimentation analogique, ici séparée pour filtrer de manière plus précise car plus sensible que le numérique. En effet, pour filtrer les hautes fréquences en numérique, les capacités de découplage suffisent alors qu'en analogique le signal d'entrée nécessite une gestion plus précise avec une ferrite.<br />
<br />
====== Horloges ======<br />
On utilise ici deux sources d'horloge : on peut soit choisir l'oscillateur RC ou une horloge externe comprise entre 4-26 MHz (p18/142) ou bien la deuxième horloge est une horloge pour temps réels (donc pas une application qu'on vise) (p22/142).<br />
<br />
[PRECISER VALEURS ET REFERENCES]<br />
<br />
====== Boot et configuration ======<br />
Les boot 0 et 1 permettent de choisir la partie ou le bloc mémoire que l'on souhaite réinitialiser. En sélectionnant 0 bit, un bit de l'un ou de l'autre ou les deux, on choisit ce que l'on souhaite réinitialiser. On peut réinitialiser :<br />
<br />
- la flash (boot0 à 0) : mémoire non volatile pour le code principal. Adresse : 0x0800 0000 - 0x0801 FFFF d'après le memory mapping (p43/142).<br />
<br />
- la ROM - Read Only Memory (boot0 à 1 et boot1 à 0) : mémoire non volatile que l'on change rarement sauf si besoin de changer mode communication par exemple (passage en spi, uart ...). Adresse : 0x1FFF 0000 - 0x1FFF 77FF.<br />
<br />
- la SRAM - Static Random Access Memory (boot0 à 1 et boot1 à 1) : mémoire volatile pour le débogage. Adresse : 0x2000 0000 - 0x2000 7FFF.<br />
<br />
On a aussi le pin NRST (Not Reset car actif à l'état bas) pour réinitialiser le microcontrôleur.<br />
<br />
====== Switchs ======<br />
On a 3 switchs qui peuvent servir pour choisir les modes de boot ?. [PRECISER UTILITE]<br />
<br />
====== Communication ======<br />
On a prévu différents types de communications selon les utilisations : SPI pour les cartes filles mais aussi UART et I2C amélioré si besoin pour une potentielle carte FPGA.<br />
<br />
====== Cartes filles ======<br />
On a prévu de la place pour 5 cartes filles, sans compter la carte mémoire et la carte FPGA potentielle.<br />
<br />
====== Leds ======<br />
3 leds supplémentaires ont étés ajoutées pour différents tests, utile pour l'ordonnanceur potentiellement par exemple.<br />
<br />
====== JTAG et SWD ======<br />
Le bloc JTAG sert pour le débogage de la carte. Ici sur le stm32, c'est combiné à un deuxième mode de débogage spécifique aux stm32 : le SWD, une version simplifiée de JTAG.<br />
<br />
JTAG (Joint Test Action Group) :<br />
<br />
* TCK : Test Clock, l'horloge du JTAG<br />
* TMS : Test Mode Select<br />
* TDI : Test Data In pour envoyer des données depuis le JTAG au microcontrôleur.<br />
* TDO : Test Data Out pour envoyer des données depuis le microcontrôleur au JTAG.<br />
* RTCK : Return Test Clock<br />
<br />
SWD (Serial Wire Debug) :<br />
<br />
* SWCLK : comme TCK<br />
* SWDIO : comme TMS<br />
* SWO : comme TDO<br />
<br />
===== Cartes filles =====<br />
Notre carte mère peut acceuillir 5 cartes filles communicantes en SPI parmi lesquelles : <br />
<br />
* carte clavier<br />
* carte écran<br />
* carte réseau<br />
* carte son<br />
* une autre carte<br />
<br />
Et en plus de cela, on a aussi la carte "fille" pour la gestion de la mémoire = le boîtier SD (en SPI également) ainsi que la carte fille FPGA ou d'autre cartes qui peuvent communiquer en UART ou I2C amélioré (car SMBA).[[Fichier:Mere schematique.pdf|left|600px|alt=Mere schematique|vignette|Mere schematique]]<br />
<p style="clear: both;" />Remarque : pour voir les différentes pages de la schématique, cliquer sur le fichier.<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Carte mere 3D.png|left|650px|alt=Carte mere 3D|vignette|Carte mere 3D]]<br />
[[Fichier:Carte mere 3D backside.png|right|650px|alt=Carte mere 3D backside|vignette|Carte mere 3D backside]]<br />
<p style="clear: both;" /><br />
<br />
=== Software ===<br />
<br />
==== NUCLEO-F410RB ====<br />
En attendant de recevoir notre carte mère et afin de prendre en main la programmation quelque peu spécifique des arm, on s'entraîne sur la carte NUCLEO-F410RB qui possède le même microcontrôleur STM32F410R8T6 que celui de notre carte mère. <br />
<br />
===== Spécifications =====<br />
La carte NUCLEO-F410RB est "séparée" en deux parties : <br />
<br />
* la partie haute de la carte : c'est le programmateur spécifique à STM32 nommé ST-LINK qui permet de programmer :<br />
* la partie basse de la carte : qui est elle dédiée à l'utilisateur.<br />
<br />
===== STM32CubeIDE =====<br />
<br />
====== Test led ======<br />
Pour commencer à comprendre, on utilise dans un premier temps l'IDE STM32CubeIDE dont l'on se passera ensuite afin d'être proche du matériel et de ne pas passer par plein de librairies.<br />
Dans notre fichier nucleo.ioc, on a toutes les spécifications de notre carte dont le pinout.<br />
Premier programme test : on fait clignoter la led LD2. On voit sur le fichier nucleo.ioc que LD2 est sur le pin PA5 du microcontrôleur.<br />
En allant dans l'arborescence à gauche, on va dans Core -> Src -> main.c.<br />
On ouvre le main et dans la boucle while, on va faire clignoter notre led D2 grâce à la librairie HAL (Hardware Abstraction Layer) dont l'on se passera par la suite (c'est juste pour les premiers tests).<syntaxhighlight lang="c"><br />
while (1)<br />
{<br />
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); //change d'état<br />
HAL_Delay(500); //attend 500ms<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Nucleo clignote.mp4|center|500px|vignette|nucleo_clignote]]<br />
<p style="clear: both;" /><br />
<br />
===== Sans IDE =====<br />
<br />
====== Test led ======<br />
Après avoir testé le code dans l'IDE, on va maintenant coder avec moins de librairies subsidiaires avec juste les fichiers utiles pour la puce STM32F410RB que l'on va chercher sur le site de STMicroelectronics .<br />
<br />
On va dans la catégorie Tools et software : https://www.st.com/en/microcontrollers-microprocessors/stm32f410rb.html#tools-software. <br />
<br />
On pourrait sélectionner directement l'evaluation tools de la nucleo mais ce n'est pas l'objectif ici puisque la nucleo nous permet juste de s'entraîner sur le microcontrôleur F410 le temps que l'on recoive notre carte. Donc on va plutôt télécharger STM32CubeF4.<br />
<br />
Suite à cela, on ajoutera différents fichiers :<br />
<br />
# stm32cubef4-v1-28-3 : le firmware de STMicroelectronics<br />
# main.c : code principal<br />
# main.h <br />
# ordonnanceur.c : uniquement pour l'ordonnanceur, le main.c gère le reste, les différents fichiers et variables à inclure<br />
# ordonnanceur.h <br />
# un makefile : pour compiler notre projet et les fichiers du firmware. On compile avec arm-none-eabi-gcc. On rajoute les chemins d'accès nécéssaires à la compilation du main.h qui a besoin du fichier stm32f410rx.h. On a également besoin du fichier core_cm4.h, d'où le second chemin : INCLUDES = -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Include \ -Istm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Include <br />
# un fichier nommé linker.ld : à la différence des atmega, notre microcontrôleur a une organisation mémoire plus complexe donc ce fichier nous permet de choisir où placer chaque type de données (cf les sections elf) dans la mémoire du microcontrôleur. On y précise la taille de la flash : 128ko et la taille de la RAM : 32 ko ainsi que leurs adresses trouvées page 40/763 de la datasheet. On y initialise également les sections .text (le code), .data (variables initialisées) et .bss (variables non initialisées).<br />
# un fichier startup_stm32f410rx.s : un fichier assembleur qui gère les interruptions, les resets, l'initialisation des données que l'on copie colle depuis /stm32/stm32cubef4-v1-28-3/STM32Cube_FW_F4_V1.28.0/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc. Remarque sur ce qu'est thumb : sur notre stm32, on utilise ARM et thumb 2 dont le rôle est d'avoir un code plus compact en mélangeant des instructions à la fois de 16 et 32 bits.<br />
<p style="clear: both;" /><p style="clear: both;" />Remarque : commande à taper quand la carte "fail to connect" : <syntaxhighlight lang="c"><br />
st-flash --connect-under-reset erase<br />
</syntaxhighlight><br />
<br />
====== Ordonnanceur ======<br />
Il faut également faire l'ordonnanceur que l'on doit maintenant adapter non plus au shield et aux avr mais à la carte mère et aux arm.<br />
<br />
* ordonnanceur.h :<br />
<br />
On y ajoute les librairies et la liste des fonctions implémentées dans ordonnanceur.c<br />
<br />
* ordonnanceur.c :<br />
<br />
On y implémente des fonctions pour les leds, le minuteur, la communication série.<br />
<br />
# leds : fonctions pour allumer, éteindre et faire clignoter (exemple de tâche).<br />
# minuteur : pour pouvoir effectuer une tâche pendant un certain temps.<br />
# communication série (deuxième exemple de tâche). Commande minicom à taper dans le terminal (-o permet d'éviter que mincom envoie des commandes d'initialisation) : <br />
<syntaxhighlight lang="c"><br />
sudo minicom -D /dev/ttyACM0 -b 9600 -o<br />
</syntaxhighlight>[[Fichier:Minicom2.png|center|500px|alt=Minicom_|vignette|Minicom_]]<br />
<p style="clear: both;" /><br />
<br />
== Carte fille Clavier ==<br />
=== Boutons utilisés ===<br />
Nous voulions implémenter un clavier à touche mécanique. Monsieur Xavier REDON avait des switchs qui convenait donc nous n'avions pas besoin d'en recommander. <br />
<br />
Les switchs sont de la marque KAILH :<br />
[[Fichier:Boite Kailh Switch.jpg|centré|vignette|Boite Kailh Switch]]<br />
[[Fichier:Kailh Hot swap socket.png|gauche|vignette|Kailh Hot swap socket]]<br />
[[Fichier:Bouton kailh comparaison hot swap.jpg|vignette|300x300px|Bouton kailh comparaison hot swap socket]]<br />
<br />
<br />
<br />
<br />
Petit bémol : les '''sockets hot-swap''' ne correspondaient pas à nos boutons. Comme on peut le voir sur la photo, il existe '''deux types de sockets''' pour nos modules hot-swap. Nous avons donc dû commander les modèles adaptés.<br />
<br />
L’intérêt de ces modules est de '''pouvoir insérer ou retirer les boutons à volonté''', sans qu’ils soient soudés directement au PCB — ce sont les sockets qui, eux, sont soudés. Cette solution présente plusieurs avantages : elle '''facilite la réutilisation des boutons''' d’un projet à un autre et '''améliore la réparabilité''' du clavier.<br />
<br />
<br />
<br />
<br />
<br />
==== Concevons un clavier ! ====<br />
Notre clavier doit comporter '''62 touches''', conformément au '''format standard ISO 60 %''', et sera capable d’'''assurer l’ensemble des combinaisons de touches attendues pour un clavier moderne en 2025'''.<br />
<br />
Afin de customiser notre clavier, on se rend sur le site [https://www.keyboard-layout-editor.com/#/ keyboard-layout-editor] .<br />
<br />
Nous pouvons partir d'un modèle de base ou alors d'un preset :<br />
[[Fichier:Site keyboard layout .png|centré|vignette|534x534px|Site keyboard layout preset ISO 60%]]<br />
<br />
<br />
Nous nous sommes alors inspirés des '''claviers disponibles sur le marché''' afin d’adopter un placement des touches conforme aux dispositions les plus courantes.<br />
[[Fichier:Keyboard-layout.jpg|centré|vignette|575x575px|Keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />L’utilisation de cet outil présente plusieurs intérêts : elle permet d’'''imaginer et définir la disposition du clavier''', de '''le découper en lignes et colonnes''' afin de concevoir la '''matrice de touches''', et enfin d’'''identifier les bonnes empreintes''' à utiliser sur le futur PCB grâce au '''sommaire illustré ci-dessous'''.<br />
[[Fichier:Summary keyboard layout.png|centré|vignette|399x399px|Summary keyboard layout]]<br />
<p style="clear: both;" /><p style="clear: both;" />Ce sommaire indique la '''taille indicative de chaque type de touche''' ainsi que '''le nombre de touches associées''' à chacune d’elles.Le "coloriage" est utile pour voir visuellement quelle touche correspond à quelle taille.<br />
<br />
==== Kicad - Schématique Notre carte fille comporte plusieurs éléments : ====<br />
# Le microcontrôleur ATMega32U4 avec un cristal de 16 MHz, des capacités de découplage et une ferrite (Cf AVR042) ;<br />
# L'USB pour la programmation et l'alimentation pendant la phase programmation du projet ;<br />
# Le connecteur ISP ;<br />
# Les boutons RST et HWB ;<br />
# Le connecteur SPI pour la communication avec la carte mère ;<br />
# La led pour l'alimentation de la carte ;<br />
# La led pour l'état du clavier (rôle ?) ;<br />
# La matrice de touches évidemment ;<br />
# Des mounting holes.<br />
<br />
Remarque : Pas de leds RGB, pas assez de pins et nous ne voulions pas nous éparpiller sur trop d'idées (sujet evoquer avec M Boé).<br />
<br />
[[Fichier:Clavier schematique.pdf|center|700px|alt=Clavier schematique|vignette|Clavier schematique]]<br />
<br />
==== Vue 3D ====<br />
[[Fichier:Keyboard 3D up v2.png|gauche|vignette|652x652px|Keyboard 3D up]]<br />
[[Fichier:Keyboard 3D back v2.png|vignette|649x649px|Keyboard 3D back]]<br />
<p style="clear: both;" /><br />
<br />
== Carte Fille FPGA ==<br />
On a prévu de faire une carte fille FPGA mais ceci n'est pas notre projet principal, on commande la carte et on espère avoir le temps d'avancer sur le code de cette carte, le code pour la carte mère restant prioritaire. M. Boé nous a dit qu'on pourrait continuer au s8 si besoin.<br />
<p style="clear: both;" /><br />
<br />
=== Hardware ===<br />
<br />
==== Puce FPGA ====<br />
Puce utilisée : XC7A15T-1FTG256C<br />
<p style="clear: both;" /><br />
<br />
==== Datasheets ====<br />
La carte FPGA étant complexe, nous avons beaucoup de datasheets donc plutôt que de les ajouter une par une, nous vous conseillons d'aller directement dans l'onglet concerné de notre git : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet .<br />
<br />
Certains extraits de ces datasheets illustrent bien comment concevoir notre schématique. Les images sont ici : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA ou décrites plus bas dans le wiki.<br />
<p style="clear: both;" /><br />
<br />
==== Conception ====<br />
<br />
===== Puce =====<br />
La puce FPGA étant assez complexe, elle ne peut être représentée en une seule entité sous kicad, elle est donc décomposée dans les unités suivantes : <br />
<br />
* U1A dans la sheet FPGA_Banks_14-15<br />
* U1B dans la sheet FPGA_Banks_34-35<br />
* U1C dans la sheet FPGA_Config<br />
* U1D dans la sheet FPGA_Power<br />
<p style="clear: both;" /><br />
<br />
===== Liste des sheets =====<br />
<br />
# Sheet principale FPGA<br />
# FPGA_Banks_14-15<br />
# FPGA_Banks_34-35<br />
# FPGA_Config<br />
# FPGA_Power<br />
# LEDs&7seg<br />
# Switch&Button<br />
# VGA<br />
# HDMI<br />
# Ethernet<br />
<p style="clear: both;" /><br />
<br />
===== Description des sheets =====<br />
<br />
====== Sheet principale FPGA ======<br />
<br />
* Ajout de 4 mounting holes si l'on veut fixer la carte quelque part ou la protéger de la poussière avec une plaque en verre.<br />
<p style="clear: both;" /><br />
<br />
<br />
====== FPGA_Banks_14-15 ======<br />
On a deux sources de tension PWR_BANK_14 et PWR_BANK_15. Pour chacune de ces sources, on ajoute :<br />
<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF <br />
* 4 capacités de découplage de 0,47 uF <br />
Ces valeurs proviennent de la page 15 de la datasheet UG483 (voir capture DecouplingInfo ci-dessous) :[[Fichier:DecouplingInfo.png|left|500px|alt=DecouplingInfo|vignette|DecouplingInfo]]<br />
<p style="clear: both;" /><br />
<br />
====== FPGA_Banks_34-35 ======<br />
On a deux sources de tension PWR_BANK_34 et PWR_BANK_35. Pour chacune de ces sources, tout comme pour la sheet FPGA_Banks_14-15, on ajoute :<br />
* 1 capacité de découplage de 100 uF<br />
* 2 capacités de découplage de 4,7 uF<br />
* 4 capacités de découplage de 0,47 uF<br />
Ces données proviennent également de la capture DecouplingInfo.<br />
<br />
====== FPGA_Config ======<br />
Différents blocs :<br />
<br />
# Sur l'unité U1C, on ajoute une capacité de 47 uF (cf image DecouplingInfo de la section FPGA_Banks_14-15). <br />
# Bloc JTAG : un connecteur 2*6 pins pour la programmation (pins TMS, TCK, TDO, TDI). Se reférer à JTAG de la carte mère pour explications.<br />
# USB Programming : FT32H : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FT232H.pdf. On ajoute différentes capacités de découplage, ferrites et un quartz (regarder pages 43/61).<br />
# USB C : diode de protection PGB1010603MR et résistance pour protéger de l'ESD (ElectroStatic Discharge) - https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/ESDPROTECTION_PGB1010603MR.pdf<br />
# FPGA Configuration Modes : 3 connecteurs de 1*3 pins pour les 3 modes de configuration du FPGA (cf image ci-dessous de la page 17 de la datasheet UG470 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug470_7Series_Config.pdf).<br />
[[Fichier:ConfigMode.png|left|500px|alt=ConfigMode|vignette|ConfigMode]]<p style="clear: both;" /><br />
<br />
====== FPGA_Power ======<br />
On a 4 sources d'alimentation :<br />
<br />
# VCCAUX : Auxiliary voltage (tension auxiliaire), alimente circuits internes non critiques en puissance.<br />
# VCCINT : Internal core voltage (tension interne du cœur logique), alimente la logique principale du FPGA (LUTs, Flip-flops).<br />
# VCCADC/BATT : <br />
#* VCCADC : tension pour le module ADC si le FPGA en a un.<br />
#* VBATT : alimenter registres de configuration non volatiles ou horloge temps réel.<br />
# VCCBRAM : Block RAM, alimente les blocs mémoire. Cela permet de séparer l’alimentation de la mémoire afin de réduire le bruit.<br />
Valeurs issues de :<br />
<br />
* Pour toutes les sources, se réferer à DecouplingInfo pour les valeurs des capacités de découplage (datasheet UG483 p15) sauf pour VCCADC/VBATT (regarder XADC_DecouplingCapa page 65 de la datasheet UG480 : https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/FPGA_ug480_7Series_XADC.pdf). Capture présente ci-dessous.<br />
* Et pour les valeurs des alimentations, regarder AlimRecommande (extrait de la datasheet DS181 pages 2 et 3) ci-dessous.<br />
<br />
[[Fichier:AlimRecommande.png|left|500px|alt=AlimRecommande|vignette|AlimRecommande]]<br />
[[Fichier:XADC DecouplingCapa.png|right|600px|alt=XADC DecouplingCapa|vignette|XADC DecouplingCapa]]<br />
<p style="clear: both;" /><br />
<br />
====== LEDs&7seg ======<br />
<br />
* Leds : on ajoute 4 leds avec des résistances de 330 Ω.<br />
* Afficheur 7 segments : TDCG1050M (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/7SEG_VISH-S-A0004391181-1.pdf). <br />
*# Cathodes : reliés à des résistances de 60 Ω.<br />
*#* Cathodes A à G et DP pour les 7 segments et le point.<br />
*#* Cathodes L1L2 et L3.<br />
*#Anodes : reliées à des transistors PNP BC807 (https://gitea.plil.fr/ahouduss/SE4-Pico-B6/src/branch/master/01-Kicad/Recherche%20FGPA/Datasheet/TRANSISTOR-PNP_SBC807-25LT1G.pdf) par le biais d'une résistance de 5,1 kΩ.<br />
*#*Anodes D1 à D4 pour allumer les 4 chiffres.<br />
*#*Anodes L2L2 et L3 <br />
[[Fichier:Afficheur fpga.png|left|500px|alt=afficheur_fpga|vignette|afficheur_fpga]]<br />
<p style="clear: both;" /><br />
<br />
====== Switch&Button ======<br />
<br />
* Switchs : 4 switchs SPDT - Single Pole Double Throw pour choisir 3V3 ou la masse par le biais de l'entrée, reliée à une résistance de 10 kΩ.<br />
* 5 boutons avec 2 résistances de 10 kΩ pour protéger si un court-circuit venait à arriver.<br />
<br />
====== VGA ======<br />
Depuis le TP avec M. Wichmann, on comprend un peu mieux la norme vidéo VGA (Video Graphics Array). On sait donc que le VGA possède 5 sorties : <br />
<br />
* 3 sorties pour les leds RVB de l'écran : VGA_RED, VGA_BLUE, VGA_GREEN. Chacune de ces sorties est sur 4 bits et la conversion DAC s'effectue à l'aide d'une échelle de résistance de 500Ω, 1k, 2k puis 4k (cf cours CNSPS).<br />
* 2 sorties pour les signaux de synchronisations horizontal et vertical : VGA_H-SYNC et VGA_V-SYNC reliés à des résistances de 100Ω.<br />
<br />
On rajoute également une capcité de découplage de 1nF en parallèle avec une résistance de 1M pour le shield.<br />
<br />
====== HDMI ======<br />
<br />
<p style="clear: both;" />Connecteur HDMI (High-Definition Multimedia Interface) si on a le temps pour programmer sur plus moderne que le VGA.<br />
<br />
<p style="clear: both;" /><br />
<br />
====== Ethernet ======<br />
Utilisation d'un port RJ45<p style="clear: both;" /></div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Keyboard_3D_back_v2.png&diff=8328Fichier:Keyboard 3D back v2.png2025-10-28T23:20:36Z<p>Cpayet : </p>
<hr />
<div>Keyboard 3D back v2</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Keyboard_3D_up_v2.png&diff=8327Fichier:Keyboard 3D up v2.png2025-10-28T23:19:57Z<p>Cpayet : </p>
<hr />
<div>Keyboard 3D up v2</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Summary_keyboard_layout.png&diff=8326Fichier:Summary keyboard layout.png2025-10-28T23:06:42Z<p>Cpayet : </p>
<hr />
<div>Summary keyboard layout</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Keyboard-layout.jpg&diff=8325Fichier:Keyboard-layout.jpg2025-10-28T22:59:08Z<p>Cpayet : </p>
<hr />
<div>Keyboard-layout</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Site_keyboard_layout_.png&diff=8324Fichier:Site keyboard layout .png2025-10-28T22:50:39Z<p>Cpayet : </p>
<hr />
<div>Site keyboard layout</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Tuto_site_keyboard_layout.png&diff=8323Fichier:Tuto site keyboard layout.png2025-10-28T22:49:38Z<p>Cpayet : </p>
<hr />
<div>Tuto site keyboard layout</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Bouton_kailh_comparaison_hot_swap.jpg&diff=8322Fichier:Bouton kailh comparaison hot swap.jpg2025-10-28T22:43:20Z<p>Cpayet : </p>
<hr />
<div>Bouton kailh comparaison hot swap</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Kailh_Hot_swap_socket.png&diff=8321Fichier:Kailh Hot swap socket.png2025-10-28T22:38:48Z<p>Cpayet : </p>
<hr />
<div>Kailh Hot swap socket</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Boite_Kailh_Switch.jpg&diff=8320Fichier:Boite Kailh Switch.jpg2025-10-28T22:36:38Z<p>Cpayet : </p>
<hr />
<div>Boite Kailh Switch</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8062SE3Groupe2024-22025-06-15T23:13:03Z<p>Cpayet : /* Affichage */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de programmer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par le capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs.<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le '''capteur de mouvement HC-SR501''' est un '''capteur infrarouge''' passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la '''quantité d’infrarouge''' captée change '''entre les deux cellules''', '''créant un déséquilibre'''. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
[[Fichier:LentilleFresnel.png|centré|vignette|Lentille Fresnel du capteur de mouvement]]<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<br />
<br />
Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C (le [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29/ds18b20.c fichier .c] et le [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29/ds18b20.h fichier .h]).<br />
<br />
<u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles à la communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir notre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette partie n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer sur l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublié de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permet également de tester les cartes aen cas de dysfonctionnement, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module. <br />
<br />
<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
Ce code permet de faire un Hello World. Il à été nettoyé au préalable. Il est également disponible [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/CapteurHumidite_ET_NRF/Lufa/SE/HelloWorld dans ce repertoire].<syntaxhighlight lang="c"><br />
#include "VirtualSerial.h"<br />
<br />
static CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 0,<br />
.CharFormat = CDC_LINEENCODING_OneStopBit,<br />
.ParityType = CDC_PARITY_None,<br />
.DataBits = 8 };<br />
<br />
int main(void)<br />
{<br />
SetupHardware();<br />
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);<br />
GlobalInterruptEnable();<br />
<br />
for (;;)<br />
{<br />
CDC_Task();<br />
USB_USBTask();<br />
}<br />
}<br />
<br />
void SetupHardware(void)<br />
{<br />
MCUSR &= ~(1 << WDRF);<br />
wdt_disable();<br />
clock_prescale_set(clock_div_1);<br />
<br />
USB_Init();<br />
}<br />
<br />
void EVENT_USB_Device_Connect(void)<br />
{<br />
LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);<br />
}<br />
<br />
void EVENT_USB_Device_Disconnect(void)<br />
{<br />
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);<br />
}<br />
<br />
void EVENT_USB_Device_ConfigurationChanged(void)<br />
{<br />
bool ConfigSuccess = true;<br />
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, 1);<br />
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_TX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);<br />
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_RX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);<br />
LineEncoding.BaudRateBPS = 0;<br />
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);<br />
}<br />
<br />
void EVENT_USB_Device_ControlRequest(void)<br />
{<br />
switch (USB_ControlRequest.bRequest)<br />
{<br />
case CDC_REQ_GetLineEncoding:<br />
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))<br />
{<br />
Endpoint_ClearSETUP();<br />
Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(LineEncoding));<br />
Endpoint_ClearOUT();<br />
}<br />
break;<br />
case CDC_REQ_SetLineEncoding:<br />
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))<br />
{<br />
Endpoint_ClearSETUP();<br />
Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(LineEncoding));<br />
Endpoint_ClearIN();<br />
}<br />
break;<br />
case CDC_REQ_SetControlLineState:<br />
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))<br />
{<br />
Endpoint_ClearSETUP();<br />
Endpoint_ClearStatusStage();<br />
}<br />
break;<br />
}<br />
}<br />
<br />
void CDC_Task(void)<br />
{<br />
// Vérifie si le périphérique USB est bien configuré avant de continuer<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Chaîne de caractères à envoyer sur la liaison série USB<br />
char msg[] = "Hello world\r\n";<br />
<br />
// Sélectionne l'endpoint d'envoi (TX) pour préparer l'envoi de données<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
<br />
// Écrit le message dans le buffer de l'endpoint USB, en mode Little Endian<br />
Endpoint_Write_Stream_LE(msg, sizeof(msg)-1, NULL);<br />
<br />
// Vérifie si le buffer de l'endpoint est plein après l'écriture<br />
bool full = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
<br />
// Vide (envoie) le contenu du buffer IN vers l'hôte<br />
Endpoint_ClearIN();<br />
<br />
// Si le buffer était plein, attend que l'endpoint soit prêt pour un autre envoi<br />
if (full)<br />
{<br />
// Attend que l'endpoint soit prêt pour un nouvel envoi (acknowledgement de l'hôte)<br />
Endpoint_WaitUntilReady();<br />
<br />
// Vide de nouveau le buffer pour s'assurer que tout est bien envoyé<br />
Endpoint_ClearIN();<br />
}<br />
<br />
// Sélectionne l'endpoint de réception (RX) pour traiter d'éventuelles données entrantes<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
<br />
// Si des données ont été reçues par l'hôte on vide le buffer<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
<br />
// Pause de 300 ms pour ralentir l'exécution de la tâche (évite les envois en boucle trop rapides)<br />
_delay_ms(300);<br />
}<br />
<br />
<br />
</syntaxhighlight>Nous n'avons pas réussi à souder notre NRF, malheuresmeent le code avec celui ne fonctionnera donc pas. Le code avec NRF sera fait avec un Arduino Uno et UART comme l'atmega328p ne supporte pas la LUFA.<br />
<br />
Voici tout de même une piste qui pourrait fonctionner : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/CapteurHumidite_ET_NRF/Lufa/SE/VirtualSerial<br />
<br />
=== '''Docker''' ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== '''Node-RED''' ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre site final :<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== '''Récupération ID microcontroleur''' ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8060SE3Groupe2024-22025-06-15T21:40:02Z<p>Cpayet : /* Énergie */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de programmer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par le capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs.<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le '''capteur de mouvement HC-SR501''' est un '''capteur infrarouge''' passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la '''quantité d’infrarouge''' captée change '''entre les deux cellules''', '''créant un déséquilibre'''. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
[[Fichier:LentilleFresnel.png|centré|vignette|Lentille Fresnel du capteur de mouvement]]<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<br />
<br />
Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C (le [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29/ds18b20.c fichier .c] et le [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29/ds18b20.h fichier .h]).<br />
<br />
<u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles à la communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir notre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette partie n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer sur l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublié de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permet également de tester les cartes aen cas de dysfonctionnement, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module. <br />
<br />
<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
[[Fichier:DatahsheetPbLUFA1.png|centré|vignette|632x632px|Extrait datasheet numéro 1 relevant le problème de quartz ]]<br />
[[Fichier:Extrait datasheet v2.png|centré|vignette|406x406px|Extrait datasheet numéro 2 relevant la configuration de l'USB où l'on est ]]<br />
Probablement des fuses à changer pour pouvoir<br />
<br />
=== '''Docker''' ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== '''Node-RED''' ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre site final :<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== '''Récupération ID microcontroleur''' ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Extrait_datasheet_v2.png&diff=8059Fichier:Extrait datasheet v2.png2025-06-15T21:32:37Z<p>Cpayet : </p>
<hr />
<div>Extrait datasheet v2</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:DatahsheetPbLUFA1.png&diff=8058Fichier:DatahsheetPbLUFA1.png2025-06-15T21:24:43Z<p>Cpayet : </p>
<hr />
<div>DatahsheetPbLUFA1</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LentilleFresnel.png&diff=8057Fichier:LentilleFresnel.png2025-06-15T21:04:42Z<p>Cpayet : </p>
<hr />
<div>l</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8056SE3Groupe2024-22025-06-15T20:56:34Z<p>Cpayet : /* LUFA */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de programmer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par cle capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs..<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le capteur de mouvement HC-SR501 est un capteur infrarouge passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la quantité d’infrarouge captée change entre les deux cellules, créant un déséquilibre. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<p style="clear: both;" />Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C.<p style="clear: both;" /><u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles àla communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<br />
<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir ntre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette parti n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer su l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublier de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permettait également de tester les cartes au cas où celles-ci dysfonctionnaient, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module.<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
'''<u>Gestion de la puissance</u>'''<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
<br />
=== '''Docker''' ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== '''Node-RED''' ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== '''Récupération ID microcontroleur''' ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8055SE3Groupe2024-22025-06-15T20:53:38Z<p>Cpayet : /* LUFA */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de prgrammer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par cle capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs..<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le capteur de mouvement HC-SR501 est un capteur infrarouge passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la quantité d’infrarouge captée change entre les deux cellules, créant un déséquilibre. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<p style="clear: both;" />Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C.<p style="clear: both;" /><u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles àla communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<br />
<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir ntre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette parti n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer su l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublier de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permettait également de tester les cartes au cas où celles-ci dysfonctionnaient, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module.<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
'''<u>Gestion de la puissance</u>'''<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
<br />
=== Docker ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== Node-RED ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== Récupération ID microcontrôleur ======<br />
Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8054SE3Groupe2024-22025-06-15T20:48:31Z<p>Cpayet : /* Docker */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de prgrammer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par cle capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs..<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le capteur de mouvement HC-SR501 est un capteur infrarouge passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la quantité d’infrarouge captée change entre les deux cellules, créant un déséquilibre. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<p style="clear: both;" />Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C.<p style="clear: both;" /><u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles àla communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<br />
<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir ntre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette parti n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer su l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublier de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permettait également de tester les cartes au cas où celles-ci dysfonctionnaient, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module.<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
'''<u>Gestion de la puissance</u>'''<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
<br />
=== Docker ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== Node-RED ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== Récupération ID microcontroleur ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8053SE3Groupe2024-22025-06-15T20:40:21Z<p>Cpayet : /* Communication */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de prgrammer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par cle capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs..<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le capteur de mouvement HC-SR501 est un capteur infrarouge passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la quantité d’infrarouge captée change entre les deux cellules, créant un déséquilibre. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<p style="clear: both;" />Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C.<p style="clear: both;" /><u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles àla communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<br />
<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir ntre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette parti n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer su l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublier de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permettait également de tester les cartes au cas où celles-ci dysfonctionnaient, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module.<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
'''<u>Gestion de la puissance</u>'''<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
<br />
=== '''Docker''' ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== '''Node-RED''' ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
[[Fichier:VideoDemoFinalv1.mp4|centré|vignette|Vidéo demonstration du projet fonctionnel]]<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== '''Récupération ID microcontroleur''' ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:VideoDemoFinalv1.mp4&diff=8052Fichier:VideoDemoFinalv1.mp42025-06-15T20:39:24Z<p>Cpayet : </p>
<hr />
<div>Video</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2024-2&diff=8051SE3Groupe2024-22025-06-15T20:29:09Z<p>Cpayet : /* LUFA */</p>
<hr />
<div>== Lien GIT ==<br />
Voici le lien git pour accéder aux différents fichiers relatifs à notre projet : https://gitea.plil.fr/ahouduss/se3_2024_B2.git<br />
<br />
== Description du projet ==<br />
<br />
=== Objectif ===<br />
L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins. <br />
<br />
=== Cahier des charges ===<br />
La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :<br />
* Température ambiante ;<br />
* Taux d'humidité ;<br />
* Présence humaine (via capteur de mouvement) ;<br />
* D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.<br />
<br />
Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :<br />
* L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;<br />
* D'autres dispositifs pourront être intégrés en fonction des besoins.<br />
<br />
Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux. <br />
<br />
=== Spécification techniques ===<br />
<br />
==== Microcontrôleur ====<br />
Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les ''GPIOs''. <br />
<br />
Nous avons le choix entre <u>plusieurs modèles de microcontrôleur</u> : '''ATmega16u4, AT90USB1286, AT90USB1287.'''<br />
<br />
Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :<br />
{| class="wikitable"<br />
|Caractéristiques<br />
|ATmega16U4<br />
|AT90USB1286<br />
|AT90USB1287<br />
|-<br />
|Architecture<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|AVR 8 bits<br />
|-<br />
|Mémoire Flash<br />
|16 KB<br />
|128 KB<br />
|128 KB<br />
|-<br />
|RAM (SRAM)<br />
|1.25 KB<br />
|4 KB<br />
|4 KB<br />
|-<br />
|EEPROM<br />
|512 Bytes<br />
|4 KB<br />
|4 KB<br />
|-<br />
|Fréquence d'horloge max.<br />
|16 MHz<br />
|16 MHz<br />
|16 MHz<br />
|-<br />
|Nombre de broches GPIO<br />
|26<br />
|48<br />
|48<br />
|-<br />
|Interfaces de communication<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|Contrôleur USB intégré<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|Oui (USB 2.0)<br />
|-<br />
|Taille des registres<br />
|8 bits<br />
|8 bits<br />
|8 bits<br />
|-<br />
|Nombre de broches<br />
|32<br />
|64<br />
|64<br />
|-<br />
|Différences principales<br />
|Conçu pour des applications compactes avec<br />
<br />
moins de mémoire et d'E/S<br />
|Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire<br />
|Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques<br />
<br />
pour certaines configurations USB (e.g., modes host/OTG).<br />
|-<br />
|Lien documentation<br />
|https://www.microchip.com/en-us/product/atmega16u4<br />
|https://www.microchip.com/en-us/product/at90usb1286<br />
|https://www.microchip.com/en-us/product/at90usb1287<br />
|}<br />
<br />
Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ). <br />
<br />
Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.<br />
{| class="wikitable"<br />
!Caractéristiques<br />
!ATmega32U4<br />
|-<br />
|'''Architecture'''<br />
|AVR 8 bits<br />
|-<br />
|'''Mémoire Flash'''<br />
|32 KB<br />
|-<br />
|'''RAM (SRAM)'''<br />
|2.5 KB<br />
|-<br />
|'''EEPROM'''<br />
|1 KB<br />
|-<br />
|'''Fréquence d'horloge max.'''<br />
|16 MHz<br />
|-<br />
|'''Nombre de broches GPIO'''<br />
|26<br />
|-<br />
|'''Interfaces de communication'''<br />
|UART, SPI, I²C, USB 2.0<br />
|-<br />
|'''Contrôleur USB intégré'''<br />
|Oui (USB 2.0)<br />
|-<br />
|'''Taille des registres'''<br />
|8 bits<br />
|-<br />
|'''Nombre de broches'''<br />
|32<br />
|-<br />
|'''Différences principales'''<br />
|Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires<br />
|}<br />
''Datasheet ATmega32u4 :''<br />
[[Fichier:Datasheet ATMEGA32U4.pdf|199x199px|vignette|Datasheet du microcontroleur : ATMEGA32U4|gauche]][[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<br />
<br />
<p style="clear: both;" /><br />
==== Communication ====<br />
La station utilisera une puce '''NRF24L01''' pour la communication sans fil entre les différents actionneurs et capteurs.<br />
<br />
La communication entre le pc et la station se fera quant à elle en USB.<br />
<br />
Lien tutoriel utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
''Datasheet NRF24L01 :''<br />
[[Fichier:Datasheet NRF24L01.pdf|200x200px|vignette|Datasheet module de communication : NRF24L01|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Énergie ====<br />
La station sera alimentée de manière hybride, selon les scénarios suivants :<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration avec affichage sur moniteur PC ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps).<br />
<br />
Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants :<br />
<br />
'''- Par un port USB''', pour la programmation, les tests et la configuration ;<br />
<br />
'''- Par une batterie Lithium''', en mode autonome pour son usage définitif.<br />
<br />
<u>Modèles de batterie à notre disposition :</u> <br />
<br />
* Batterie 3.7V 100 mAh, connecteur molex mâle ;<br />
* Batterie 3.7V 300 mAh, connecteur molex mâle ;<br />
<br />
<br />
Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants...<br />
<br />
Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte.<br />
<br />
<br />
<br />
''Datasheets du chargeur et du régulateur :''[[Fichier:Datasheet MAX1811.pdf|gauche|194x194px|vignette|Datasheet du chargeur : MAX1811]]<br />
<br />
*<br />
[[Fichier:Datasheet LTC3531.pdf|194x194px|vignette|Datasheet du régulateur : LTC3531|centré]]<br />
<p style="clear: both;" /><br />
<br />
==== Affichage ====<br />
Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).<br />
<br />
Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.<br />
<br />
''Datasheet de l'écran graphique utilisé :''<br />
<br />
[[Fichier:Datasheet NHD‐C12832A1Z‐FSW‐FBW‐3V3.pdf|194x194px|vignette|Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3|centré]]<br />
<p style="clear: both;" />On décide de prgrammer l'écran en C. On code donc notre écran via l'API "glcd.h".<br />
<br />
L'écran sera composé d'un menu permettant de naviguer parmi les différents capteurs enregistrés afin de consulter la valeur renvoyée par cle capteur choisi.<br />
<br />
Les boutons intégrés sur la carte ainsi que l'encodeur rotatif permettront à l'utilisateur de naviguer entre les différents capteurs..<p style="clear: both;" /><br />
<br />
==== Diverses ====<br />
La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.<br />
<p style="clear: both;" /><br />
<br />
== Hardware ==<br />
<br />
=== Schématique ===<br />
==== Notre schéma électrique ====<br />
[[Fichier:Kicad station .pdf|centré|vignette|Schéma électrique V1 KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Comprendre notre schéma ====<br />
[[Fichier:ComprendreSchematique.pdf|centré|vignette|Comprendre la schématique]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:Station vue 3D ARRIERE.png|gauche|vignette|Carte station en 3D - Vue arrière|461x461px]]<br />
[[Fichier:Station vue 3D AVANT.png|centré|vignette|Carte station en 3D - Vue avant|432x432px]]<br />
<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
<br />
<p style="clear: both;" /><br />
<br />
== Software ==<br />
<br />
=== <big>Capteurs</big> ===<br />
<br />
==== <big>Capteur de mouvement - HC-SR501</big> ====<br />
<br />
===== Principe physique =====<br />
Le capteur de mouvement HC-SR501 est un capteur infrarouge passif (PIR), ce qui signifie qu’il ne produit aucun rayonnement mais détecte celui émis naturellement par les objets chauds, notamment le corps humain.<br />
<br />
Ces deux cellules pyroélectriques sont disposées de manière à percevoir deux zones distinctes du champ de vision. En l'absence de mouvement, les deux reçoivent une quantité similaire d'infrarouge, et le signal reste équilibré. <br />
<br />
Lorsqu'un corps chaud passe devant le capteur, la quantité d’infrarouge captée change entre les deux cellules, créant un déséquilibre. Ce changement est interprété comme un mouvement.<br />
<br />
<br />
Un dôme en plastique blanc recouvre le capteur : c’est une lentille de Fresnel.<br />
<br />
Elle concentre et divise la lumière infrarouge en plusieurs zones, augmentant ainsi la portée et la sensibilité du capteur en "segmentant" son champ de vision. Ainsi, même un petit mouvement crée une variation significative de rayonnement perçu.<br />
<br />
===== Spécifications techniques =====<br />
On utilise un capteur de mouvement HC-SR501 (voir datasheet ci-dessous) afin de détecter ou non la présence de quelqu'un dans une pièce. L'intérêt est de pouvoir ensuite allumer la lumière si une personne est présente ou a contrario l'éteindre si la pièce est vide. Ici la lumière sera modélisée par une led présente sur l'arduino UNO en guise de démonstration. <br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Datasheet mvmt.pdf|alt=datasheet_mvmt|vignette|datasheet_mvmt]] <br />
[[Fichier:Mvmt.png|alt=mvmt|vignette|capteur_mvmt|479x479px|gauche]]<br />
<br />
<p style="clear: both;" /><br />
* Jumper Set<br />
<br />
Les deux modes, repeat ou single trigger, permettent de régler le trigger de schmith permettant la détection d'une présence. En single, on effectue un seul trigger afin de détecter spontanément une présence (ex : Cas alarme intrusion). <br />
<br />
Dans l'autre mode on souhaite détecter un mouvement peu importe si celui-ci est déjà détecter. Par exemple, besoin d'un mouvement après un certains nombre de temps pour que la led reste allumée ou bien besoin de réactiver de temps à autre le capteur en bougeant. <br />
<br />
* Sensitivty Adjust<br />
<br />
On modifie le potentiomètre à l'aide d'un tournevis afin d'ajuster la sensibilité à la présence de notre main, par exemple pour l'amplitude de nos mouvements. <br />
<br />
*Time Delay Adjust<br />
<br />
Ici le potentiomètre permet d'ajuster le temps entre deux seuils de détection afin d'éviter la détection après des mouvements parasites, par exemple pour déclencher sans erreur une alarme intrusion. <br />
<br />
===== Circuit =====<br />
On connecte le GND à la masse de l'arduino, le power au 5V et la sortie au pin PB0 (digital 8). Voir la vidéo de démonstration pour plus de détails.<br />
<br />
===== Programmation =====<br />
Voici le code afin d'allumer une led dès qu'une présence est détectée. <syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
int main(void) {<br />
DDRB |= (1 << PB5); //led D13 en sortie<br />
while (1) {<br />
if (PINB & (1 << PB0)) { //si mvmt<br />
PORTB |= (1 << PB5); //led allumée<br />
} else { //si absence<br />
PORTB &= ~(1 << PB5); //led éteinte<br />
}<br />
_delay_ms(500); // Peut être baisser ou augmenter pour regler la sensibilité de détection<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><br />
<p style="clear: both;" /><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la led s'allume lorsqu'une présence est détectée.<br />
[[Fichier:Capteur presence.mp4|centré|vignette|500px|Capteur presence]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules de communication radio (NRF24L01) afin d'afficher l'état de la pièce sur l'écran et également transmettre ces données via le port série.<br />
<p style="clear: both;" /><br />
<br />
==== <big>Capteur de température - DS18B20</big> ====<br />
<br />
===== Principe physique =====<br />
Ce capteur fonctionne grâce à un principe physique appelé '''variation de la résistance électrique avec la température'''. À l’intérieur du capteur, il y a un composant semi-conducteur, souvent une '''diode ou une jonction PN''', qui change son comportement électrique selon la température.<br />
<br />
Quand la température augmente, la façon dont les électrons se déplacent dans ce matériau change, ce qui modifie la tension ou le courant électrique mesuré.<br />
<br />
Un convertisseur analogique-numérique (CAN) est intégré au circuit afin de transferer par la suite la mesure via un protocole 1-Wire.<br />
<p style="clear: both;" /><br />
<br />
===== Spécifications techniques =====<br />
On utilise aussi le capteur de température DS18B20 (voir datasheet ci-dessous) afin de mesurer la température dans une matière tel que l'eau ou bien la terre (pour une piscine ou une plante par exemple).<br />
<br />
[[Fichier:Datasheet temp eau.pdf|alt=Datasheet_temp_eau|vignette|Datasheet_temp_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Circuit =====<br />
On branche les 3 broches de notre sonde de la manière suivante :<br />
<br />
* le GND est relié à la masse<br />
* le power est relié au 3,3V (peut également être relié sur le +5V si besoin)<br />
* le fil de données est branché sur un pin digital (valeur TOR) et ici sur PD2 (digital 2).<br />
<br />
On doit brancher une résistance de 4,7kΩ entre le fil de données et le 3,3V (ou +5V).[[Fichier:Capteur eau.jpg|alt=capteur_eau|vignette|capteur_eau|centré]]<br />
<p style="clear: both;" /><br />
<br />
===== Programmation =====<br />
<br />
====== Arduino ======<br />
Pour commencer, on a testé si notre sonde fonctionnait correctement à l'aide d'un code arduino et on a constaté aucun souci ([https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/Arduino Code Arduino]).<br />
====== C ======<br />
Dans le cadre de ce projet, nous sommes partis d’un code initialement fonctionnel développé sur Arduino, puis nous l’avons adapté à notre propre environnement en langage C, plus proche du matériel et sans dépendance aux bibliothèques Arduino. Pour cela, nous avons fusionné deux ressources trouvées sur GitHub afin d'obtenir une base de code cohérente, fonctionnelle et surtout structurée de manière à répondre à nos besoins techniques. <br />
<br />
Nous avons utilisé les fichiers disponibles dans le répertoire suivant : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/Capteurs/Temperature%20eau/1er%20code%20%28C%29 Code C] <br />
<br />
'''''<u>Protocole OneWire</u>''''' <br />
<br />
Le '''protocole OneWire''' est un protocole de communication série développé par '''Maxim Integrated'''. Il permet à un microcontrôleur de communiquer avec un ou plusieurs périphériques (comme des capteurs de température, EEPROM, etc.) via '''un seul fil de données''' (en plus du GND). Ce fil est '''bidirectionnel''' et transporte à la fois les données et l’horloge synchronisée par le maître (généralement le microcontrôleur). <br />
<br />
Ce protocole est particulièrement utilisé avec des capteurs qui mesurent la température et la transmettent sous forme numérique. Le principal avantage du OneWire est sa '''simplicité matérielle''' : un seul fil suffit pour communiquer avec plusieurs périphériques, chacun ayant une adresse unique codée en ROM.<br />
<br />
Ce [https://blog.domadoo.fr/guides/principe-du-protocole-1-wire/ lien/] est un tutoriel qui nous explique comment fonctionne le protocole OneWire et sur [https://kampi.gitbook.io/avr/1-wire-implementation-for-avr ce lien] on retrouve un exemple de code complet mais pour notre usage nous nous sommes limités aux fonctionnalités essentielles ( à savoir écriture et lecture pour un unique appareil connecté).<br />
<br />
<u>onewire.h, onewire.c </u>: pour remplacer la librairie OneWire.h de l'arduino afin de communiquer avec l'unique fil de données de la sonde en pure C. <br />
<br />
* onewireInit : reset le bus de données et renvoie une erreur si le capteur de répond pas.<br />
* onewireWriteBit : envoie un bit sur le bus de données en respectant le temps d'envoi du protocole Onewire.<br />
* onewireWrite : transmet un octet en utilisant la fonction précédente.<br />
* onewireReadbit : lit un bit sur le bus de données.<br />
* onewireRead : lit un octet sur le bus de données.<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Code de notre sonde de température</u>'''''<p style="clear: both;" />Nous avons étudier le fonctionnement de notre sonde de temperature via sa [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/Capteurs/DS18B20.pdf datasheet]. Nous nous sommes aidés de celle ci et de son code équivalent Arduino afin de pouvoir programmer une librairie en C.<p style="clear: both;" /><u>ds18b20.h, ds18b20.c</u> : pour les fonctions principales utiles àla communication entre notre sonde et notre microcontroleur.<br />
* ds18B20crc8 : CRC signifie cyclic redundacy check est l'octet renvoyé par cette fonction qui permet de savoir si la transmission s'est effectuée sans erreurs.<br />
* ds18b20match : utile si il y a plusieurs capteurs (pas le cas ici).<br />
* ds18b20convert : la valeur de la température est stockée sur les deux premiers octets de la mémoire scratchpad. ds18b20convert permet de convertir ces octets en degré celsius.<br />
* ds18b20rsp : lit le scratchpad (mémoire temporaire) pour récupérer la valeur de la température (sur les deux premiers octets).<br />
* ds18b20wsp : écrit dans le scratchpad.<br />
* ds18b20csp : copie les données du scratchpad dans l'eeprom du capteur.<br />
* ds18b20read : lit la température. <br />
* ds18b20rom : lit l'adresse du capteur rom (pas utile ici car un seul capteur).<br />
<br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>UART</u>'''''<br />
<br />
Cette partie à été codé uniquement pour le debug car l'usage de l'UART sera négligé plus tard. Effectivement le but final c'est d'avoir un périphérique USB complet donc à coder via la LUFA. Le port série virtuel USB (CDC) créé par LUFA est reconnu par la plupart des OS modernes sans besoin de drivers spécifiques. On aura alors un projet modulaire !<p style="clear: both;" /> <br />
<br />
<u>UART.h, UART.c</u> : pour afficher la température sur la liaison série. On définit deux fonctions : <br />
<br />
* USART_SendChar pour afficher un caractère sur le minicom. <br />
* USART_SendString pour afficher des mots sur le minicom. Rq : utiliser le retour chariot \r pour un affichage correct. <br />
<p style="clear: both;" /><p style="clear: both;" />'''''<u>Main</u>'''''<br />
<br />
<u>main.c</u> : pour le code principal<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
#include <avr/io.h><br />
#include <util/delay.h><br />
#include <stdio.h><br />
#include "UART.h"<br />
#include "ds18b20.h"<br />
<br />
#define DS18B20_DDR DDRD<br />
#define DS18B20_PORT PORTD<br />
#define DS18B20_PIN PIND<br />
#define DS18B20_MASK (1 << PD2)<br />
<br />
int main(void)<br />
{<br />
int16_t temperature_raw;<br />
char buffer[32];<br />
uint8_t error;<br />
<br />
USART_init(9600);<br />
USART_SendString("Debut lecture DS18B20...\r\n");<br />
<br />
while (1)<br />
{<br />
// Démarrer conversion<br />
error = ds18b20convert(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL);<br />
_delay_ms(800); // attendre la fin de conversion<br />
<br />
if (error != DS18B20_ERROR_OK) {<br />
USART_SendString("Erreur conversion\r\n");<br />
}<br />
else {<br />
<br />
// Lire la température<br />
error = ds18b20read(&DS18B20_PORT, &DS18B20_DDR, &DS18B20_PIN, DS18B20_MASK, NULL, &temperature_raw);<br />
if (error == DS18B20_ERROR_OK) {<br />
float temperature_celsius = temperature_raw / 16.0;<br />
snprintf(buffer, sizeof(buffer), "Temp: %.2f C\r\n", temperature_celsius);<br />
USART_SendString(buffer);<br />
} else {<br />
snprintf(buffer, sizeof(buffer), "Erreur lecture: %d\r\n", error);<br />
USART_SendString(buffer);<br />
}<br />
}<br />
_delay_ms(200);<br />
}<br />
return 0;<br />
}<br />
<br />
</syntaxhighlight><p style="clear: both;" />Dans notre fonction main :<br />
* on initialise la liaison série.<br />
<br />
* on convertit les octets de la mémoire du capteur en une température en degré celsius. <br />
* on lit la température afin de l'afficher dans le minicom. Pour cela, il faut au préalable convertir ntre température en flottant en des caractères avec une taille adaptée au buffer à l'aide de la fonction snprintf (string numbered print format).<br />
<br />
<br />
Le DS18B20 mesure la température avec une '''résolution de 0,0625 °C''', ce qui correspond à '''1/16 de degré Celsius'''. Si le capteur renvoyait directement la température en °C sous forme entière, il serait '''impossible d’exprimer des fractions précises''', comme 23,0625 °C.<br />
<br />
En utilisant une '''valeur entière (int16_t)''' codant des '''fractions binaires''', on peut :<br />
<br />
* Éviter les calculs en virgule flottante dans les systèmes embarqués (coûteux en ressources).<br />
* Avoir une grande précision avec un codage simple :<blockquote>1 bit de poids faible = 0,0625 °C → résolution sur 12 bits.</blockquote><br />
<br />
'''''<u>Makefile</u>''''' : <syntaxhighlight lang="makefile"><br />
CC = avr-gcc<br />
OBJCOPY = avr-objcopy<br />
SIZE = avr-size<br />
<br />
MCU = atmega328p<br />
FCPU = 16000000UL<br />
<br />
FLAGS = -mmcu=$(MCU) -Wl,-u,vfprintf -lprintf_flt -lm<br />
CFLAGS = -Wall $(FLAGS) -DF_CPU=$(FCPU) -Os<br />
LDFLAGS = $(FLAGS)<br />
<br />
PROGRAMMER = avrdude<br />
AVRDUDE_MCU = atmega328p<br />
AVRDUDE_PORT = /dev/ttyACM0 # À adapter<br />
AVRDUDE_BAUD = 115200<br />
AVRDUDE_PROGRAMMER = arduino<br />
<br />
TARGET = main<br />
SOURCES = $(wildcard *.c)<br />
OBJECTS = $(SOURCES:.c=.o)<br />
<br />
all: $(TARGET).hex<br />
<br />
clean:<br />
rm -f *.o $(TARGET).hex $(TARGET).elf eeprom.hex<br />
<br />
$(TARGET).elf: $(OBJECTS)<br />
$(CC) -o $@ $^ $(LDFLAGS)<br />
<br />
$(TARGET).hex: $(TARGET).elf<br />
$(OBJCOPY) -j .text -j .data -O ihex $< $@<br />
$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \<br />
--change-section-lma .eeprom=0 -O ihex $< eeprom.hex<br />
<br />
upload: $(TARGET).hex<br />
$(PROGRAMMER) -v -p $(AVRDUDE_MCU) -c $(AVRDUDE_PROGRAMMER) -P $(AVRDUDE_PORT) \<br />
-b $(AVRDUDE_BAUD) -D -U flash:w:$(TARGET).hex:i<br />
<br />
size: $(TARGET).elf<br />
$(SIZE) --format=avr --mcu=$(MCU) $<<br />
<br />
</syntaxhighlight><br />
<br />
===== Démonstration =====<br />
Voici le résultat en vidéo ci-dessous. On constate bien que la température affichée sur le minicom augmente lorsque la sonde reste longtemps dans la bouilloire chauffée au préalable.[[Fichier:Capteur temperature.mp4|centré|vignette|video capteur eau]]<br />
<p style="clear: both;" /><br />
<br />
Dans un second temps, on fera communiquer ce capteur avec notre carte station domotique par le biais des modules nrf24 afin d'afficher la température de la pièce sur l'écran.<br />
<p style="clear: both;" /><br />
<br />
=== <big>Actionneur</big> ===<br />
<br />
==== <big>Lumière</big> ====<br />
On peut décider d'allumer une lumière selon certains critères (par exemple lorsque le capteur de présence détecte quelqu'un). Ici allumer une led par exemple. Cette parti n'as pas encore été mise en place, faute de temps. Nous avons préférez avancer su l'écran avant tout.<br />
<br />
=== <big>Ecran</big> ===<br />
Pour offrir une interface utilisateur intuitive, nous avons décidé d’afficher sur un écran les données issues des capteurs ainsi que l’état des actionneurs. Par exemple, il doit être possible de visualiser la température d’une pièce ou la détection de présence en temps réel.<br />
<br />
Nous avons choisi d’utiliser un écran [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/99%20-%20Datasheets/ECRAN_NHD%E2%80%90C12832A1Z%E2%80%90FSW%E2%80%90FBW%E2%80%903V3.pdf '''NHD‐C12832A1Z‐FSW‐FBW‐3V3'''] '''(stock de M. Boé)'''. Initialement, nous avons tenté d’utiliser la bibliothèque graphique '''u8g2''', réputée pour sa compatibilité avec de nombreux écrans. Cependant, malgré plusieurs essais de programmes issus de cette bibliothèque, l’écran restait vierge sans aucune information affichée.<br />
<br />
Face à cette difficulté, nous avons décidé de simplifier notre approche en codant une instruction basique destinée à allumer l’ensemble des pixels de l’écran, en nous appuyant directement sur la datasheet du composant. Mais là encore, aucun résultat visible. <br />
<br />
Cette absence de réaction nous a conduit à suspecter un problème matériel lié à la communication entre le microcontrôleur et l’écran. Nous avons alors découvert que notre écran ne fonctionne pas en I2C, contrairement à ce que nous avions initialement supposé, mais bien en '''SPI'''. <br />
<br />
Pour corriger cela, nous avons modifié le câblage en coupant les pistes SDA et SCL (liées au bus I2C) puis connecté le pin SCL de l’écran au SCK du microcontrôleur, et le pin SI de l’écran au MOSI du microcontrôleur. <br />
[[Fichier:ModifPiste.jpg|centré|vignette|Modification de nos piste pour échnager avec l'écran|536x536px]] <br />
<br />
<br />
<br />
Malgré ces ajustements, l’écran restait toujours noir. Nous avons donc vérifié à l’oscilloscope la présence des signaux SPI transmis à l’écran, ce qui nous a confirmé que les données étaient bien envoyées. [[Fichier:Signaux SCL et MOSI.png|alt=signaux SCL et MOSI|centré|vignette|signaux SCL et MOSI|585x585px]]<br />
<br />
Nous avons ensuite affiné notre code d’initialisation de l’écran, notamment en veillant à éteindre l’affichage pendant la configuration, puis à le rallumer une fois les paramètres correctement envoyés. Voici un extrait de la fonction d’initialisation :<syntaxhighlight lang="c" line="1"><br />
void lcd_init() {<br />
lcd_reset();<br />
lcd_command(0xA0); // ADC select<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0xC8); // COM direction scan<br />
lcd_command(0xA2); // LCD bias set<br />
lcd_command(0x2F); // Power Control set<br />
lcd_command(0x21); // Resistor Ratio Set<br />
lcd_command(0x81); // Electronic Volume Command (set contrast) Double Btye: 1 of 2<br />
lcd_command(0x20); // Electronic Volume value (contrast value) Double Byte: 2 of 2<br />
lcd_command(0xA6); // Display normal (non inverser) <br />
lcd_command(0xAF); // Display ON <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Nous avions également oublier de désactiver le JTAG afin de pouvoir utiliser correctement le PORTF.<syntaxhighlight lang="c" line="1"><br />
MCUCR |= (1 << JTD);<br />
MCUCR |= (1 << JTD);<br />
</syntaxhighlight><br />
<br />
<br />
Nous avons également du allonger notre temps de delay pour notre fonction lcd_reset :<syntaxhighlight lang="c" line="1"><br />
void lcd_reset() {<br />
PORTF &= ~(1 << RESET);<br />
_delay_ms(200);<br />
PORTF |= (1 << RESET);<br />
_delay_ms(200);<br />
}<br />
</syntaxhighlight>Grâce à ces modifications, nous avons réussi à allumer un carré de pixels sur l’écran. Nous nous sommes renseigné pour afficher des objet plus complexe tel qu'un logo. Nous avons récuperer le logo et le code pour afficher une image sur [https://support.newhavendisplay.com/hc/en-us/articles/4415264814231-NHD-C12832A1Z-with-Arduino le site du constructeur].<br />
[[Fichier:Logo1.mp4|centré|vignette|Visualisation code écran avec logo]]<br />
<br />
<br />
<br />
'''<u>Affichage d'une image</u>'''<br />
<br />
Pour créer notre propre logo sous forme de tableau il faut s'aider de cette outil : https://javl.github.io/image2cpp/<br />
<br />
Voici la configuration à adopter pour exporter correctement sur notre écran :<br />
<br />
<u>''Image Settings''</u><br />
<br />
* Canvas size(s) = 128x32 (résolution de notre écran)<br />
<br />
* Background color : Black (afin de n’afficher aucune couleur car écran monochrome<br />
* Scaling : Scale to fit (pour redimensionner l’image selon nos nouvelles proportions)<br />
<br />
Les autres paramètres de la section Image Settings restent inchangés (à l’exception de Center image, qui reste une option de personnalisation).<br />
<br />
<u>''Output''</u><br />
<br />
* Code output format : plain bytes (pour obtenir uniquement les octets qui nous intéressent, on précisera nous-mêmes le type du tableau)<br />
* Draw mode : Vertical - 1 bit per pixel (l’écran utilise un système de pages pour écrire les pixels)<br />
<br />
[[Fichier:Logo2.mp4|centré|vignette|Visualisation code écran avec logo personnalisé]]<br />
<br />
Et voici la fonction permettant d'afficher une image :<syntaxhighlight lang="c"><br />
void DispPic(unsigned char* lcd_string)<br />
{<br />
unsigned char page = 0xB0;<br />
lcd_command(0xAE); // Display OFF<br />
lcd_command(0x40); // Display start address + 0x40 (base RAM écran)<br />
for (unsigned int i = 0; i < 4; i++) { // Parcourt les 4 pages<br />
lcd_command(page); // Envoie l'adresse de la page actuelle (0xB0 + i)<br />
lcd_command(0x10); // column address upper 4 bits + 0x10<br />
lcd_command(0x00); // column address lower 4 bits + 0x00<br />
for (unsigned int j = 0; j < 128; j++){ // Parcourt toutes les colonnes (128 colonnes)<br />
lcd_data(*lcd_string); // Envoie un octet de données (une colonne verticale de 8 pixels)<br />
lcd_string++; // Passe à l'octet suivant dans lcd_string<br />
}<br />
page++; // after 128 columns, go to next page<br />
}<br />
lcd_command(0xAF);<br />
}<br />
</syntaxhighlight>'''<u>Affichage d'un texte</u>'''<br />
<br />
Pour afficher du texte, nous avons créé un tableau appelé '''font bitmap''' en terme courant. Chaque caractère est représenté par une matrice de pixels 5x7, où chaque bit indique si un pixel doit être allumé ou non. Ce format compact nous permet d’afficher les lettres de manière claire et efficace, tout en s’adaptant à la taille souhaitée. Ici nous n'avons qu'une seule taille (5x7) pour répondre à l'objectif embarqué que nous nous sommes fixés (moindre code et moindre consommation).<br />
<br />
Voici un tableau donnant une idée de ce à quoi cela peut ressembler :<syntaxhighlight lang="c" line="1"><br />
const uint8_t font5x7[][5] = {<br />
// ASCII 32 à 127<br />
{0x00,0x00,0x00,0x00,0x00}, // (space)<br />
{0x00,0x00,0x5F,0x00,0x00}, // !<br />
[...]<br />
{0x00,0x60,0x60,0x00,0x00}, // .<br />
{0x20,0x10,0x08,0x04,0x02}, // /<br />
{0x3E,0x51,0x49,0x45,0x3E}, // 0<br />
{0x00,0x42,0x7F,0x40,0x00}, // 1<br />
{0x42,0x61,0x51,0x49,0x46}, // 2<br />
[...]<br />
{0x7E,0x11,0x11,0x11,0x7E}, // A<br />
[...]<br />
}<br />
</syntaxhighlight>Le tableau <code>font5x7</code> est organisé en '''5 colonnes par caractère''' parce que chaque caractère est représenté sur une matrice de pixels 5 colonnes (largeur) par 7 lignes (hauteur). Chaque caractère de la police bitmap fait '''5 pixels de large''' et '''7 pixels de haut'''. Ce genre de tableau peut être généré ou repris d'une librairie graphique tel que [https://github.com/andygock/glcd/blob/master/fonts/font5x7.h glcd].<br />
<br />
Une fois que nous avons le tableau il suffit d'envoyer les données de celle ci ainsi : <syntaxhighlight lang="c" line="1"><br />
void lcd_char(char c) {<br />
if (c == 248 || c == 176) { // '°' = ASCII étendu 248 ou parfois 176<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(deg_symbol[i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
else if (c >= 32 && c <= 126) {<br />
for (uint8_t i = 0; i < 5; i++) {<br />
lcd_data(font5x7[c - 32][i]);<br />
}<br />
lcd_data(0x00); // espace<br />
}<br />
}<br />
<br />
void lcd_goto(uint8_t page, uint8_t column) {<br />
lcd_command(0xB0 | page); // Page = 0 à 3<br />
lcd_command(0x10 | (column >> 4)); // MSB<br />
lcd_command(0x00 | (column & 0x0F)); // LSB<br />
}<br />
<br />
void lcd_print(char *str, uint8_t page, uint8_t column) {<br />
lcd_goto(page, column);<br />
while (*str) lcd_char(*str++);<br />
}<br />
</syntaxhighlight>L'envoie d'un espace après chaque envoie de caractère permet de creer un espacement '''entre les caractères affichés''', pour que les lettres '''ne soient pas collées''' les unes aux autres. '''L’écran est divisé en pages''' (souvent 8 pixels de hauteur par page, ici on a 4 pages si la hauteur est 32 pixel. Par exemple, <code>page 0</code> correspond à la ligne verticale 0–7, <code>page 1</code> à 8–15, etc...<br />
<br />
'''La position horizontale se fait par colonnes''' (chaque colonne correspondant à une tranche verticale de pixels, souvent 1 octet = 8 pixels en hauteur).<br />
<br />
Le contrôleur de l’écran LCD gère en interne une '''adresse mémoire d’écriture''' composée d’une page (ligne) et d’une colonne (position horizontale. Le contrôleur '''incrémente automatiquement la colonne''' pour la prochaine donnée.<br />
<br />
* <code>lcd_goto()</code> sert à positionner le '''curseur initial'''.<br />
<br />
* <code>lcd_data()</code> '''incrémente''' la colonne '''automatiquement''' après chaque octet envoyé.<br />
[[Fichier:TexteLCD.jpg|centré|vignette|Photographie de l'écran avec du texte|519x519px]]<br />
<br />
<br />
Ce projet nous a demandé beaucoup de temps et de persévérance, mais il nous a permis de comprendre en profondeur le fonctionnement d’un écran graphique. Nous sommes désormais capables de coder notre propre bibliothèque pour piloter l’écran, ce qui représentait auparavant un défi majeur.<br />
<br />
=== <big>Communication</big> ===<br />
Ici, nous traiterons du code implémenté afin de communiquer entre les différents capteurs/actionneurs et notre carte principale. Nous avons utilisé un NRF24L01 pour communiquer entre notre station domotique et nos capteurs/actionneurs. Voici le lien du tutoriel pour l’utilisation de puces à distance : [https://passionelectronique.fr/tutorial-nrf24l01 NRF24L01]<br />
<br />
Ce tutoriel nous a aidés à tester ce module via [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/Arduino Arduino]. Nous avons d'abord essayé de coder un simple "hello world" à envoyer et recevoir afin de comprendre le fonctionnement du NRF. Ce code permettait également de tester les cartes au cas où celles-ci dysfonctionnaient, comme c'était le cas avec un Arduino fourni par le professeur. Nous avons ensuite utilisé un Arduino qu’un d’entre nous possédait afin de coder.<br />
[[Fichier:ArduinoDemo.mp4|centré|vignette]]<br />
Par la suite, nous avons codé en C une bibliothèque pour le NRF permettant de communiquer avec celui-ci.<br />
<br />
Le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.c .c] n'était pas fourni par [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/99%20-%20nrf24L01_plus-master%20%28lib%20utilise%29 cette bibliothèque] et le fichier [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/02%20-%20Station%20Domotique/02%20-%20Programmation/NRF24L01/C/01%20-%201er%20code%20sans%20opti/rx/nRF24L01.h .h] a été complété par les fonctions ajoutées ci-dessous :<syntaxhighlight lang="c" line="1"><br />
#include <avr/io.h><br />
#include "nRF24L01.h"<br />
<br />
// Définition des ports et broches<br />
#define MISO_DDR DDRB<br />
#define MISO_PORT PORTB<br />
#define MISO_PIN PINB<br />
#define MISO_BIT PB4<br />
<br />
#define MOSI_DDR DDRB<br />
#define MOSI_PORT PORTB<br />
#define MOSI_BIT PB3<br />
<br />
#define SCK_DDR DDRB<br />
#define SCK_PORT PORTB<br />
#define SCK_BIT PB5<br />
<br />
#define CSN_DDR DDRB<br />
#define CSN_PORT PORTB<br />
#define CSN_BIT PB2<br />
<br />
#define CE_DDR DDRB<br />
#define CE_PORT PORTB<br />
#define CE_BIT PB1<br />
<br />
// Initialisation des broches NRF24L01<br />
void nrf24_setupPins() {<br />
// MISO en entrée<br />
MISO_DDR &= ~(1 << MISO_BIT);<br />
<br />
// MOSI, SCK, CSN, CE en sortie<br />
MOSI_DDR |= (1 << MOSI_BIT);<br />
SCK_DDR |= (1 << SCK_BIT);<br />
CSN_DDR |= (1 << CSN_BIT);<br />
CE_DDR |= (1 << CE_BIT);<br />
<br />
// Valeurs initiales : tout à 0 sauf CSN à 1 (désactivé)<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
CE_PORT &= ~(1 << CE_BIT);<br />
CSN_PORT |= (1 << CSN_BIT); // CSN HIGH (non sélectionné)<br />
}<br />
<br />
// Contrôle de la broche CE<br />
void nrf24_ce_digitalWrite(uint8_t state) {<br />
if (state)<br />
CE_PORT |= (1 << CE_BIT);<br />
else<br />
CE_PORT &= ~(1 << CE_BIT);<br />
}<br />
<br />
// Contrôle de la broche CSN<br />
void nrf24_csn_digitalWrite(uint8_t state) {<br />
if (state)<br />
CSN_PORT |= (1 << CSN_BIT);<br />
else<br />
CSN_PORT &= ~(1 << CSN_BIT);<br />
}<br />
<br />
// Contrôle de la broche SCK<br />
void nrf24_sck_digitalWrite(uint8_t state) {<br />
if (state)<br />
SCK_PORT |= (1 << SCK_BIT);<br />
else<br />
SCK_PORT &= ~(1 << SCK_BIT);<br />
}<br />
<br />
// Contrôle de la broche MOSI<br />
void nrf24_mosi_digitalWrite(uint8_t state) {<br />
if (state)<br />
MOSI_PORT |= (1 << MOSI_BIT);<br />
else<br />
MOSI_PORT &= ~(1 << MOSI_BIT);<br />
}<br />
<br />
// Lecture de la broche MISO<br />
uint8_t nrf24_miso_digitalRead() {<br />
return (MISO_PIN & (1 << MISO_BIT)) ? 1 : 0;<br />
}<br />
<br />
</syntaxhighlight>Nous avons déclaré en <code>#define</code> les DDR, PORT, PIN et BIT de chaque broche afin d'avoir un code plus lisible.<br />
<br />
'''<u>Initialisation des broches du NRF</u>'''<br />
<br />
Pour commencer, nous avons <code>nrf24_init()</code> qui sert à configurer les broches utilisées par le module (MISO, MOSI, SCK, CSN, CE). Ça permet de préparer la communication SPI logicielle. Ensuite, on mets CE à LOW et CSN à HIGH, ce qui correspond à l’état « repos » du module.<br />
'''<u>Configuration du module NRF</u>'''La fonction <code>nrf24_config</code> sert à configurer le module selon le canal radio (fréquence) et la taille des paquets (payload).<br />
<br />
* Elle la longueur de la charge utile (payload) dans une variable globale.<br />
* Elle configure les différents registres : le canal RF, la taille du payload pour les pipes (canaux de réception), la puissance d’émission, le CRC, l’auto-acknowledgment (reconnaissance automatique de réception), les adresses RX activées, la retransmission automatique.<br />
* Puis elle mets le module en mode écoute (réception).<br />
<br />
<br />
<br />
'''<u>Gestion des adresses TX et RX</u>'''<br />
<br />
<code>nrf24_tx_address()</code> et <code>nrf24_rx_address()</code> servent à définir les adresses pour l’envoi et la réception. Ces adresses doivent être cohérentes pour que la communication fonctionne.<br />
<br />
'''<u>Envoi et réception des données</u>'''<br />
<br />
<code>nrf24_send()</code> permet d’envoyer un paquet. Elle prépare le module, vide le FIFO d’émission, puis écris le payload et démarre la transmission.<br />
<br />
<code>nrf24_getData()</code> lit les données reçues depuis le module en SPI, puis remet à zéro le flag d’interruption réception.<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
'''<u>Vérification de l’état</u>'''<br />
<br />
<code>nrf24_dataReady()</code> et <code>nrf24_rxFifoEmpty()</code> permettent de savoir si des données sont prêtes à être lues.<br />
<br />
<code>nrf24_isSending()</code> indique si le module est encore en train d’envoyer un message.<br />
<br />
<code>nrf24_lastMessageStatus()</code> dit si la dernière transmission a réussi ou a échoué (nombre max de retransmissions atteint).<br />
<br />
<code>nrf24_retransmissionCount()</code> donne le nombre de tentatives de retransmission.<br />
'''<u>Gestion de la puissance</u>'''<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
'''<u>Gestion de la puissance</u>'''<br />
<br />
<code>nrf24_powerUpRx()</code>, <code>nrf24_powerUpTx()</code>, <code>nrf24_powerDown()</code> sont des fonctions pour mettre le module en mode réception, émission, ou veille.<br />
<br />
<br />
<br />
'''<u>Communication SPI en logiciel (bit-banging)</u>'''<br />
<br />
Comme on n’utilise pas le matériel SPI natif, <code>spi_transfer()</code> envoie et reçoit un octet via manipulation manuelle des broches MOSI, MISO et SCK.<br />
<br />
Les fonctions <code>nrf24_transferSync()</code> et <code>nrf24_transmitSync()</code> permettent d’envoyer ou recevoir plusieurs octets à la suite.<br />
Cela à été fait de cette façon afin d'avoir le code le plus portatif possible, ce qui explique le contenu de cette librairie.<br />
Nous n'avons pas implémenté le SPI matériel puisque le code fonctionne très bien sans.<br />
'''<u>Lecture/écriture des registres</u>'''<br />
Pour lire ou écrire un registre du nRF24, <code>nrf24_readRegister()</code> et <code>nrf24_writeRegister()</code>, envoient la commande adéquate en SPI puis récupèrent ou envoient les données.<br />
<br />
<br />
Nous avons commencé par étudier la documentation officielle du module '''nRF24L01''', en particulier le '''datasheet''', afin de comprendre le protocole SPI, les registres internes et les commandes à utiliser. Ensuite, nous avons consulté différents exemples sur '''GitHub''' ainsi que des tutoriels pour Arduino. <br />
<br />
<br />
Je ne vais pas remontrer la vidéo de démonstration c'est redondant ici. Il y en aura une pour la prochaine étape qui est ...<br />
<br />
=== IHM PC ===<br />
Dans cette section, nous expliquons comment la '''carte domotique''' communique avec un '''PC via USB''', en utilisant la bibliothèque '''LUFA'''. Le code utilisé est un exemple issu du [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/Demos/Device/LowLevel/VirtualSerial repertoire suivant], déjà employé dans un projet annexe de '''programmateur AVR'''. Ce code permet l’envoi simple de données via une '''liaison série USB''' (USB CDC). <br />
<br />
Pour récupérer ces données côté PC et les afficher, nous avons choisi d’utiliser d’abord '''Node-RED''' pour la gestion des flux de données, puis '''Grafana''' (outil recommandé par M. Boé) pour l’affichage graphique qui sera implémenté plus tard. Ce choix nous permet de gagner du temps sur la partie interface web, qui peut être longue à développer manuellement. <br />
<br />
Grafana ne sera peut être pas déployer car la liaison entre Node-RED et Grafana doit se faire depuis une base de donnée (surement InfluxDB) et cela prend du temps à être mis en place. <br />
<br />
Voici le repertoire de cette partie : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/03%20-%20%20ui_web_interface <br />
<br />
=== LUFA ===<br />
<br />
=== '''Docker''' ===<br />
Ces outils sont déployés à l’aide de '''Docker''', une technologie (open source et créer par des ingénieurs français !) de virtualisation légère qui permet d’exécuter des applications dans des conteneurs isolés. <br />
<br />
Docker permet de '''packager toute une application et ses dépendances''' dans un conteneur. Plus besoin de réinstaller des bibliothèques, configurer l’environnement, ou se soucier du “ça marche sur mon PC mais pas ailleurs”. Cela marchera donc aussi de votre côté ;). <br />
<br />
Nous utilisons également '''Docker Compose''' pour automatiser le lancement coordonné de plusieurs services (ici Node-RED et Grafana) à partir d’un simple fichier de configuration. <br />
<br />
Voici le fichier de configuration de '''Docker Compose''' : <syntaxhighlight lang="yaml"><br />
version: '3.8'<br />
<br />
services:<br />
<br />
nodered:<br />
image: nodered/node-red:latest<br />
container_name: nodered<br />
ports:<br />
- "1880:1880"<br />
volumes:<br />
- ./nodered_data:/data<br />
devices:<br />
- /dev/ttyACM0<br />
restart: unless-stopped<br />
<br />
grafana:<br />
image: grafana/grafana-oss<br />
container_name: grafana<br />
ports:<br />
- "3000:3000"<br />
volumes:<br />
- ./grafana_data:/var/lib/grafana<br />
<br />
<br />
restart: unless-stopped<br />
<br />
</syntaxhighlight>On configure le port où le service sera lancé et nous laissons les accès devices à nodered pour quelle puisse écouter le port série où notre LUFA écrit. La mention <code>- ${SERIAL_DEV:-/dev/null}:/dev/ttyACM0</code> peut être ajouté afin de pouvoir lancer le dock sans problème de compilation car Docker ne démarre pas le conteneur si un périphérique mentionné dans <code>devices:</code> est '''introuvable.''' <br />
<br />
La mention<code>${SERIAL_DEV:-/dev/null}:</code> créera un lien vers <code>/dev/null</code> (un périphérique vide), évitant ainsi l’erreur. Je connaissais Docker parceque j'utilisais une application qui se lançait sur celle-ci et je m'y suis intéressé. J'estimais intéressant de l'intégrer au projet !<br />
<br />
Voici un fichier mémo qui nous a aider à nous rappeler des commandes importantes sur Docker :<syntaxhighlight lang="text"><br />
Liste des docker actif sur le pc :<br />
docker ps -a<br />
<br />
Dans ce repertoire, lancer les dockers via :<br />
docker compose up -d<br />
<br />
Pour relancer copie tout :<br />
docker compose down<br />
docker compose up -d<br />
<br />
Pour stopper un docker : <br />
docker stop <nomDock><br />
<br />
Pour supprimer un docker :<br />
docker rm -f <nomDock><br />
<br />
Si un pb, voir log :<br />
docker logs <nomDock><br />
<br />
</syntaxhighlight><br />
<br />
=== '''Node-RED''' ===<br />
Voici à quoi ressemble notre configuration :<br />
[[Fichier:NodeRedConfig.png|centré|vignette|778x778px|Configuration Node-RED]]<br />
<br />
<br />
'''Bloc 1 : Entrée série (Serial In)'''<br />
<br />
Ce bloc permet d'écouter un port série. Il lit les données envoyées par la carte domotique sur le port <code>/dev/ttyACM0</code>. Les données sont transmises sous forme de texte brut, souvent une chaîne JSON. Voici la configuration :<br />
[[Fichier:ConnfigLEcturePortSerie.png|centré|vignette|596x596px|Configuration bloc 1]]<br />
<br />
<br />
'''Bloc 2 : Conversion JSON'''<br />
<br />
Les données reçues sont des chaînes de caractères au format JSON. Ce bloc les convertit en objet JavaScript pour que Node-RED puisse les manipuler plus facilement dans les blocs suivants.<br />
<br />
<br />
'''Bloc 3 : Traitement de la donnée (Function)'''<br />
<br />
Ce bloc exécute une petite fonction JavaScript pour isoler la température contenue dans l'objet JSON.<br />
<br />
Voici le contenu de la fonction :<syntaxhighlight lang="js" line="1"><br />
msg.payload = msg.payload.temperature;<br />
return msg;<br />
</syntaxhighlight><br />
<br />
* <code>msg.payload</code> contient l'objet JSON complet, par exemple : <code>{ "temperature": 22.5, "...": 45, "...": 20, "...": "oui" }</code><br />
* La ligne <code>msg.payload = msg.payload.temperature;</code> remplace le contenu du message pour ne garder que la valeur de la température (ici <code>22.5</code>). Cela permet d’envoyer uniquement la température au bloc suivant, comme une simple valeur numérique.<br />
<br />
* <code>return msg;</code> renvoie ce nouveau message modifié pour qu’il continue à circuler dans le flow.<br />
<br />
<br />
'''Bloc 4 : Affichage ou base de données'''<br />
<br />
Le message contenant uniquement la température peut ensuite être affiché dans un tableau de bord, envoyé à Grafana, ou enregistré dans une base de données.<br />
<br />
Pour le moment on utilisera pas de base donnée mais une interface beaucoup plus minimaliste sur Node-RED. <br />
<br />
Voici la configuration du bloc :<br />
[[Fichier:CaptureConfigDataDisplay.png|centré|vignette|573x573px|Configuration bloc 3 permettant l'affichage de la température]]<br />
Pour avoir accès au noeud du bloc 1 et 3 il a fallu ajouter des "nodes" à notre palette. Pour y acceder c'est ici :<br />
[[Fichier:PaletteNodeAccess.png|centré|vignette|Acces à Palette ]]<br />
Et voici les noeuds installés :<br />
[[Fichier:PaletteNoodes.png|centré|vignette|408x408px|Palette de nodes du projet]]<br />
<br />
<br />
Maintenant regardons notre<br />
[[Fichier:AccesVueRedNode.png|gauche|vignette|249x249px|Accès au résultat de notre Node-RED]]<br />
[[Fichier:Vue sur notre projet Node RED.png|centré|vignette|301x301px|Accès vue sur notre projet]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
On clique sur la petite icône est nous sommes renvoyé sur cette url : http://localhost:1880/ui/<br />
<br />
Voici notre interface finale :<br />
[[Fichier:Dashboard.png|centré|vignette|1456x1456px|Dashboard site web]]<br />
<br />
<br />
Et une démonstration du projet dans son intégralité en vidéo ci dessous :<br />
<br />
=== Programmateur AVR (Projet annexe) ===<br />
<br />
=== Objectif ===<br />
Réaliser un programmateur AVR afin d'envoyer notre code C sur un microcontrôleur. Ce projet est une introduction au logiciel et à la programmation sur microcontroleur AVR.<br />
<br />
Nous nous sommes aider du cours afin de réaliser notre projet : https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html<br />
=== Schématique ===<br />
<br />
==== Notre schéma électrique ====<br />
[[Fichier:SE3_2024_G2_prog_schema.pdf|center|thumb|Schéma électrique KICAD]]<br />
<p style="clear: both;" /><br />
<br />
==== Conception de notre schéma électrique ====<br />
[[Fichier:Comprendre le schéma.pdf|vignette|centré|Document expliquant point par point le schéma réalisé sur KICAD]]<br />
<p style="clear: both;" /><br />
'''Documents relatifs à la conception du kicad de la carte'''<br />
[[Fichier:Datasheet ATMEGA8U2.pdf|gauche|194x194px|vignette|Datasheet ATMEGA8U2]]<br />
[[Fichier:AVR042.pdf|199x199px|vignette|AVR Hardware Design Considerations|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Vue 3D ===<br />
[[Fichier:3D Kicad Programmmateur AVR.png|centré|sans_cadre|521x521px|Programmmateur AVR - 3D KICAD]]<br />
<p style="clear: both;" /><br />
<br />
=== Fichier kicad ===<br />
[[Fichier:2024-PSE-G2-Prog VFinale sans erreur.zip|alt=2024-PSE-G2-Prog VFinale|centré]]<br />
<p style="clear: both;" /><br />
<br />
=== Brasure ===<br />
[[Fichier:Brasure avant carte prog avr.jpg|gauche|vignette|Carte programmateur AVR - Vue avant]]<br />
[[Fichier:Brasure arriere carte prog avr.jpg|centré|vignette|Carte programmateur AVR - Vue arrière]]<br />
<p style="clear: both;" /><br />
<br />
=== Programmation ===<br />
<br />
==== Test leds et boutons ====<br />
Afin de vérifier que notre carte fonctionne correctement après sa brasure, on code un programme permettant d'allumer une LED lorsqu'un bouton poussoir est pressé. Chaque bouton est associé à une LED. <br />
<br />
===== Modification de l'horloge =====<br />
<syntaxhighlight lang="c" line="1"><br />
<br />
void setupClock(void)<br />
{<br />
CLKSEL0 = 0b00010101; // sélection de l'horloge externe<br />
CLKSEL1 = 0b00001111; // minimum de 8Mhz<br />
CLKPR = 0b10000000; // modification du diviseur d'horloge (CLKPCE=1)<br />
CLKPR = 0; // 0 pour pas de diviseur (diviseur de 1)<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation des pins ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupPin(volatile uint8_t* PORTx, volatile uint8_t* DDRx, uint8_t pin, pinmode mode) {<br />
switch (mode)<br />
{<br />
case INPUT: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
break;<br />
case INPUT_PULL_UP: // Forcage pin à 0<br />
*DDRx &= ~(1 << pin);<br />
*PORTx |= (1 << pin);<br />
break;<br />
case OUTPUT: // Forcage pin à 1<br />
*DDRx |= (1 << pin);<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction initialisation de l'ensemble des boutons et LEDs ======<br />
<syntaxhighlight lang="c" line="1"><br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
====== Fonction de lecture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
int readPin(volatile uint8_t* PINx, uint8_t pin) {<br />
return (*PINx & (1 << pin));<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction d'écriture de pin ======<br />
<syntaxhighlight lang="c" line="1"><br />
void writePin(volatile uint8_t* PORTx, uint8_t pin, write level) {<br />
if (level == LOW)<br />
*PORTx |= (1 << pin);<br />
else<br />
*PORTx &= ~(1 << pin);<br />
}<br />
</syntaxhighlight><br />
<br />
====== Fonction pour initialiser les composantes de la cartes ======<br />
<syntaxhighlight lang="c" line="1"><br />
// ------------------ Boutons ------------------ //<br />
#define BTNsUp_Left_PORT &PORTC<br />
#define BTNsUp_Left_DDR &DDRC<br />
#define BTNsUp_Left_PIN &PINC<br />
<br />
#define BTNsDown_Right_PORT &PORTB<br />
#define BTNsDown_Right_DDR &DDRB<br />
#define BTNsDown_Right_PIN &PINB<br />
<br />
#define BTN_Up_PIN PC4 <br />
#define BTN_Down_PIN PB5 <br />
#define BTN_Left_PIN PC6 <br />
#define BTN_Right_PIN PB6 <br />
<br />
// ------------------ LEDs ------------------ //<br />
#define LEDs_PORT &PORTD<br />
#define LEDs_DDR &DDRD<br />
#define LEDs_PIN &PIND<br />
<br />
#define LED1_PIN PD0<br />
#define LED2_PIN PD1<br />
#define LED3_PIN PD2<br />
#define LED4_PIN PD3<br />
<br />
// ------------------ Enum ------------------ //<br />
typedef enum {<br />
INPUT,<br />
INPUT_PULL_UP,<br />
OUTPUT,<br />
} pinmode;<br />
<br />
<br />
void setupHardware() {<br />
setupClock();<br />
<br />
setupPin(LEDs_PORT, LEDs_DDR, LED1_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED2_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED3_PIN, OUTPUT);<br />
setupPin(LEDs_PORT, LEDs_DDR, LED4_PIN, OUTPUT);<br />
<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Up_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Down_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsUp_Left_PORT, BTNsUp_Left_DDR, BTN_Left_PIN, INPUT_PULL_UP);<br />
setupPin(BTNsDown_Right_PORT, BTNsDown_Right_DDR, BTN_Right_PIN, INPUT_PULL_UP);<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==== LUFA ====<br />
Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).<br />
<br />
* Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : [https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/02%20-%20Programmation/lufa-LUFA-210130-NSI/se/VirtualSerial https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial]<br />
Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant : <code>LUFA/Demos/Device/LowLevel/VirtualSerial</code><br />
<br />
<br />
Le code exemple du VirtualSerial permet d'écrire des données à notre pc (visible via minicom).<br />
<br />
<br />
<br />
Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.<br />
[[Fichier:Terminal - cmd lsusb avec carte.png|droite|sans_cadre|712x712px]]<br />
[[Fichier:Terminal - Cmd lsusb.png|gauche|sans_cadre|756x756px]]<br />
<br />
<p style="clear: both;" /><br />
<br />
Pour plus de détail sur notre périphérique usb branché on doit faire la commande suivante :<syntaxhighlight lang="terminfo" line="1"><br />
cedricagathe@computer:~$ lsusb -s 003:008 -v<br />
<br />
Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application<br />
[...]<br />
Device Descriptor:<br />
bLength 18<br />
bDescriptorType 1<br />
[...]<br />
bDeviceClass 2 Communications<br />
bDeviceSubClass 0 <br />
bDeviceProtocol 0 <br />
[...]<br />
idVendor 0x03eb Atmel Corp.<br />
idProduct 0x2044 LUFA CDC Demo Application<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 0<br />
bAlternateSetting 0<br />
bNumEndpoints 1<br />
bInterfaceClass 2 Communications<br />
bInterfaceSubClass 2 Abstract (modem)<br />
bInterfaceProtocol 1 AT-commands (v.25ter)<br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x82 EP 2 IN<br />
[...]<br />
Interface Descriptor:<br />
bLength 9<br />
bDescriptorType 4<br />
bInterfaceNumber 1<br />
bAlternateSetting 0<br />
bNumEndpoints 2<br />
bInterfaceClass 10 CDC Data<br />
bInterfaceSubClass 0 <br />
bInterfaceProtocol 0 <br />
[...]<br />
Endpoint Descriptor:<br />
bLength 7<br />
bDescriptorType 5<br />
bEndpointAddress 0x83 EP 3 IN<br />
[...]<br />
</syntaxhighlight><br />
<br />
Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données. Une fois notre carte détectée, on appuie en continue sur le bouton HWB puis une seule impulsion sur le bouton RESET afin de mettre notre carte en mode DFU et ensuite on relache HWB. <br />
<br />
On pourra alors téléverser notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande <code>make dfu</code>.<br />
<p style="clear: both;" /><br />
<br />
[[Fichier:Led carte.mp4|500px|left|led_carte]]<br />
[[Fichier:Bouton carte.mp4|500px|right|bouton_carte]]<br />
<p style="clear: both;" /><br />
<br />
* On place le programme dans notre carte à l'aide de la commande <code>make upload</code>. Pour ce faire, il faut modifier le makefile original par ceci :<br />
<syntaxhighlight lang="makefile" line="1" start="1"><br />
MCU = atmega8u2<br />
ARCH = AVR8<br />
BOARD = NONE<br />
F_CPU = 16000000<br />
F_USB = $(F_CPU)<br />
OPTIMIZATION = s<br />
TARGET = VirtualSerial<br />
SRC = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)<br />
LUFA_PATH = ../../LUFA<br />
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig/<br />
LD_FLAGS =<br />
PROGRAMMER = dfu-programmer<br />
<br />
# Include LUFA-specific DMBS extension modules<br />
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA<br />
include $(DMBS_LUFA_PATH)/lufa-sources.mk<br />
include $(DMBS_LUFA_PATH)/lufa-gcc.mk<br />
<br />
# Include common DMBS build system modules<br />
DMBS_PATH ?= $(LUFA_PATH)/Build/DMBS/DMBS<br />
include $(DMBS_PATH)/core.mk<br />
include $(DMBS_PATH)/cppcheck.mk<br />
include $(DMBS_PATH)/doxygen.mk<br />
include $(DMBS_PATH)/dfu.mk<br />
include $(DMBS_PATH)/gcc.mk<br />
include $(DMBS_PATH)/hid.mk<br />
include $(DMBS_PATH)/avrdude.mk<br />
include $(DMBS_PATH)/atprogram.mk<br />
<br />
</syntaxhighlight><br />
<br />
Le MCU a été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmentée à 16 MHz.<br />
<br />
* On lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.<br />
<syntaxhighlight lang="terminfo"><br />
sudo minicom -os<br />
</syntaxhighlight><br />
<p style="clear: both;" />Ensuite nous entrons dans Serial port setup :[[Fichier:Image terminal apres commande minicom -os.png|gauche|sans_cadre|361x361px]]<br />
[[Fichier:Menu serial port ssetup minicom.png|centré|sans_cadre|395x395px]]<br />
<br />
<p style="clear: both;" /><br />
Il va falloir procéder à 3 changements : <br />
<br />
# '''''Appuyer sur A''''' et changer modem par l'emplacement de notre carte (ici /ttyACM0) puis ENTRER<br />
# '''''Appuyer sur E''''' puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER<br />
# '''''Appuyer sur F''''' puis ENTRER<br />
<p style="clear: both;" /><br />
<br />
Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit. <br />
<br />
On est maintenant prêt à recevoir les messages USB qu'on envoie lors d'un appui :<br />
[[Fichier:Interface minicom vierge.png|gauche|sans_cadre|620x620px]]<br />
[[Fichier:Interface minicom apres reception message.png|centré|sans_cadre]]<br />
<p style="clear: both;" /><br />
<br />
<br />
* Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.<br />
<p style="clear: both;" /><br />
[[Fichier:Lufa boutons.mp4|vignette|Demonstration vidéo de notre programme utilisant la LUFA|centré]]<br />
<br />
<p style="clear: both;" /><p style="clear: both;" /><br />
<br />
===== <big>Modification du fichier virtual.c</big> =====<br />
<br />
====== Afficher sur le minicom lorsqu'un bouton est pressé et test leds ======<br />
<syntaxhighlight lang="c" line="1"><br />
void CDC_Task(void) {<br />
static char ReportBuffer[64]; // Buffer pour stocker le message à envoyer<br />
static bool ActionSent = false; // Pour éviter d'envoyer plusieurs fois le même message<br />
<br />
bool hasMessage = false; // Indique si un bouton a été pressé<br />
<br />
// Vérifie que l’appareil est connecté et configuré<br />
if (USB_DeviceState != DEVICE_STATE_Configured)<br />
return;<br />
<br />
// Détection du bouton haut<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Up_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du haut\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED1_PIN);<br />
_delay_ms(300); // Anti-rebond<br />
}<br />
else ActionSent = false;<br />
<br />
<br />
// Détection du bouton bas<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Down_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton du bas\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED2_PIN);<br />
<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton gauche<br />
if (!readPin_HardwareProgAVR(BTNsUp_Left_PIN, BTN_Left_PIN)) {<br />
hasMessage = true;<br />
strcpy(ReportBuffer, "bouton de gauche\r\n");<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED3_PIN);<br />
_delay_ms(300);<br />
<br />
}<br />
else ActionSent = false;<br />
<br />
// Détection du bouton droit<br />
if (!readPin_HardwareProgAVR(BTNsDown_Right_PIN, BTN_Right_PIN)) {<br />
hasMessage = true;<br />
ReportString = "bouton de droite\r\n";<br />
// spi_test_octet(ReportBuffer);<br />
// getIDspi(ReportBuffer);<br />
<br />
toggleLed(LEDs_PORT, LEDs_PIN, LED4_PIN);<br />
_delay_ms(300);<br />
}<br />
else ActionSent = false;<br />
<br />
// Si un bouton a été pressé et qu'aucune action n’a encore été envoyée<br />
if (hasMessage && (ActionSent == false) && LineEncoding.BaudRateBPS) {<br />
ActionSent = true;<br />
<br />
// Envoie le message via USB<br />
Endpoint_SelectEndpoint(CDC_TX_EPADDR);<br />
Endpoint_Write_Stream_LE(ReportBuffer, strlen(ReportBuffer), NULL);<br />
<br />
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);<br />
Endpoint_ClearIN();<br />
<br />
if (IsFull) {<br />
Endpoint_WaitUntilReady();<br />
<br />
Endpoint_ClearIN();<br />
}<br />
}<br />
<br />
// Nettoie le buffer de réception (inutile ici mais bonne pratique)<br />
Endpoint_SelectEndpoint(CDC_RX_EPADDR);<br />
if (Endpoint_IsOUTReceived())<br />
Endpoint_ClearOUT();<br />
}<br />
</syntaxhighlight><br />
<p style="clear: both;" />L’ajout d’un délai de 300 ms est nécessaire pour éviter les rebonds des boutons mécaniques. Sans cela, une pression peut être détectée plusieurs fois à cause des oscillations électriques rapides à l’activation.<p style="clear: both;" />Ici on voit que le code peut être factorisé. Cela n'a pas été fais pour tester individuellement des fonctions différentes sur chaque bouton (cf prochaine section).<br />
<br />
====== '''Récupération ID microcontroleur''' ======<br />
<p style="clear: both;" />Il y a des tentatives afin de récuprer un identifiant d'un microcontroleur via la fonction getIDspi(ReportBuffer). <syntaxhighlight lang="c"><br />
#include "../spi.h"<br />
<br />
#include <avr/io.h><br />
#include <string.h><br />
#include <util/delay.h><br />
<br />
<br />
#define SPI_DDR DDRB<br />
#define SPI_PORT PORTB<br />
#define SPI_SS PB0<br />
#define SPI_SCK PB1<br />
#define SPI_MOSI PB2<br />
#define SPI_MISO PB3<br />
<br />
void spi_init(void) { // Initialisation du bus SPI<br />
SPI_DDR |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS); // Définition des sorties<br />
SPI_DDR &= ~(1 << SPI_MISO); // Définition de l'entrée<br />
SPI_PORT |= (1 << SPI_SS); // Désactivation du périphérique<br />
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); // Activation SPI (SPE) en état maître (MSTR)<br />
SPSR &= ~(1 << SPI2X); // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)<br />
}<br />
<br />
void spi_activer(void) { // Activer le périphérique<br />
SPI_PORT &= ~(1 << SPI_SS); // Ligne SS à l'état bas<br />
}<br />
<br />
void spi_desactiver(void) { // Désactiver le périphérique<br />
SPI_PORT |= (1 << SPI_SS); // Ligne SS à l'état haut<br />
}<br />
<br />
uint8_t spi_echange(uint8_t envoi) { // Communication sur le bus SPI<br />
SPDR = envoi; // Octet a envoyer<br />
while (!(SPSR & (1 << SPIF))); // Attente fin envoi (drapeau SPIF du statut)<br />
return SPDR; // Octet reçu<br />
}<br />
<br />
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {<br />
spi_echange(a);<br />
spi_echange(b);<br />
spi_echange(c);<br />
return spi_echange(d);<br />
}<br />
<br />
void end_pmode(void) {<br />
PORTB &= ~(1 << PB0);<br />
}<br />
<br />
#define nibble2char(n) (((n)<10)?'0'+(n):'a'+(n)-10)<br />
<br />
void convert(unsigned char byte, char* string) {<br />
string[0] = nibble2char(byte >> 4);<br />
string[1] = nibble2char(byte & 0x0f);<br />
string[2] = '\0';<br />
}<br />
<br />
void getIDspi(char* ReportString) {<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
<br />
uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00); //cf p8 Device Code de la DS AVR_ISP<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(high, format + 5); // "xx" remplacé par la valeur convertie<br />
<br />
uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);<br />
spi_desactiver();<br />
spi_activer();<br />
_delay_ms(10); // délai optionnel pour stabilité<br />
// convert(middle, format + 14); // "yy" remplacé par middle<br />
uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);<br />
spi_desactiver();<br />
// convert(low, format + 22); // "zz" remplacé par low<br />
<br />
<br />
<br />
char highHex[3], middleHex[3], lowHex[3];<br />
convert(high, highHex);<br />
convert(middle, middleHex);<br />
convert(low, lowHex);<br />
<br />
// Construire la chaîne manuellement<br />
char* ptr = ReportString;<br />
const char* prefix = "RAW SPI ID: H=0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
<br />
*ptr++ = highHex[0];<br />
*ptr++ = highHex[1];<br />
<br />
const char* midStr = " M=0x";<br />
while (*midStr) *ptr++ = *midStr++;<br />
<br />
*ptr++ = middleHex[0];<br />
*ptr++ = middleHex[1];<br />
<br />
const char* lowStr = " L=0x";<br />
while (*lowStr) *ptr++ = *lowStr++;<br />
<br />
*ptr++ = lowHex[0];<br />
*ptr++ = lowHex[1];<br />
<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight><p style="clear: both;" />Avec l’aide de M. Redon, nous avons tenté de récupérer l’identifiant unique d’un microcontrôleur AVR en utilisant le protocole SPI. Pour cela, nous avons développé un programme basé sur une communication SPI bas-niveau, avec les fonctions d’initialisation, d’activation/désactivation du bus, et d’échange de données via SPI.<p style="clear: both;" />Le principe était d’envoyer des commandes spécifiques conformes au protocole ISP (In-System Programming) d’Atmel, notamment l’envoi de la commande <code>0x30</code> suivie d’adresses pour lire les octets composant l’ID (haut, milieu, bas). La fonction <code>getIDspi()</code> réalise ces transactions successives et convertit les valeurs reçues en chaîne hexadécimale lisible.<p style="clear: both;" /><p style="clear: both;" />Nous avons également implémenté une fonction de test simple, <code>spi_test_octet()</code>, qui envoie un octet <code>0x55</code> et devrait recevoir la même valeur en retour si le périphérique répond correctement.<p style="clear: both;" /><syntaxhighlight lang="c"><br />
void spi_test_octet(char* ReportString) {<br />
// Configuration de RESET en sortie<br />
SPI_DDR |= (1 << SPI_SS); // RESET = PB0 en sortie<br />
SPI_PORT &= ~(1 << SPI_SS); // RESET à 0 : mode programmation<br />
// _delay_ms(30); // Attente suffisante (20ms minimum)<br />
<br />
// Envoie de la commande ISP pour vérifier si la cible répond<br />
// spi_activer(); // SS SPI actif (LOW)<br />
// uint8_t check = spi_transaction(0xAC, 0x53, 0x00, 0x00); // Activation ISP<br />
// spi_desactiver(); // SS SPI inactif (HIGH)<br />
<br />
// if (check != 0x53) {<br />
// strcpy(ReportString, "Erreur: mode ISP non actif\r\n");<br />
// SPI_PORT |= (1 << SPI_SS); // RESET à 1 : fin prog<br />
// return;<br />
// }<br />
<br />
// Si la cible est bien en mode programmation, test SPI<br />
spi_activer();<br />
uint8_t response = spi_echange(0x55);<br />
spi_desactiver();<br />
<br />
SPI_PORT |= (1 << SPI_SS); // Fin du mode ISP (RESET à 1)<br />
<br />
// Construction de la chaîne<br />
char hexStr[3];<br />
convert(response, hexStr);<br />
<br />
char* ptr = ReportString;<br />
const char* prefix = "SPI test response: 0x";<br />
while (*prefix) *ptr++ = *prefix++;<br />
*ptr++ = hexStr[0];<br />
*ptr++ = hexStr[1];<br />
*ptr++ = '\r';<br />
*ptr++ = '\n';<br />
*ptr = '\0';<br />
}<br />
</syntaxhighlight>'''Cependant, malgré plusieurs essais, la récupération stable de l’ID n’a pas été réussie :'''<br />
* Le signal SPI semble fonctionner de manière intermittente.<br />
* La réponse attendue (<code>0x55</code>) est parfois reçue, mais de façon instable.<br />
* Cela pourrait venir d’un problème matériel (câblage, niveau des signaux) ou d’un timing non respecté dans le protocole SPI/ISP.<br />
<br />
* '''Fonctions SPI implémentées''' :<br />
** <code>spi_init()</code> : configure les broches et paramètres SPI maître.<br />
** <code>spi_activer()</code> / <code>spi_desactiver()</code> : contrôle de la ligne SS (Slave Select).<br />
** <code>spi_echange()</code> : envoie et réception d’un octet SPI.<br />
** <code>spi_transaction()</code> : envoie une séquence de quatre octets en SPI, utile pour la commande ISP.<br />
<br />
<br />
Jusqu'ici, je n'ai pas de piste pour pouvoir continuer, sachant que le câblage n'est pas le problème.</div>Cpayethttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Dashboard.png&diff=8050Fichier:Dashboard.png2025-06-15T20:18:45Z<p>Cpayet : </p>
<hr />
<div>Dashboard</div>Cpayet