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

SE4Binome2024-6

2024-11-18T19:03:18Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
À l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6. Pour cela nous configurons la communication SPI avec avr-gcc grâce au code présent dans le fichier spi.c grandement inspiré du code présent sur le site de Mr Redon (https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme.html). Ci-dessous un aperçu du code source utiliser pour gerer la communication SPI ainsi que celui utilisé pour gérer l'affichage du sept segments.
{|class="wikitable"
|-
|colspan="2"|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define SPI_DDR DDRB
#define SS_DDR DDRC
#define SPI_PORT PORTC

#define SPI_SS_M 2 // master ?
#define SPI_MOSI 3
#define SPI_MISO 4
#define SPI_SCK 5

void spi_activer(void){ // Activer le périphérique
SPI_PORT &= ~(1<<0); // Ligne SS à l'état bas
}

void spi_desactiver(void){ // Désactiver le périphérique
SPI_PORT |= (1<<0); // 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 spi_init(void){ // Initialisation du bus SPI
SPI_DDR |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS_M); // Définition des sorties
SPI_DDR &= ~(1<<SPI_MISO); // Définition de l'entrée
// Désactivation du périphérique
SS_DDR |= (1<<0); // afficheur sur pc0
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1); // Activation SPI (SPE) en état maître (MSTR)
SPI_PORT |= (1<<0); // horloge F_CPU/64 (SPR1=1,SPR0=0)
}
</syntaxhighlight>
</code>
|-
|[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]
||<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "SPI.h"

int main(void){
spi_init();
spi_activer();
spi_echange(0x76); // adresse de l'afficheur du 7 segment
spi_desactiver();

while(1){
spi_activer(); // active
spi_echange('G');
_delay_ms(5);
spi_echange('R');
_delay_ms(5);
spi_echange('p');
_delay_ms(5);
spi_echange('6');

spi_desactiver(); //désactive
_delay_ms(5);
}
return 0;
}
</syntaxhighlight>
</code>
|-
|}

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

video test multitache ordo (portsérie/LEDs) :
[[Fichier:Test ordo.mov|centre|vignette]]

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

{|class="wikitable"
|-
|[[Fichier:schemaLCD.pdf|vignette|centre|Schématique de notre carte fille écran]]
||[[Fichier:routageLCD.pdf|vignette|centre|Routage de notre carte fille écran]]
|-
|[[Fichier:recto3D.pdf|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
||[[Fichier:verso3D.pdf|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]
|-
|}

réception de la carte PCB:
[[Fichier:Carte.pdf.pdf|centre|vignette]]

Fichier:Carte.pdf

2024-11-18T19:02:31Z

Yyahiani :

SE4Binome2024-6

2024-11-18T19:00:49Z

Yyahiani : /* Carte file ecran LCD */

2024-11-13T10:03:52Z

Yyahiani :

Fichier:Verso3D.pdf

2024-11-13T10:03:25Z

Yyahiani :

Fichier:RoutageLCD.pdf

2024-11-13T10:02:43Z

Yyahiani :

SE4Binome2024-6

2024-11-13T10:02:07Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD.pdf|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD.pdf|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:recto3D.pdf|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:verso3D.pdf|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

SE4Binome2024-6

2024-11-13T10:01:46Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD.pdf|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:recto3D|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:verso3D|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

Fichier:SchemaLCD.pdf

2024-11-13T10:00:56Z

Yyahiani :

SE4Binome2024-6

2024-11-13T09:57:55Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:SchemaLCD|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:RoutageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:Verso3D|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

SE4Binome2024-6

2024-11-13T09:57:40Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:SchemaLCD|vignette|thumb|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:RoutageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:Verso3D|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

SE4Binome2024-6

2024-11-13T09:55:51Z

Yyahiani :

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD|vignette|thumb|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:Verso3D|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

Fichier:Verso3D.png

2024-11-13T09:50:12Z

Yyahiani :

Fichier:Recto3D.png

2024-11-13T09:49:39Z

Yyahiani :

SE4Binome2024-6

2024-11-13T09:49:22Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|gauche|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:Verso3D|vignette|droite|Visualisation 3D de notre carte PCB (face arrière)]]

SE4Binome2024-6

2024-11-13T09:48:51Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|Visualisation 3D de notre carte PCB (face avant)]] [[Fichier:Verso3D|vignette|Visualisation 3D de notre carte PCB (face arrière)]]

SE4Binome2024-6

2024-11-13T09:48:30Z

Yyahiani : /* Carte file ecran LCD */

=GIT=
Nos codes et nos conceptions kicad sont disponibles via notre GIT : https://gitea.plil.fr/yyahiani/pico_yahiani_zongo.git

=Objectif=
<div style="text-align: justify;">
Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

*Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.

*Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.

*Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.

*Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.

*Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.

*Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

Enfin, pour assurer la communication entre tous ces éléments, nous allons mettre en place un bus série. Cela facilitera les échanges de données et garantira une intégration harmonieuse de chaque composant. Pour ce qui concerne notre binome notre travail portera sur la realisation d'une carte ecran qui devra remplir les taches precisées dans l'énoncé du projet.

