projets-se.plil.fr - Contributions [fr]

SE4Binome2024-3

2025-01-25T12:14:55Z

Vdetrez : /* Schéma de fonctionnement de la mémoire */

[[Fichier:Titre page pico carte mère cart detrez.png|centré|sans_cadre|972x972px]]

== Description ==
L'objectif de ce projet est de réaliser un pico ordinateur. Nous allons traiter le développement de la carte mère, un shield arduino ainsi que la programmation d'un ordonnanceur.

Notre carte mère sera alimenté via une alimentation secteur en 5v et le code sera implanté par USB.

== Réalisation d'un shield arduino ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:PicoShield SCH Detrez Cart.pdf|sans_cadre|639x639px]]
![[Fichier:Routage shield CART DETREZ.png|sans_cadre|638x638px]]
|}

=== PINOUT ===
{| class="wikitable"
|+
|LED1
|PC0
|-
|LED2
|PC3
|-
|LED3
|PD1
|-
|LED4
|PD4
|-
|LED5
|PD7
|}

=== Brasage du shield ===

==== shield nu ====
[[Fichier:Shield nu CART DETREZ 2.jpg|sans_cadre]]

==== shield fini ====
[[Fichier:Shield fini CART DETREZ.jpg|sans_cadre]]

=== Test du shield ===
[[Fichier:Affichage 7 segments DETREZ CART.jpg|sans_cadre]]

== Réalisation carte mère ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:Schématique Carte mere CART DETREZ.pdf|centré|sans_cadre|679x679px]]
![[Fichier:Schématique Carte mere .png|centré|sans_cadre|575x575px]]
|}

=== Brasage carte mère ===

==== carte mère nue ====
[[Fichier:PCB_carte_mère_nu.jpg|sans_cadre]]

==== ajout ATmega 328p ====
[[Fichier:Brasage ATmega 328p carte mère.jpg|sans_cadre]]

==== ajout ATmega 8U2 ====
[[Fichier:Carte mère G3 avec 8U2.jpg|sans_cadre]]

==== mise en lien des ATmega et correction de conception ====
La correction consiste en l'ajout d'un bouton reset et HWB pour l'ATmega8U2.

[[Fichier:Lien ATmega + correction.jpg|sans_cadre]]

==== carte finale ====
[[Fichier:Carte mere finale detrez cart 2.jpg|sans_cadre]]

=== Tests ===

==== Test de clignotement d'une LED (25ms) ====
[[Fichier:Test clignotement LED ATmega 328p .mp4|sans_cadre]]

=== Programmation des cartes ===

27/11/24 : pour le moment le µc atmega328p a réussi à être programmé par ISP en changeant les fuses grâce à avrdude. En revanche, impossible de programmer l'atmega8u2. Nous avons essayé de lui mettre un bootloader et de changer ses fuses mais c'est impossible dans les deux cas et la carte n'est donc pas détectée en USB.

4/12/24 : nous avons réussi à mettre un bootloader dans le 8u2, en revanche nous n'arrivons toujours pas à programmer le 328p grâce au port USB. La cause : nous n'arrivons pas à burn le bootloader du 328p pour qu'il puisse recevoir des données via usb_série ...