En premier lieu, nous avons d'abord réalisé un shield qui nous servira, dans le cas où la carte mère n'abouti pas, à pouvoir tester nos cartes filles à l'aide d'un Arduino uno pour prototyper le coeur d'une carte mère.
</div>

=Shield=
==Realisation==
<div style="text-align: justify;">
Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma. Vous pouvez voir ci-dessous la version finale du routage concernant le PCB du Bouclier ainsi que ce dernier après soudures des différents composants.
</div>
{|class="wikitable"
|-
|[[Fichier:Connecteur.pdf|vignette|centré|schematique du Bouclier ]]||
[[Fichier:PcbRout.png|vignette|centré|PCB routé]]
|-
|colspan="2"|
[[Fichier:Pcb1.jpg|vignette|centre|Carte après soudure]]
|}

<div style="text-align: justify;">
Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:
</div>
{|class="wikitable"
|-
|[[Fichier:COnBoAr.jpg|vignette|gauche|connexion Bouclier-Arduino]] ||
[[Fichier:ConBoucAr.jpg|vignette|centré|connexion Bouclier-Arduino]]
|}

==Tests==
===LEDs===
Après avoir connecté notre bouclier et l'arduino nous avons effectué les tests et constaté l'allumage des differentes LED; attestant du bon fonctionnement de notre bouclier.

Voici le code C (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permet de faire clignoter les leds.
{|class = "wikitable"
|-
!Code C !! Vidéo fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

void setup()
{
pinMode(BROCHE_LED_BLEU, OUTPUT);
pinMode(BROCHE_LED_JAUNE, OUTPUT);
pinMode(BROCHE_LED_ROUGE, OUTPUT);
pinMode(BROCHE_LED_ORANGE, OUTPUT);
pinMode(BROCHE_D3, OUTPUT) ;
}

void loop()
{
digitalWrite(BROCHE_D3, HIGH);
digitalWrite(BROCHE_LED_ORANGE, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_ROUGE, HIGH);
delay(1000);
digitalWrite (BROCHE_LED_BLEU, HIGH);
delay (1000);
digitalWrite(BROCHE_LED_JAUNE, HIGH);
delay (1000) ;
digitalWrite(BROCHE_LED_ROUGE, LOW);
digitalWrite(BROCHE_LED_BLEU, LOW);
digitalWrite(BROCHE_LED_JAUNE, LOW);
digitalWrite(BROCHE_LED_ORANGE, LOW);
delay(1000);
}
</syntaxhighlight>
</code>
||[[Fichier:Videotest.mov|vignette|centre|clignotement des LEDs]]
|}
{|class="wikitable"
|-
|[[Fichier:Snapchat-186857338.jpg|vignette|gauche|fonctionnement effectif du bouclier (LED allumées)]]||
[[Fichier:Snapchat-1046850592.jpg|vignette|centre|fonctionnement effectif du bouclier (LED allumées)]]
|}

===Puce mémoire===
Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.
====Problème====
En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino):
{|class = "wikitable"
|-
!Code C !! Visualisation
|-
|
<code>
<syntaxhighlight lang="c" line="1" start="1">
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup()
{
// set the slaveSelectPin as an output:
Serial.begin (9600);
pinMode(slaveSelectPin, OUTPUT),
// initialize SPI:
SPI.begin();
}

void loop()
{

digitalWrite(slaveSelectPin, LOW);
SPI.transfer(0xaa);
Serial.write("ok");
delay(100);
}
</syntaxhighlight>
</code>
||[[Fichier:signal.png|200px|thumb|gauche|Signal d'horloge]]
|}

Le signal d'horloge de notre Arduino est correct.

Le problème ne venant pas de l'Arduino, nous avons donc dessoudé et ressoudé notre puce mémoire et le problème à été résolu:

[[Fichier:Csd.png|200px|thumb|centre|Carte SD reconnue]]

===Connecteurs HE10===
A l'aide d'un afficheur 7-segments nous vérifions le bon fonctionnement des connecteurs HE10 en affichant "GrP6" pour Groupe6.
[[Fichier:7s.jpg|vignette|centre|connecteur HE610 fonctionnel]]

==Accomplissement des taches==
=== Ordonnanceur ===
<div style="text-align: justify;">
La principale tâche à accomplir est de faire cligonter deux LED à des fréquences différentes. Pour cela nous passerons par plusieurs étapes. La première tâche à realiser est de programmer le '''minuteur 1''' de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les '''20ms'''. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme vous pouvez le voir dans notre git : '''pico_yahiani_zongo/Software/ISR_nonNue_1tache/timer.c'''

Le Timer 1 est configuré en mode '''CTC''' c'est à dire qu'il se réinitialise automatiquement à chaque fois qu'il atteint la valeur OCR1A.Le prescaler est configuré à 256, ce qui divise la fréquence de l'horloge système(16000000hz)par 256. Nous avons donc une nouvelle fréquence d'horloge à 62500 hz, ce qui implique que les coups d'horloge (ticks) s'effectuent toutes les 16us. Le timer compte jusqu'à 1250 ticks, ce qui génère une interruption toutes les 20 ms.

La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR '''non nue''' avec notre timer. Le code suivant nous a permis de réaliser cette tâche.
</div>
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
#include <avr/io.h>
#include <avr/interrupt.h>

#define PRESCALER 256
#define NB_TICK 1250
#define CTC1 WGM12 // Better name

void init_timer(void){
TCCR1A = 0;
TCCR1B = 1<<CTC1;
#if (PRESCALER==8)
TCCR1B |= (1<<CS11);
#elif (PRESCALER==64)
TCCR1B |= (1<<CS11 | 11<<CS10);
#elif (PRESCALER==256)
TCCR1B |= (1<<CS12);
#elif (PRESCALER==1024)
TCCR1B |= (1<<CS12 | 1<<CS10);
#endif

OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect, ISR_NAKED){ // Procédure d'interruption
PORTB ^= (1<<PB5);
}

int main(void)
{
DDRB |= (1<<PB5);
init_timer();
sei();
while(1);
}
</syntaxhighlight>
</code>
||[[Fichier:PB5 cli.mp4|vignette|centre|LED PB5 clignote]]
|}

Pour passer d'une ISR '''non nue''' à une ISR '''naked''' il faut écrire les macros de sauvegardes et de restaurations des registres, ces macros sont écrites dans des fichiers présents dans notre GIT :
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/save_registers.h'''
* '''pico_yahiani_zongo/Software/ordo_tourni_2taches/restore_registers.h'''

Dans la suite nous avons défini nos processus comme des structures que nous avons stockées dans un tableau.

<syntaxhighlight lang="c" line>
typedef struct {
void (*tache)(void);
int pile;
int temps;
int etat;//wake ou sleepy (processus actif ou en attente)
}tache;
tache taches[TACHE_MAX];

</syntaxhighlight>

Notre prochain objectif est de lancer deux tâches en parallèle en incluant un ordonnanceur à torniquet dans l'ISR. Pour cela nous utilisons en plus du timer présenté plus haut; une fonction d'initialisation des tâches ('''init_taches()''') et une '''ISR nue''' cette fois, qui gère la succession des tâches.
{|class = "wikitable"
|-
!Code C !! Vidéo de fonctionnement
|-
|
<code>
<syntaxhighlight lang="c" line>
void init_taches()
{
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++)
{
uint16_t sauv = SP;
SP = taches[cpt].pile;
uint16_t addresse=(uint16_t) taches[cpt].tache;
asm volatile("push %0" : : "r" (addresse & 0x00ff));
asm volatile("push %0" : : "r" ((addresse & 0xff00)>>8));
SAVE_REGISTERS();
taches[cpt].pile = SP;
SP = sauv;
}
}

ISR(TIMER1_COMPA_vect,ISR_NAKED)
{
// Sauvegarde du contexte de la tâche interrompue
SAVE_REGISTERS();
taches[tache_courante].pile = SP;
// Appel à l'ordonnanceur
tache_courante ++;
if (tache_courante >= TACHE_MAX)
{
tache_courante = 0;
}
// Récupération du contexte de la tâche ré-activée
SP = taches[tache_courante].pile;
RESTORE_REGISTERS();

asm volatile ( "reti" );
TCNT1=0;
}
</syntaxhighlight>
</code>
||[[Fichier:Cli2LED.mp4|vignette|Les 2 LEDS clignotent à des fréquences differentes]]
|}

=Carte file ecran LCD=

<div style="text-align: justify;">
La carte fille ecran comporte un ATMega328p et un écran LCD à base de contrôleur HD44780. Nous utilisons comme nous le precisé dans le wiki un potentiomètre pour régler la luminosité des cristaux liquides ainsi qu'un connecteur HE10 pour la connexion de cette carte fille à notre carte mère sur lequel nous avons bien prevu une ligne de sélection SPI. Aucune ligne d'interruption n'était initialement necessaire mais suite au rajoût d'une RAM SPI nous avons dû en rajouter une pour gérer les interruptions.La carte mère écrit dans la RAM et le uC de la carte fille rafraichit l'écran régulièrement; en outre pour éviter les conflits entre la carte mère qui écrit et la carte fille qui lit il est nécessaire d'effectuer une gestion de priorités entre les differents signaux MOSI, d'horloge et de selection. Cette gestion se fait à l'aide de circuits intermédaires présents dans notre schématique inspirés des circuits "NMOS highside" que nous avons réalisé avec l'aide de nos Encadrants Mr BOE et Mr REDON.
</div>

Voici les étapes de conceptions de notre carte fille:

schématique:

[[Fichier:schemaLCD|vignette|centre|Schématique de notre carte fille écran]]

routage:

[[Fichier:routageLCD|vignette|centre|Routage de notre carte fille écran]]

résultats 3D:

[[Fichier:Recto3D|vignette|Visualisation 3D de notre carte PCB (face avant)]]
[[Fichier:Verso3D|vignette|Visualisation 3D de notre carte PCB (face arrière)]]

2024-09-30T10:11:01Z

Yyahiani :