Solution trouvée : Nous avons changé le bootloader en mettant [https://github.com/Optiboot/optiboot/blob/master/optiboot/bootloaders/optiboot/optiboot_atmega328.hex celui-ci] (/usr/share/arduino/hardware/arduino/avr/bootloaders/optiboot) à la place pour augmenter la place de ce dernier. Maintenant le 328p peut être programmé grâce à l'USB.

== Programmation ordonnanceur ==

=== Initialisation de la pile ===
<syntaxhighlight lang="c">
void init_pile(int N){
uint16_t tempSP = SP;
SP = task[N].stackPointer;
uint16_t adresse=(uint16_t)task[N].addressFunction;
asm volatile("push %0" : : "r" (adresse & 0x00ff) );
asm volatile("push %0" : : "r" ((adresse & 0xff00)>>8) );
SAVE_REGISTERS();
task[N].stackPointer = SP;
SP = tempSP;
}
</syntaxhighlight>La fonction init_pile() sert à charger un processus dans la pile. Cette fonction est appelée dans une boucle au début du main pour initialiser tous les processus.

=== Interruption de l'ordonnanceur ===
L'ordonnanceur est appelé à un interval de temps régulier grâce à des interruptions du Timer1.

Avant de passer d'une tâche à une autre (mode Round Robin) il faut d'abord effectuer quelques opérations sur la mémoire du micro-processeur.<syntaxhighlight lang="c">
ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
/* Sauvegarde du contexte de la tâche interrompue */
SAVE_REGISTERS();
task[currentTask].stackPointer = SP;
/* Appel à l'ordonnanceur */
scheduler();
/* Récupération du contexte de la tâche ré-activée */
SP = task[currentTask].stackPointer;
RESTORE_REGISTERS();
asm volatile ( "reti" );
}
</syntaxhighlight>La routine d'interruption est générée par le '''Timer1''' avec comme paramètre ISR_NAKED qui permet de ne pas avoir le prologue et l'épilogue automatique du compilateur ce qui nous est très utile pour gérer manuellement ces interruptions afin d'éxecuter nos tâches.

La macro '''''SAVE_REGISTERS()''''' nous permet de sauvegarder les 32 registres sur la pile. Cela permet de s’assurer qu’au retour de l'interruption, la tâche interrompue pourra reprendre son exécution là où elle s’était arrêtée, sans perdre son contexte.

'''''task[currentTask].stackPointer = SP''''' permet de sauvegarder le pointeur de pile de la tâche associée.

'''''scheduler()''''' est expliqué [[SE4Binome2024-3#Code de l'ordonnanceur|ici]].

'''''SP = task[currentTask].stackPointer''''' permet de replacer le pointeur de pile à celui de la nouvelle tâche engendrée par le scheduler.

La macro '''''RESTORE_REGISTERS()''''' remets la nouvelle fonction sur les 32 registres avec des Pop().

'''''asm volatile ( "reti" )''''' : étant en ISR_NAKED, il faut dire manuellement la fin de l'interruption avec cette commande assembleur '''RETurn from Interrupt'''.

=== Structure d'une tâche ===
<syntaxhighlight lang="c">
enum States{
AWAKE,
IDLE
};

enum IDLE_TYPE{
IDLE_TYPE_DELAY,
IDLE_TYPE_STABLE
};

typedef union {
int sleeping_time;
} Time;

typedef struct {
enum IDLE_TYPE type;
Time time;
} Etat ;

typedef struct{
uint16_t stackPointer; // stack pointer, défini le début du process
void (*addressFunction)(void); // adresse de l'instruction en cours
enum States state; // état de la fonction (Awake ou Idle)
Etat etat;
}process;
</syntaxhighlight>

Les tâches sont définies par leurs pointeurs de piles, leurs adresses, un état qui est soit IDLE ou AWAKE et enfin un dernier état qui lui gère permet d'avoir différent type d'IDLE.

L'utilisation d'[[wikipedia:Union_type#C/C++|unions]] n'est pas forcément justifiée ici mais permet de limiter la place que va prendre la structure dans l'optique de futures implémentations.

=== Code de l'ordonnanceur ===
<syntaxhighlight lang="c">
void scheduler(){

// décrémentation de l'attente de toutes les tâches en IDLE
for(int i=0;i<NB_TASKS;i++){
if(task[i].state==IDLE && (task[i].etat.type==IDLE_TYPE_DELAY)){
task[i].etat.time.sleeping_time -= PERIODE;
if(task[i].etat.time.sleeping_time <= 0){
task[i].etat.time.sleeping_time = 0;
task[i].state = AWAKE;
}
}
}
do{
currentTask ++;
if(currentTask >= NB_TASKS) currentTask = 0; // ordonnanceur en mode Round Robin
}while(task[currentTask].state == IDLE);
}
</syntaxhighlight>

L'ordonnanceur est en mode [https://fr.wikipedia.org/wiki/Round-robin_(informatique) Round Robin] (tourniquet) ce qui veut dire qu'il n'y a pas de priorité de tâche, elles sont toutes appelées une à une dans l'ordre avant de boucler et ainsi de suite...

L'un des ajouts a été de mettre un mode IDLE à nos tâches qui indique la veille de ces dernières. Si une tâche est en IDLE, elle ne sera pas appelée lors de la sélection des tâches et son temps de sommeil sera décrémenté. Cela permet de créer des attentes passives donc d'éviter d'attendre inutilement des tâches qui ne font qu'attendre. On bon exemple pour comprendre serait avec un [[SE4Binome2024-3#Exemple de tâches|clignotement de LED]]. Au lieu de mettre un _delay_ms(1000) qui éxecutera une attente à chaque fois que cette tâche est appelée, on la passe pendant 1000 ms ce qui permet d'éxécuter d'autres tâches entre temps.

=== Fonction wait ===
<syntaxhighlight lang="c" line="1">
void wait(int time_ms){
task[currentTask].state = IDLE;
task[currentTask].etat.type=IDLE_TYPE_DELAY;
task[currentTask].etat.time.sleeping_time = time_ms;
TCNT1 = 0;
TIMER1_COMPA_vect();
}
</syntaxhighlight>

La fonction permet d'endormir un processus pendant un temps donné en ms.

Elle passe la tâche en IDLE, remet le '''Timer1''' à zéro pour éviter de garder un décalage de temps car le changement est surement fait en plein milieu d'une tâche.

Et ensuite elle appelle l'interruption pour qu'une nouvelle tâche soit en cours.

=== Exemple de tâches ===
<syntaxhighlight lang="c" line="1">
void USART_Init(unsigned int ubrr)
{
/*Set baud rate */
UBRR0H = (unsigned char)(ubrr>>8);
UBRR0L = (unsigned char)ubrr;
/*Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Set frame format: 8data, 2stop bit */
UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}
</syntaxhighlight><syntaxhighlight lang="c">
void LED_init(){
DDRC |= (1<<LED1) | (1<<LED2);
DDRD |= (1<<LED3) | (1<<LED4) | (1<<LED5);
PORTC |= (1<<LED1)|(1<<LED2);
PORTD |= (1<<LED3)|(1<<LED4)|(1<<LED5);
}

void LED1_blink(){
while(1){
PORTC ^= (1<<LED1);
_delay_ms(1000);
}
}

void LED2_blink(){
while(1){
PORTC ^= (1<<LED2);
wait(100);
}
}
</syntaxhighlight>

<syntaxhighlight lang="c">
void Serial_Message(){
unsigned char data;
while(1){
data = USART_Receive();
USART_Transmit(data);
}
}

void USART_Transmit(unsigned char data)
{
/* Wait for empty transmit buffer */
while (!(UCSR0A & (1<<UDRE0)))
;
/* Put data into buffer, sends the data */
UDR0 = data;
}

unsigned char USART_Receive(void)
{
/* Wait for data to be received */
while (!(UCSR0A & (1<<RXC0)))
;
/* Get and return received data from buffer */
return UDR0;
}
</syntaxhighlight><syntaxhighlight lang="c">
void spi_activer(void){ // Activer le périphérique
PORTD &= ~(1<<SPI_SS); // Ligne SS à l'état bas
}

void spi_desactiver(void){ // Désactiver le périphérique
PORTD |= (1<<SPI_SS); // Ligne SS à l'état haut
}

uint8_t spi_echange(uint8_t envoi){ // Communication sur le bus SPI
SPDR = envoi; // Octet a envoyer
while(!(SPSR & (1<<SPIF))); // Attente fin envoi (drapeau SPIF du statut)
return SPDR; // Octet reçu
}

void seven_seg(){
while(1){
spi_activer();
spi_echange(0x01);
spi_desactiver();
}
}
</syntaxhighlight>

=== Exemple d'utilisation ===

==== Clignotement de 5 Leds asynchrones ====
[[Fichier:Clignotement 5 leds .mp4|sans_cadre]]

==== Affichage clavier avec minicom ====
[[Fichier:Affichage clavier minicom.mp4|sans_cadre]]

== Création mémoire sur carte SD ==

=== Schéma de fonctionnement de la mémoire ===
[[Fichier:Gestion memoire sd.png|sans_cadre|770x770px]]

=== Récupération des commandes de base ===

Dans un premier temps, nous avons un programme qui permet à la carte de mère de reconnaitre 3 commandes: ls, rm et cp. Cela nous permettra par la suite de créer des fichiers, les supprimer et lire les fichiers présents dans le répertoire. <syntaxhighlight lang="c">
int main(){
init_stdio();
char data[Max_chaine],cmd[Max_chaine], arg1[Max_chaine],arg2[Max_chaine];
while(1) {
fgets(data,Max_chaine,stdin);
fprintf(stdout,"\r");
fflush(stdout);
int taille = sscanf(data,"%s %s %s", cmd,arg1,arg2);
if(taille != 0){
switch(taille){
case 1 :
if(strcmp(cmd,"ls") == 0) fprintf(stdout,"je suis un ls\n");
else fprintf(stdout,"je suis une fraude\n");
break;
case 2 :
if(strcmp(cmd,"rm") == 0) fprintf(stdout,"je suis un rm\n mon arg est : %s \n",arg1);
else fprintf(stdout,"je suis une fraude\n");
break;
case 3:
if(strcmp(cmd,"cp") == 0) {
fprintf(stdout,"je suis un cp\n");
fprintf(stdout,"mon arg1 est : %s\n",arg1);
fprintf(stdout,"mon arg2 est : %s\n",arg2);}
else fprintf(stdout,"je suis une fraude\n");
break;
}
}
}
}
</syntaxhighlight>

Lors de l'utilisation de minicom, le fgets ne s'exécute que lors d'un "/n", cependant, un entrée sur le clavier correspond à un "/r", nous avons donc converti chaque "/r" en "/n" dans notre fonction de scan pour fluidifier l'utilisation.

<syntaxhighlight lang="c">
static int get_serial_scanf(FILE *stream) {
static unsigned char nl=0;
if(stream==stdin){
if(nl){ nl=0; return '\n'; }
char c=get_serial();
if(c=='\r') nl=1;
return c;
}
return _FDEV_EOF;
}
</syntaxhighlight>

À l'inverse, lors d'un fprintf, il est naturel en C de placer un "/n" à la fin d'une chaine de caractère. Cependant, la carte mère à besoin d'un "\r" pour effectuer ce retour à la ligne. Nous avons donc converti chaque "\n" en "\r" dans notre fonction d'impression.

<syntaxhighlight lang="c">
static int send_serial_printf(char c,FILE *stream){
if(stream==stdout){
if(c=='\n') send_serial('\r');
send_serial(c);
}
return 0;
}
</syntaxhighlight>

=== Création d'un fichier ===
Nous sommes capable maintenant d'écrire le nom d'un fichier dans un bloc.<syntaxhighlight lang="c">
void createFile(SD_files* fichier){
//write à 0 le nom puis les data pares
uint8_t name[TAILLE_NOM];
string_to_uint8_array(fichier->name, name);
int statut=writeBlock(&sd,LastFile,name);
if(statut != 1) fprintf(stdout,"erreur lors du Write\n");
LastFile += NB_BLOCK_MAX;
}
</syntaxhighlight>

== Bilan de puissance ==
Afin d'être sûr de l'alimentation de toutes les cartes, nous utilisons une alimentation +5V d'une Raspberry PI branchée sur secteur.
{| class="wikitable"
|+
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (VCC = 3.3V)
|-
!Composant
!Courant
!Puissance
|-
|74LVC125
|40 uA
|0.2mW
|-
|Carte SD
|100 mA
|330 mW
|-
|'''TOTAL'''
|'''100,04 mA'''
|'''330.2 mW'''
|}
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (Vcc = 5V)
|-
!Composant
!Courant
!Puissance
|-
|AtMega328p
|14mA
|70mW
|-
|ATMega8U2
|21mA
|105mW
|-
|5xLED
|5*5mA
|5*25 mW
|-
|'''TOTAL'''
|'''60mA'''
|'''300 mW'''
|}
!
{| class="wikitable"
|+
! colspan="2" |Bilan de puissance général du groupe
|-
!CARTE
!PUISSANCE (maximale)
|-
|Mère
|0,63W
|-
|Clavier
|5,55W
|-
|Réseau
|0,15W
|-
|Ecran
|0,17W
|-
|'''TOTAL'''
|'''2,685W'''
|}
|}

== Liens ==
Lien du git : https://gitea.plil.fr/vdetrez/SE4_PICO_DETREZ_CART

Fichier:Gestion memoire sd.png

2025-01-25T12:13:39Z

Vdetrez :

SE4Binome2024-3

2025-01-08T11:06:53Z

Vdetrez : /* Schéma de fonctionnement de la mémoire */

[[Fichier:Titre page pico carte mère cart detrez.png|centré|sans_cadre|972x972px]]

== Description ==
L'objectif de ce projet est de réaliser un pico ordinateur. Nous allons traiter le développement de la carte mère, un shield arduino ainsi que la programmation d'un ordonnanceur.

Notre carte mère sera alimenté via une alimentation secteur en 5v et le code sera implanté par USB.

== Réalisation d'un shield arduino ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:PicoShield SCH Detrez Cart.pdf|sans_cadre|639x639px]]
![[Fichier:Routage shield CART DETREZ.png|sans_cadre|638x638px]]
|}

=== PINOUT ===
{| class="wikitable"
|+
|LED1
|PC0
|-
|LED2
|PC3
|-
|LED3
|PD1
|-
|LED4
|PD4
|-
|LED5
|PD7
|}

=== Brasage du shield ===

==== shield nu ====
[[Fichier:Shield nu CART DETREZ 2.jpg|sans_cadre]]

==== shield fini ====
[[Fichier:Shield fini CART DETREZ.jpg|sans_cadre]]

=== Test du shield ===
[[Fichier:Affichage 7 segments DETREZ CART.jpg|sans_cadre]]

== Réalisation carte mère ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:Schématique Carte mere CART DETREZ.pdf|centré|sans_cadre|679x679px]]
![[Fichier:Schématique Carte mere .png|centré|sans_cadre|575x575px]]
|}

=== Brasage carte mère ===

==== carte mère nue ====
[[Fichier:PCB_carte_mère_nu.jpg|sans_cadre]]

==== ajout ATmega 328p ====
[[Fichier:Brasage ATmega 328p carte mère.jpg|sans_cadre]]

==== ajout ATmega 8U2 ====
[[Fichier:Carte mère G3 avec 8U2.jpg|sans_cadre]]

==== mise en lien des ATmega et correction de conception ====
La correction consiste en l'ajout d'un bouton reset et HWB pour l'ATmega8U2.

[[Fichier:Lien ATmega + correction.jpg|sans_cadre]]

==== carte finale ====
[[Fichier:Carte mere finale detrez cart 2.jpg|sans_cadre]]

=== Tests ===

==== Test de clignotement d'une LED (25ms) ====
[[Fichier:Test clignotement LED ATmega 328p .mp4|sans_cadre]]

=== Programmation des cartes ===

27/11/24 : pour le moment le µc atmega328p a réussi à être programmé par ISP en changeant les fuses grâce à avrdude. En revanche, impossible de programmer l'atmega8u2. Nous avons essayé de lui mettre un bootloader et de changer ses fuses mais c'est impossible dans les deux cas et la carte n'est donc pas détectée en USB.

4/12/24 : nous avons réussi à mettre un bootloader dans le 8u2, en revanche nous n'arrivons toujours pas à programmer le 328p grâce au port USB. La cause : nous n'arrivons pas à burn le bootloader du 328p pour qu'il puisse recevoir des données via usb_série ...

Solution trouvée : Nous avons changé le bootloader en mettant [https://github.com/Optiboot/optiboot/blob/master/optiboot/bootloaders/optiboot/optiboot_atmega328.hex celui-ci] (/usr/share/arduino/hardware/arduino/avr/bootloaders/optiboot) à la place pour augmenter la place de ce dernier. Maintenant le 328p peut être programmé grâce à l'USB.

== Programmation ordonnanceur ==

=== Initialisation de la pile ===
<syntaxhighlight lang="c">
void init_pile(int N){
uint16_t tempSP = SP;
SP = task[N].stackPointer;
uint16_t adresse=(uint16_t)task[N].addressFunction;
asm volatile("push %0" : : "r" (adresse & 0x00ff) );
asm volatile("push %0" : : "r" ((adresse & 0xff00)>>8) );
SAVE_REGISTERS();
task[N].stackPointer = SP;
SP = tempSP;
}
</syntaxhighlight>La fonction init_pile() sert à charger un processus dans la pile. Cette fonction est appelée dans une boucle au début du main pour initialiser tous les processus.

=== Interruption de l'ordonnanceur ===
L'ordonnanceur est appelé à un interval de temps régulier grâce à des interruptions du Timer1.

Avant de passer d'une tâche à une autre (mode Round Robin) il faut d'abord effectuer quelques opérations sur la mémoire du micro-processeur.<syntaxhighlight lang="c">
ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
/* Sauvegarde du contexte de la tâche interrompue */
SAVE_REGISTERS();
task[currentTask].stackPointer = SP;
/* Appel à l'ordonnanceur */
scheduler();
/* Récupération du contexte de la tâche ré-activée */
SP = task[currentTask].stackPointer;
RESTORE_REGISTERS();
asm volatile ( "reti" );
}
</syntaxhighlight>La routine d'interruption est générée par le '''Timer1''' avec comme paramètre ISR_NAKED qui permet de ne pas avoir le prologue et l'épilogue automatique du compilateur ce qui nous est très utile pour gérer manuellement ces interruptions afin d'éxecuter nos tâches.

La macro '''''SAVE_REGISTERS()''''' nous permet de sauvegarder les 32 registres sur la pile. Cela permet de s’assurer qu’au retour de l'interruption, la tâche interrompue pourra reprendre son exécution là où elle s’était arrêtée, sans perdre son contexte.

'''''task[currentTask].stackPointer = SP''''' permet de sauvegarder le pointeur de pile de la tâche associée.

'''''scheduler()''''' est expliqué [[SE4Binome2024-3#Code de l'ordonnanceur|ici]].

'''''SP = task[currentTask].stackPointer''''' permet de replacer le pointeur de pile à celui de la nouvelle tâche engendrée par le scheduler.

La macro '''''RESTORE_REGISTERS()''''' remets la nouvelle fonction sur les 32 registres avec des Pop().

'''''asm volatile ( "reti" )''''' : étant en ISR_NAKED, il faut dire manuellement la fin de l'interruption avec cette commande assembleur '''RETurn from Interrupt'''.

=== Structure d'une tâche ===
<syntaxhighlight lang="c">
enum States{
AWAKE,
IDLE
};

enum IDLE_TYPE{
IDLE_TYPE_DELAY,
IDLE_TYPE_STABLE
};

typedef union {
int sleeping_time;
} Time;

typedef struct {
enum IDLE_TYPE type;
Time time;
} Etat ;

typedef struct{
uint16_t stackPointer; // stack pointer, défini le début du process
void (*addressFunction)(void); // adresse de l'instruction en cours
enum States state; // état de la fonction (Awake ou Idle)
Etat etat;
}process;
</syntaxhighlight>

Les tâches sont définies par leurs pointeurs de piles, leurs adresses, un état qui est soit IDLE ou AWAKE et enfin un dernier état qui lui gère permet d'avoir différent type d'IDLE.

L'utilisation d'[[wikipedia:Union_type#C/C++|unions]] n'est pas forcément justifiée ici mais permet de limiter la place que va prendre la structure dans l'optique de futures implémentations.

=== Code de l'ordonnanceur ===
<syntaxhighlight lang="c">
void scheduler(){

// décrémentation de l'attente de toutes les tâches en IDLE
for(int i=0;i<NB_TASKS;i++){
if(task[i].state==IDLE && (task[i].etat.type==IDLE_TYPE_DELAY)){
task[i].etat.time.sleeping_time -= PERIODE;
if(task[i].etat.time.sleeping_time <= 0){
task[i].etat.time.sleeping_time = 0;
task[i].state = AWAKE;
}
}
}
do{
currentTask ++;
if(currentTask >= NB_TASKS) currentTask = 0; // ordonnanceur en mode Round Robin
}while(task[currentTask].state == IDLE);
}
</syntaxhighlight>

L'ordonnanceur est en mode [https://fr.wikipedia.org/wiki/Round-robin_(informatique) Round Robin] (tourniquet) ce qui veut dire qu'il n'y a pas de priorité de tâche, elles sont toutes appelées une à une dans l'ordre avant de boucler et ainsi de suite...

L'un des ajouts a été de mettre un mode IDLE à nos tâches qui indique la veille de ces dernières. Si une tâche est en IDLE, elle ne sera pas appelée lors de la sélection des tâches et son temps de sommeil sera décrémenté. Cela permet de créer des attentes passives donc d'éviter d'attendre inutilement des tâches qui ne font qu'attendre. On bon exemple pour comprendre serait avec un [[SE4Binome2024-3#Exemple de tâches|clignotement de LED]]. Au lieu de mettre un _delay_ms(1000) qui éxecutera une attente à chaque fois que cette tâche est appelée, on la passe pendant 1000 ms ce qui permet d'éxécuter d'autres tâches entre temps.

=== Fonction wait ===
<syntaxhighlight lang="c" line="1">
void wait(int time_ms){
task[currentTask].state = IDLE;
task[currentTask].etat.type=IDLE_TYPE_DELAY;
task[currentTask].etat.time.sleeping_time = time_ms;
TCNT1 = 0;
TIMER1_COMPA_vect();
}
</syntaxhighlight>

La fonction permet d'endormir un processus pendant un temps donné en ms.

Elle passe la tâche en IDLE, remet le '''Timer1''' à zéro pour éviter de garder un décalage de temps car le changement est surement fait en plein milieu d'une tâche.

Et ensuite elle appelle l'interruption pour qu'une nouvelle tâche soit en cours.

=== Exemple de tâches ===
<syntaxhighlight lang="c" line="1">
void USART_Init(unsigned int ubrr)
{
/*Set baud rate */
UBRR0H = (unsigned char)(ubrr>>8);
UBRR0L = (unsigned char)ubrr;
/*Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Set frame format: 8data, 2stop bit */
UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}
</syntaxhighlight><syntaxhighlight lang="c">
void LED_init(){
DDRC |= (1<<LED1) | (1<<LED2);
DDRD |= (1<<LED3) | (1<<LED4) | (1<<LED5);
PORTC |= (1<<LED1)|(1<<LED2);
PORTD |= (1<<LED3)|(1<<LED4)|(1<<LED5);
}

void LED1_blink(){
while(1){
PORTC ^= (1<<LED1);
_delay_ms(1000);
}
}

void LED2_blink(){
while(1){
PORTC ^= (1<<LED2);
wait(100);
}
}
</syntaxhighlight>

<syntaxhighlight lang="c">
void Serial_Message(){
unsigned char data;
while(1){
data = USART_Receive();
USART_Transmit(data);
}
}

void USART_Transmit(unsigned char data)
{
/* Wait for empty transmit buffer */
while (!(UCSR0A & (1<<UDRE0)))
;
/* Put data into buffer, sends the data */
UDR0 = data;
}

unsigned char USART_Receive(void)
{
/* Wait for data to be received */
while (!(UCSR0A & (1<<RXC0)))
;
/* Get and return received data from buffer */
return UDR0;
}
</syntaxhighlight><syntaxhighlight lang="c">
void spi_activer(void){ // Activer le périphérique
PORTD &= ~(1<<SPI_SS); // Ligne SS à l'état bas
}

void spi_desactiver(void){ // Désactiver le périphérique
PORTD |= (1<<SPI_SS); // Ligne SS à l'état haut
}

uint8_t spi_echange(uint8_t envoi){ // Communication sur le bus SPI
SPDR = envoi; // Octet a envoyer
while(!(SPSR & (1<<SPIF))); // Attente fin envoi (drapeau SPIF du statut)
return SPDR; // Octet reçu
}

void seven_seg(){
while(1){
spi_activer();
spi_echange(0x01);
spi_desactiver();
}
}
</syntaxhighlight>

=== Exemple d'utilisation ===

==== Clignotement de 5 Leds asynchrones ====
[[Fichier:Clignotement 5 leds .mp4|sans_cadre]]

==== Affichage clavier avec minicom ====
[[Fichier:Affichage clavier minicom.mp4|sans_cadre]]

== Création mémoire sur carte SD ==

=== Schéma de fonctionnement de la mémoire ===
(à modifier)

[[Fichier:Gestion memoire detrez cart.png|sans_cadre|770x770px]]

=== Récupération des commandes de base ===

Dans un premier temps, nous avons un programme qui permet à la carte de mère de reconnaitre 3 commandes: ls, rm et cp. Cela nous permettra par la suite de créer des fichiers, les supprimer et lire les fichiers présents dans le répertoire. <syntaxhighlight lang="c">
int main(){
init_stdio();
char data[Max_chaine],cmd[Max_chaine], arg1[Max_chaine],arg2[Max_chaine];
while(1) {
fgets(data,Max_chaine,stdin);
fprintf(stdout,"\r");
fflush(stdout);
int taille = sscanf(data,"%s %s %s", cmd,arg1,arg2);
if(taille != 0){
switch(taille){
case 1 :
if(strcmp(cmd,"ls") == 0) fprintf(stdout,"je suis un ls\n");
else fprintf(stdout,"je suis une fraude\n");
break;
case 2 :
if(strcmp(cmd,"rm") == 0) fprintf(stdout,"je suis un rm\n mon arg est : %s \n",arg1);
else fprintf(stdout,"je suis une fraude\n");
break;
case 3:
if(strcmp(cmd,"cp") == 0) {
fprintf(stdout,"je suis un cp\n");
fprintf(stdout,"mon arg1 est : %s\n",arg1);
fprintf(stdout,"mon arg2 est : %s\n",arg2);}
else fprintf(stdout,"je suis une fraude\n");
break;
}
}
}
}
</syntaxhighlight>

Lors de l'utilisation de minicom, le fgets ne s'exécute que lors d'un "/n", cependant, un entrée sur le clavier correspond à un "/r", nous avons donc converti chaque "/r" en "/n" dans notre fonction de scan pour fluidifier l'utilisation.

<syntaxhighlight lang="c">
static int get_serial_scanf(FILE *stream) {
static unsigned char nl=0;
if(stream==stdin){
if(nl){ nl=0; return '\n'; }
char c=get_serial();
if(c=='\r') nl=1;
return c;
}
return _FDEV_EOF;
}
</syntaxhighlight>

À l'inverse, lors d'un fprintf, il est naturel en C de placer un "/n" à la fin d'une chaine de caractère. Cependant, la carte mère à besoin d'un "\r" pour effectuer ce retour à la ligne. Nous avons donc converti chaque "\n" en "\r" dans notre fonction d'impression.

<syntaxhighlight lang="c">
static int send_serial_printf(char c,FILE *stream){
if(stream==stdout){
if(c=='\n') send_serial('\r');
send_serial(c);
}
return 0;
}
</syntaxhighlight>

=== Création d'un fichier ===
Nous sommes capable maintenant d'écrire le nom d'un fichier dans un bloc.<syntaxhighlight lang="c">
void createFile(SD_files* fichier){
//write à 0 le nom puis les data pares
uint8_t name[TAILLE_NOM];
string_to_uint8_array(fichier->name, name);
int statut=writeBlock(&sd,LastFile,name);
if(statut != 1) fprintf(stdout,"erreur lors du Write\n");
LastFile += NB_BLOCK_MAX;
}
</syntaxhighlight>

== Bilan de puissance ==
Afin d'être sûr de l'alimentation de toutes les cartes, nous utilisons une alimentation +5V d'une Raspberry PI branchée sur secteur.
{| class="wikitable"
|+
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (VCC = 3.3V)
|-
!Composant
!Courant
!Puissance
|-
|74LVC125
|40 uA
|0.2mW
|-
|Carte SD
|100 mA
|330 mW
|-
|'''TOTAL'''
|'''100,04 mA'''
|'''330.2 mW'''
|}
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (Vcc = 5V)
|-
!Composant
!Courant
!Puissance
|-
|AtMega328p
|14mA
|70mW
|-
|ATMega8U2
|21mA
|105mW
|-
|5xLED
|5*5mA
|5*25 mW
|-
|'''TOTAL'''
|'''60mA'''
|'''300 mW'''
|}
!
{| class="wikitable"
|+
! colspan="2" |Bilan de puissance général du groupe
|-
!CARTE
!PUISSANCE (maximale)
|-
|Mère
|0,63W
|-
|Clavier
|5,55W
|-
|Réseau
|0,15W
|-
|Ecran
|0,17W
|-
|'''TOTAL'''
|'''2,685W'''
|}
|}

== Liens ==
Lien du git : https://gitea.plil.fr/vdetrez/SE4_PICO_DETREZ_CART

SE4Binome2024-3

2025-01-08T10:24:25Z

Vdetrez : /* Création mémoire sur carte SD */

[[Fichier:Titre page pico carte mère cart detrez.png|centré|sans_cadre|972x972px]]

== Description ==
L'objectif de ce projet est de réaliser un pico ordinateur. Nous allons traiter le développement de la carte mère, un shield arduino ainsi que la programmation d'un ordonnanceur.

Notre carte mère sera alimenté via une alimentation secteur en 5v et le code sera implanté par USB.

== Réalisation d'un shield arduino ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:PicoShield SCH Detrez Cart.pdf|sans_cadre|639x639px]]
![[Fichier:Routage shield CART DETREZ.png|sans_cadre|638x638px]]
|}

=== PINOUT ===
{| class="wikitable"
|+
|LED1
|PC0
|-
|LED2
|PC3
|-
|LED3
|PD1
|-
|LED4
|PD4
|-
|LED5
|PD7
|}

=== Brasage du shield ===

==== shield nu ====
[[Fichier:Shield nu CART DETREZ 2.jpg|sans_cadre]]

==== shield fini ====
[[Fichier:Shield fini CART DETREZ.jpg|sans_cadre]]

=== Test du shield ===
[[Fichier:Affichage 7 segments DETREZ CART.jpg|sans_cadre]]

== Réalisation carte mère ==

=== Schématique et routage ===
{| class="wikitable"
|+
![[Fichier:Schématique Carte mere CART DETREZ.pdf|centré|sans_cadre|679x679px]]
![[Fichier:Schématique Carte mere .png|centré|sans_cadre|575x575px]]
|}

=== Brasage carte mère ===

==== carte mère nue ====
[[Fichier:PCB_carte_mère_nu.jpg|sans_cadre]]

==== ajout ATmega 328p ====
[[Fichier:Brasage ATmega 328p carte mère.jpg|sans_cadre]]

==== ajout ATmega 8U2 ====
[[Fichier:Carte mère G3 avec 8U2.jpg|sans_cadre]]

==== mise en lien des ATmega et correction de conception ====
La correction consiste en l'ajout d'un bouton reset et HWB pour l'ATmega8U2.

[[Fichier:Lien ATmega + correction.jpg|sans_cadre]]

==== carte finale ====
[[Fichier:Carte mere finale detrez cart 2.jpg|sans_cadre]]

=== Tests ===

==== Test de clignotement d'une LED (25ms) ====
[[Fichier:Test clignotement LED ATmega 328p .mp4|sans_cadre]]

=== Programmation des cartes ===

27/11/24 : pour le moment le µc atmega328p a réussi à être programmé par ISP en changeant les fuses grâce à avrdude. En revanche, impossible de programmer l'atmega8u2. Nous avons essayé de lui mettre un bootloader et de changer ses fuses mais c'est impossible dans les deux cas et la carte n'est donc pas détectée en USB.

4/12/24 : nous avons réussi à mettre un bootloader dans le 8u2, en revanche nous n'arrivons toujours pas à programmer le 328p grâce au port USB. La cause : nous n'arrivons pas à burn le bootloader du 328p pour qu'il puisse recevoir des données via usb_série ...

Solution trouvée : Nous avons changé le bootloader en mettant [https://github.com/Optiboot/optiboot/blob/master/optiboot/bootloaders/optiboot/optiboot_atmega328.hex celui-ci] (/usr/share/arduino/hardware/arduino/avr/bootloaders/optiboot) à la place pour augmenter la place de ce dernier. Maintenant le 328p peut être programmé grâce à l'USB.

== Programmation ordonnanceur ==

=== Initialisation de la pile ===
<syntaxhighlight lang="c">
void init_pile(int N){
uint16_t tempSP = SP;
SP = task[N].stackPointer;
uint16_t adresse=(uint16_t)task[N].addressFunction;
asm volatile("push %0" : : "r" (adresse & 0x00ff) );
asm volatile("push %0" : : "r" ((adresse & 0xff00)>>8) );
SAVE_REGISTERS();
task[N].stackPointer = SP;
SP = tempSP;
}
</syntaxhighlight>La fonction init_pile() sert à charger un processus dans la pile. Cette fonction est appelée dans une boucle au début du main pour initialiser tous les processus.

=== Interruption de l'ordonnanceur ===
L'ordonnanceur est appelé à un interval de temps régulier grâce à des interruptions du Timer1.

Avant de passer d'une tâche à une autre (mode Round Robin) il faut d'abord effectuer quelques opérations sur la mémoire du micro-processeur.<syntaxhighlight lang="c">
ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
/* Sauvegarde du contexte de la tâche interrompue */
SAVE_REGISTERS();
task[currentTask].stackPointer = SP;
/* Appel à l'ordonnanceur */
scheduler();
/* Récupération du contexte de la tâche ré-activée */
SP = task[currentTask].stackPointer;
RESTORE_REGISTERS();
asm volatile ( "reti" );
}
</syntaxhighlight>La routine d'interruption est générée par le '''Timer1''' avec comme paramètre ISR_NAKED qui permet de ne pas avoir le prologue et l'épilogue automatique du compilateur ce qui nous est très utile pour gérer manuellement ces interruptions afin d'éxecuter nos tâches.

La macro '''''SAVE_REGISTERS()''''' nous permet de sauvegarder les 32 registres sur la pile. Cela permet de s’assurer qu’au retour de l'interruption, la tâche interrompue pourra reprendre son exécution là où elle s’était arrêtée, sans perdre son contexte.

'''''task[currentTask].stackPointer = SP''''' permet de sauvegarder le pointeur de pile de la tâche associée.

'''''scheduler()''''' est expliqué [[SE4Binome2024-3#Code de l'ordonnanceur|ici]].

'''''SP = task[currentTask].stackPointer''''' permet de replacer le pointeur de pile à celui de la nouvelle tâche engendrée par le scheduler.

La macro '''''RESTORE_REGISTERS()''''' remets la nouvelle fonction sur les 32 registres avec des Pop().

'''''asm volatile ( "reti" )''''' : étant en ISR_NAKED, il faut dire manuellement la fin de l'interruption avec cette commande assembleur '''RETurn from Interrupt'''.

=== Structure d'une tâche ===
<syntaxhighlight lang="c">
enum States{
AWAKE,
IDLE
};

enum IDLE_TYPE{
IDLE_TYPE_DELAY,
IDLE_TYPE_STABLE
};

typedef union {
int sleeping_time;
} Time;

typedef struct {
enum IDLE_TYPE type;
Time time;
} Etat ;

typedef struct{
uint16_t stackPointer; // stack pointer, défini le début du process
void (*addressFunction)(void); // adresse de l'instruction en cours
enum States state; // état de la fonction (Awake ou Idle)
Etat etat;
}process;
</syntaxhighlight>

Les tâches sont définies par leurs pointeurs de piles, leurs adresses, un état qui est soit IDLE ou AWAKE et enfin un dernier état qui lui gère permet d'avoir différent type d'IDLE.

L'utilisation d'[[wikipedia:Union_type#C/C++|unions]] n'est pas forcément justifiée ici mais permet de limiter la place que va prendre la structure dans l'optique de futures implémentations.

=== Code de l'ordonnanceur ===
<syntaxhighlight lang="c">
void scheduler(){

// décrémentation de l'attente de toutes les tâches en IDLE
for(int i=0;i<NB_TASKS;i++){
if(task[i].state==IDLE && (task[i].etat.type==IDLE_TYPE_DELAY)){
task[i].etat.time.sleeping_time -= PERIODE;
if(task[i].etat.time.sleeping_time <= 0){
task[i].etat.time.sleeping_time = 0;
task[i].state = AWAKE;
}
}
}
do{
currentTask ++;
if(currentTask >= NB_TASKS) currentTask = 0; // ordonnanceur en mode Round Robin
}while(task[currentTask].state == IDLE);
}
</syntaxhighlight>

L'ordonnanceur est en mode [https://fr.wikipedia.org/wiki/Round-robin_(informatique) Round Robin] (tourniquet) ce qui veut dire qu'il n'y a pas de priorité de tâche, elles sont toutes appelées une à une dans l'ordre avant de boucler et ainsi de suite...

L'un des ajouts a été de mettre un mode IDLE à nos tâches qui indique la veille de ces dernières. Si une tâche est en IDLE, elle ne sera pas appelée lors de la sélection des tâches et son temps de sommeil sera décrémenté. Cela permet de créer des attentes passives donc d'éviter d'attendre inutilement des tâches qui ne font qu'attendre. On bon exemple pour comprendre serait avec un [[SE4Binome2024-3#Exemple de tâches|clignotement de LED]]. Au lieu de mettre un _delay_ms(1000) qui éxecutera une attente à chaque fois que cette tâche est appelée, on la passe pendant 1000 ms ce qui permet d'éxécuter d'autres tâches entre temps.

=== Fonction wait ===
<syntaxhighlight lang="c" line="1">
void wait(int time_ms){
task[currentTask].state = IDLE;
task[currentTask].etat.type=IDLE_TYPE_DELAY;
task[currentTask].etat.time.sleeping_time = time_ms;
TCNT1 = 0;
TIMER1_COMPA_vect();
}
</syntaxhighlight>

La fonction permet d'endormir un processus pendant un temps donné en ms.

Elle passe la tâche en IDLE, remet le '''Timer1''' à zéro pour éviter de garder un décalage de temps car le changement est surement fait en plein milieu d'une tâche.

Et ensuite elle appelle l'interruption pour qu'une nouvelle tâche soit en cours.

=== Exemple de tâches ===
<syntaxhighlight lang="c" line="1">
void USART_Init(unsigned int ubrr)
{
/*Set baud rate */
UBRR0H = (unsigned char)(ubrr>>8);
UBRR0L = (unsigned char)ubrr;
/*Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Set frame format: 8data, 2stop bit */
UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}
</syntaxhighlight><syntaxhighlight lang="c">
void LED_init(){
DDRC |= (1<<LED1) | (1<<LED2);
DDRD |= (1<<LED3) | (1<<LED4) | (1<<LED5);
PORTC |= (1<<LED1)|(1<<LED2);
PORTD |= (1<<LED3)|(1<<LED4)|(1<<LED5);
}

void LED1_blink(){
while(1){
PORTC ^= (1<<LED1);
_delay_ms(1000);
}
}

void LED2_blink(){
while(1){
PORTC ^= (1<<LED2);
wait(100);
}
}
</syntaxhighlight>

<syntaxhighlight lang="c">
void Serial_Message(){
unsigned char data;
while(1){
data = USART_Receive();
USART_Transmit(data);
}
}

void USART_Transmit(unsigned char data)
{
/* Wait for empty transmit buffer */
while (!(UCSR0A & (1<<UDRE0)))
;
/* Put data into buffer, sends the data */
UDR0 = data;
}

unsigned char USART_Receive(void)
{
/* Wait for data to be received */
while (!(UCSR0A & (1<<RXC0)))
;
/* Get and return received data from buffer */
return UDR0;
}
</syntaxhighlight><syntaxhighlight lang="c">
void spi_activer(void){ // Activer le périphérique
PORTD &= ~(1<<SPI_SS); // Ligne SS à l'état bas
}

void spi_desactiver(void){ // Désactiver le périphérique
PORTD |= (1<<SPI_SS); // Ligne SS à l'état haut
}

uint8_t spi_echange(uint8_t envoi){ // Communication sur le bus SPI
SPDR = envoi; // Octet a envoyer
while(!(SPSR & (1<<SPIF))); // Attente fin envoi (drapeau SPIF du statut)
return SPDR; // Octet reçu
}

void seven_seg(){
while(1){
spi_activer();
spi_echange(0x01);
spi_desactiver();
}
}
</syntaxhighlight>

=== Exemple d'utilisation ===

==== Clignotement de 5 Leds asynchrones ====
[[Fichier:Clignotement 5 leds .mp4|sans_cadre]]

==== Affichage clavier avec minicom ====
[[Fichier:Affichage clavier minicom.mp4|sans_cadre]]

== Création mémoire sur carte SD ==

=== Schéma de fonctionnement de la mémoire ===
[[Fichier:Gestion memoire detrez cart.png|sans_cadre|770x770px]]

=== Récupération des commandes de base ===

Dans un premier temps, nous avons un programme qui permet à la carte de mère de reconnaitre 3 commandes: ls, rm et cp. Cela nous permettra par la suite de créer des fichiers, les supprimer et lire les fichiers présents dans le répertoire. <syntaxhighlight lang="c">
int main(){
init_stdio();
char data[Max_chaine],cmd[Max_chaine], arg1[Max_chaine],arg2[Max_chaine];
while(1) {
fgets(data,Max_chaine,stdin);
fprintf(stdout,"\r");
fflush(stdout);
int taille = sscanf(data,"%s %s %s", cmd,arg1,arg2);
if(taille != 0){
switch(taille){
case 1 :
if(strcmp(cmd,"ls") == 0) fprintf(stdout,"je suis un ls\n");
else fprintf(stdout,"je suis une fraude\n");
break;
case 2 :
if(strcmp(cmd,"rm") == 0) fprintf(stdout,"je suis un rm\n mon arg est : %s \n",arg1);
else fprintf(stdout,"je suis une fraude\n");
break;
case 3:
if(strcmp(cmd,"cp") == 0) {
fprintf(stdout,"je suis un cp\n");
fprintf(stdout,"mon arg1 est : %s\n",arg1);
fprintf(stdout,"mon arg2 est : %s\n",arg2);}
else fprintf(stdout,"je suis une fraude\n");
break;
}
}
}
}
</syntaxhighlight>

Lors de l'utilisation de minicom, le fgets ne s'exécute que lors d'un "/n", cependant, un entrée sur le clavier correspond à un "/r", nous avons donc converti chaque "/r" en "/n" dans notre fonction de scan pour fluidifier l'utilisation.

<syntaxhighlight lang="c">
static int get_serial_scanf(FILE *stream) {
static unsigned char nl=0;
if(stream==stdin){
if(nl){ nl=0; return '\n'; }
char c=get_serial();
if(c=='\r') nl=1;
return c;
}
return _FDEV_EOF;
}
</syntaxhighlight>

À l'inverse, lors d'un fprintf, il est naturel en C de placer un "/n" à la fin d'une chaine de caractère. Cependant, la carte mère à besoin d'un "\r" pour effectuer ce retour à la ligne. Nous avons donc converti chaque "\n" en "\r" dans notre fonction d'impression.

<syntaxhighlight lang="c">
static int send_serial_printf(char c,FILE *stream){
if(stream==stdout){
if(c=='\n') send_serial('\r');
send_serial(c);
}
return 0;
}
</syntaxhighlight>

=== Création d'un fichier ===
Nous sommes capable maintenant d'écrire le nom d'un fichier dans un bloc.<syntaxhighlight lang="c">
void createFile(SD_files* fichier){
//write à 0 le nom puis les data pares
uint8_t name[TAILLE_NOM];
string_to_uint8_array(fichier->name, name);
int statut=writeBlock(&sd,LastFile,name);
if(statut != 1) fprintf(stdout,"erreur lors du Write\n");
LastFile += NB_BLOCK_MAX;
}
</syntaxhighlight>

== Bilan de puissance ==
Afin d'être sûr de l'alimentation de toutes les cartes, nous utilisons une alimentation +5V d'une Raspberry PI branchée sur secteur.
{| class="wikitable"
|+
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (VCC = 3.3V)
|-
!Composant
!Courant
!Puissance
|-
|74LVC125
|40 uA
|0.2mW
|-
|Carte SD
|100 mA
|330 mW
|-
|'''TOTAL'''
|'''100,04 mA'''
|'''330.2 mW'''
|}
!
{| class="wikitable"
|+
! colspan="3" |Bilan de puissance (Vcc = 5V)
|-
!Composant
!Courant
!Puissance
|-
|AtMega328p
|14mA
|70mW
|-
|ATMega8U2
|21mA
|105mW
|-
|5xLED
|5*5mA
|5*25 mW
|-
|'''TOTAL'''
|'''60mA'''
|'''300 mW'''
|}
!
{| class="wikitable"
|+
! colspan="2" |Bilan de puissance général du groupe
|-
!CARTE
!PUISSANCE (maximale)
|-
|Mère
|0,63W
|-
|Clavier
|5,55W
|-
|Réseau
|0,15W
|-
|Ecran
|0,17W
|-
|'''TOTAL'''
|'''2,685W'''
|}
|}

== Liens ==
Lien du git : https://gitea.plil.fr/vdetrez/SE4_PICO_DETREZ_CART

2024-12-16T13:09:45Z

Vdetrez :

Fichier:Carte mère finale detrez cart.jpg

2024-12-16T13:07:11Z

Vdetrez :

SE4Binome2024-3

2024-10-07T08:24:13Z

Vdetrez :