https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Tnehariprojets-se.plil.fr - Contributions [fr]2026-05-14T03:43:29ZContributionsMediaWiki 1.39.1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-1&diff=2923SE4Binome2023-12024-01-17T15:32:20Z<p>Tnehari : /* Conclusion */</p>
<hr />
<div>= Ordonnanceur =<br />
<br />
== Soudure et Test du SHIELD ==<br />
Au cours des 2 premières séances nous avons soudé et testé notre Shield<br />
[[Fichier:ShieldSoudé.jpg|thumb|center|300x300px|<div style="text-align:center;">Shield soudé et monté sur Arduino</div>]]<br />
<br />
Sur l'un des connecteurs, la led est abîmée dû à une soudure excessive. Sachant que les leds sont uniquement utilisées en tant qu'indicateurs pour savoir quelle carte fille à le contrôle et que nous n'en utiliserons pas plus de 3 pour tester nos programmes, cela ne vas pas avoir d'influence négative.<br />
Le potentiomètre permet de régler le niveau de luminosité de l'écran et le connecteur HE10 permettra de comuniquer avec l'écran.<br />
Les problèmes rencontrés sont les suivants : Au départ, la carte ne fonctionnait pas, le soucis étant le quartz mal soudé, c'est à l'aide d'un pistolet à air chaud que celui-ci à été ressoudé. Un autre problème était le reset de la carte fille qui ne fonctionnait pas non plus, une ressoudure classique a permis de le faire fonctionner.<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Code<br />
! scope="col"| Image<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
#include <avr/io.h><br />
<br />
void init_led(){<br />
DDRD=0x92;<br />
DDRC=0x09;<br />
}<br />
<br />
int main(){<br />
init_led();<br />
while(1)<br />
{<br />
PORTD=0x92;<br />
PORTC=0x09;<br />
}<br />
return 0;<br />
}<br />
</syntaxhighlight> <br />
| style="width:50%;" |<br />
[[Fichier:ShieldLed.jpg|thumb|center|300x300px|<div style="text-align:center;">Test des Leds du Shield</div>]]<br />
|}<br />
Puis nous avons aussi soudé l'adaptateur HE10 pour l'utilisation de la matrice de leds[[Fichier:Adaptateur HE10.jpg|thumb|center|300x300px|<div style="text-align:center;">Adaptateur HE10 pour Matrice de leds</div>]]<br />
<br />
== Programmation de l'Ordonnanceur ==<br />
Nous commençons maintenant l'ordonnanceur, tout d'abord nous créeons la structure de nos Taches.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
struct TacheInfo{<br />
void (*depart)(void);<br />
uint16_t SPointeur;<br />
int etat;<br />
};<br />
</syntaxhighlight> <br />
|}<br />
Puis nous ajoutons les 2 premières taches demandées qui sont de faire clignoter 2 leds différentes à des timing différents.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void TacheA(){<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
_delay_ms(300);<br />
}<br />
}<br />
<br />
void TacheB(){<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
struct TacheInfo Taches[2]={<br />
{TacheA,0x0600,0},<br />
{TacheB,0x0700,0}<br />
};<br />
<br />
</syntaxhighlight><br />
|}<br />
On s'occupe maintenant de l'ordonnanceur, ainsi que de l'ISR.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void ordonnanceur ()<br />
{ <br />
PORTD ^= 0x02;<br />
courant++;<br />
if (courant == NBR_TACHE) courant = 0;<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect,ISR_NAKED)<br />
{<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTER();<br />
Taches[courant].SPointeur = SP;<br />
<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].SPointeur;<br />
RESTORE_REGISTER();<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight><br />
|}<br />
Nous avons décider de faire clignoter une LED (PORTD ^= 0x02) à chaques utilisations de la fonction ordonnanceur() dans l'ISR.<br />
<br />
La variable courant indique la Tache qui est actuellement en cours.<br />
<br />
A chaque chaques changements de tache, l'ISR se déclenche enregistre la tache en cours (les registres ainsi que le Stack Pointer), appel l'ordonnanceur, puis change "charge" la tache suivante.<br />
<br />
On oublie pas maintenant de générer l'interruption toute les 20ms, pour cela on choisit un prescaler de 1024 et un nombre de ticks de 312.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
#define PRESCALER 1024<br />
#define NB_TICK 312<br />
#define CTC1 WGM12<br />
<br />
void init_timer(){<br />
TCCR1A = 0; // No output pin connected, no PWM mode enabled<br />
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match<br />
#if (PRESCALER==1024)<br />
TCCR1B |= (1<<CS12 | 1<<CS10);<br />
#endif<br />
OCR1A = NB_TICK;<br />
TCNT1 = 0;<br />
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt<br />
}<br />
</syntaxhighlight><br />
|}<br />
Ainsi que d'initialiser les Taches pour assurer le bon fonctionnement de notre ordonnanceur.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void init_taches(int pid)<br />
{<br />
int save=SP;<br />
SP=Taches[pid].SPointeur;<br />
uint16_t adresse=(uint16_t)Taches[pid].depart;<br />
asm volatile ("push %0 \n\t" : : "r" (adresse & 0x00ff));<br />
asm volatile ("push %0 \n\t" : : "r" ((adresse & 0xff00) >> 8));<br />
SAVE_REGISTER();<br />
Taches[pid].SPointeur=SP;<br />
SP=save;<br />
}<br />
</syntaxhighlight><br />
|}<br />
On peut maintenant tester notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
#define NBR_TACHE 2<br />
int main(void){<br />
init_ports();<br />
init_timer();<br />
init_taches(1);<br />
sei();<br />
SP = Taches[courant].SPointeur;<br />
Taches[courant].depart();<br />
return 0;<br />
}<br />
</syntaxhighlight> <br />
| style="width:50%;" |[[Fichier:Video 2leds shield.mp4|centré|vignette|<div style="text-align:center;">Video test du clignotement de 2 Leds </div>]]<br />
<br />
|}<br />
Les 2 leds clignotent bien avec le bon timing, et la led témoin de l'ordonnanceur clignotent aussi, ce qui indique que l'ISR est bien actif.<br />
<br />
Nous pouvons donc maitenant passer à la gestion des "sleeps".<br />
<br />
En effet, l'utilisation de _delay_ms dans chaque tache n'est pas la manière la plus optimale de procéder. Et meme cela nous bloquera par la suite.<br />
<br />
Nous ajoute donc à la structure de nos Taches, une structure InfoEndormi, qui, comme son nom l'indique nous donne des informations si la tache est endormie. A savoir la raison mais aussi des donnees comme par exemple le temps que cette tache doit passer endormie.<br />
<br />
Puis afin de remplacer _delay_ms, nous créeons une fonction Attente qui endors une tache pour un temps donné.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
#define REVEILLE 0<br />
#define ENDORMI 1<br />
#define RAISON_DELAY 0<br />
<br />
struct InfoEndormi{<br />
int raison;<br />
uint16_t donnee;<br />
}sleep_t;<br />
<br />
<br />
struct TacheInfo{<br />
void (*depart)(void); <br />
uint16_t SPointeur;<br />
int etat;<br />
struct InfoEndormi endormi;<br />
};<br />
</syntaxhighlight> <br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void Attente(uint16_t temps_ms){<br />
cli();<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_DELAY;<br />
Taches[Tache_courante].endormi.donnee = temps_ms;<br />
TCNT1 = 0;<br />
sei();<br />
}<br />
</syntaxhighlight><br />
<br />
|}<br />
Voila maitenant nos taches, il est important de créer une TacheZombie qui comme son nom l'indique est toujours révéillée.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void TacheZombie() //Tache toujours réveillé<br />
{<br />
while(1)<br />
{<br />
_delay_ms(1.5*PERIODE_INTERUPTION); //Delay légèrement supèrieur à la periode pour éviter tout soucis<br />
}<br />
}<br />
<br />
void TacheA()<br />
{<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
Attente(300);<br />
}<br />
}<br />
<br />
void TacheB()<br />
{<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
Attente(500);<br />
}<br />
}<br />
</syntaxhighlight><br />
|}<br />
Il est important maitenant de modifier notre ordonnanceur afin que celui-ci puisse recalculer le nouveau temps de sleep d'une tache et si ce temps devient inférieur ou ègale à 0 alors l'ordonnacnceur réveille la tache.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void ordonnanceur ()<br />
{<br />
PORTD ^= 0x02;<br />
for(int i = 0; i < NBR_TACHE; i++)<br />
{<br />
if(Taches[i].etat == ENDORMI && Taches[Tache_courante].endormi.raison == RAISON_DELAY)<br />
{<br />
uint16_t diff_temps = PERIODE_INTERUPTION;<br />
if(TCNT1 != 0)<br />
{<br />
//Calcul précis de la différence de temps (pas obligatoirement 20 ms)<br />
diff_temps = ((TCNT1*PERIODE_INTERUPTION*10)/OCR1A)/10;<br />
TCNT1 = 0;<br />
}<br />
Taches[i].endormi.donnee -= diff_temps;<br />
<br />
if(Taches[i].endormi.donnee <= 0)<br />
{<br />
Taches[i].etat = REVEILLE;<br />
}<br />
}<br />
}<br />
<br />
do<br />
{<br />
Tache_courante++;<br />
if (Tache_courante == NBR_TACHE) Tache_courante = 0;<br />
}<br />
while(Taches[Tache_courante].etat == ENDORMI);<br />
}<br />
<br />
</syntaxhighlight><br />
|}<br />
Maintenant que cela est fait, nous pouvons ajouter 2 nouvelles taches qui sont la lecture et l'ecriture sur le port série.<br />
<br />
Pour cela, nous allons procéder avec des sémaphores. En effet, il ne peut y avoir que 1 seule tache en écriture ou en lecture, il faut donc que si plusieurs taches essaient de prendre la ressource, cette ressource soit donner à la première arrivé et que les autres taches en attendant patientent.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void semaphore_e(int ACTION){<br />
if (ACTION == PRENDRE)<br />
{<br />
while(1)<br />
{<br />
cli();<br />
if (semaphore_ecriture > 0) //Si ressource dispo <br />
{<br />
semaphore_ecriture = 0;<br />
sei();<br />
break;<br />
} else<br />
{<br />
// La ressource est occupée, on endort la tache<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_ECRITURE;<br />
TCNT1=0;<br />
TIMER1_COMPA_vect();<br />
}<br />
sei();<br />
while(semaphore_ecriture==0);<br />
}<br />
<br />
}<br />
else if (ACTION == LAISSER)<br />
{<br />
cli();<br />
semaphore_ecriture = 1;<br />
sei();<br />
}<br />
}<br />
</syntaxhighlight><br />
|}<br />
On fait la meme chose pour la lecture.<br />
<br />
On oublie pas d'initialiser le port série avec les bons paramètres, créer les taches, puis on test.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void init_serie(long int vitesse){<br />
UBRR0=FREQ_CPU/(((unsigned long int)vitesse)<<4)-1; <br />
// configure la vitesse<br />
UCSR0B=(1<<TXEN0 | 1<<RXEN0); // autorise l'envoi et la réception<br />
UCSR0C=(1<<UCSZ01 | 1<<UCSZ00); // 8 bits et 1 bit de stop<br />
UCSR0A &= ~(1 << U2X0); // double vitesse désactivée<br />
}<br />
<br />
</syntaxhighlight><br />
| style="width:50%;" |[[Fichier:Lecture EcritureSerie.jpg|centré|vignette|356x356px|<div style="text-align:center;">Test de la lecture et de l'écriture sur le port série.(On écrie 9 caractères puis le shield nous renvoie les mêmes 9) </div>]]<br />
<br />
|}<br />
<br />
= Carte électronique numérique =<br />
<br />
== Conception et Création ==<br />
Nous avons choisi la Carte Fille : Ecran LCD <br />
<br />
Pendant la 3ème séance nous avons finis le Schématic de la carte <br />
[[Fichier:SCH.png|centré|vignette|700x700px|<div style="text-align:center;">Schematic de la Carte Fille : Ecran LCD</div>]]<br />
Puis nous avons Routé la carte et envoyé à la Fabrication<br />
[[Fichier:PCB LCD.png|centré|vignette|550x550px|<div style="text-align:center;">Routage de la Carte Fille : Ecran LCD</div>]]<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Carte non soudée<br />
! scope="col"| Carte soudée<br />
! scope="col"| Video Test<br />
|-<br />
| style="width:33%;" |[[Fichier:Carte LCD non soudée.jpg|centré|vignette|300x300px|<div style="text-align:center;">Carte non soudée</div>]]<br />
| style="width:33%;" |[[Fichier:Carte LCD soudee.jpg|centré|vignette|400x400px|<div style="text-align:center;">Carte soudée</div>]]<br />
| style="width:33%;" |[[Fichier:Video TestLCD.mp4|centré|vignette|<div style="text-align:center;">Video test des leds</div>]]<br />
<br />
|}<br />
<br />
== Programmation de la carte LCD ==<br />
Tout d'abord, nous avons voulu tester le bon fonctionnement de notre carte mais surtout du bon controle de l'ecran HD44780 grâce à l'IDE Arduino.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
const int rs = 2, en = 18, d4 = 14, d5 = 15, d6 = 16, d7 = 17;<br />
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);<br />
<br />
void setup() {<br />
// set up the LCD's number of columns and rows:<br />
pinMode(9,OUTPUT);<br />
digitalWrite(9,LOW);<br />
lcd.begin(16, 2);<br />
// Print a message to the LCD.<br />
lcd.print("Je compte");<br />
}<br />
<br />
void loop() {<br />
// set the cursor to column 0, line 1<br />
// (note: line 1 is the second row, since counting begins with 0):<br />
lcd.setCursor(0, 1);<br />
// print the number of seconds since reset:<br />
lcd.print(millis() / 1000);<br />
}<br />
</syntaxhighlight><br />
| style="width:50%;" |[[Fichier:TestLCDArduino.jpg|centré|vignette|375x375px|<div style="text-align:center;">Test LCD via IDE Arduino</div>]]<br />
<br />
|}<br />
Maintenant que cela fonctionne, nous pouvons commencer à écrire notre Librairie pour faire fonctionner notre carte.<br />
<br />
=== Librairie HD44780 ===<br />
Nous avons commencer par reprendre la librairie d'ancien élève, merci à eux pour leur travail.<br />
<br />
Dans notre cas, pour l'utilisation la plus simple nous avons besoin de plusieurs fonctions. La première écrit un caractère sur l'écran, la deuxième copie une ligne et la dernière efface une ligne.<br />
<br />
HD44780_CopyLine1in0 :<br />
<br />
Permet de copier la seconde ligne sur la première. Pour ce faire, on se place au début de la première ligne, on écrit le contenu du tableau de caractère, et on le vide ensuite (EmptyLine1).<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void HD44780_CopyLine1in0(char line1[], int nbrows, int nbcols, int ind_line1) {<br />
for (int i = 0; i < ind_line1; i++) {<br />
int address_ligne0 = HD44780_XY2Adrr(nbrows, nbcols, 0, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_ligne0);<br />
HD44780_WriteData(line1[i],0);<br />
}<br />
HD44780_EmptyLine1(line1,nbcols);<br />
}<br />
</syntaxhighlight><br />
|}<br />
<br />
<br />
HD44780_EraseLine :<br />
<br />
Permet d'effacer une ligne. Pour ce faire on se place au début de la ligne voulue, et on écrit une suite de caractère vide.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void HD44780_EraseLine(int nbrows, int nbcols, int line) {<br />
int address_line1;<br />
char espace = ' ';<br />
for (int i = 0; i < nbcols; i++) {<br />
address_line1 = HD44780_XY2Adrr(nbrows, nbcols, line, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_line1);<br />
HD44780_WriteData(espace,0);<br />
}<br />
}<br />
</syntaxhighlight><br />
|}<br />
<br />
<br />
HD44780_WriteChar :<br />
<br />
Permet d'écrire un caractère sur l'écran. Chaque caractère écrit sur la seconde ligne est placé dans un tableau de caractère. <br />
<br />
Lorsqu'on arrive au bout d'une ligne : Si nous sommes à la première ligne (Ligne 0), on passe à la seconde (Ligne 1) et on se replace au début des colonnes. Si nous sommes à la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde. <br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void HD44780_WriteChar(char car, char line1[], int* ind_line1, int nbrows, int nbcols, int* row, int* col) {<br />
if ((*col) == nbcols) {<br />
(*col) = 0;<br />
if ((*row) <= 1) (*row)++;<br />
if ((*row) > 1) {<br />
(*row) = 1;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1);<br />
}<br />
(*ind_line1) = 0;<br />
}<br />
<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(car,1);<br />
(*col)++;<br />
if ((*row) == 1) <br />
{<br />
line1[*ind_line1] = car;<br />
(*ind_line1)++;<br />
}<br />
}<br />
</syntaxhighlight><br />
|}<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Video Test<br />
|-<br />
| style="width:50%;" |[[Fichier:Video test de la librairie.mp4|centré|vignette|<div style="text-align:center;">Video test de la librairie</div>]]<br />
|}Super, ca fonctionne ! <br />
<br />
Désormais, nous voulons que notre écran affiche ce qu'il recoit via le bus SPI. <br />
<br />
=== Communication SPI ===<br />
Pour cela il nous faut initialiser le maitre (un arduino UNO) et l'esclave (notre carte LCD). <br />
<br />
Puis que le maitre transmette des données et que l'esclave les recoivent. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Maitre<br />
! scope="col" | Code Esclave<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS);<br />
DDRB &= ~(1 << SPI_MISO);<br />
SPCR |= (1 << MSTR);<br />
SPCR |= (1 << SPE) | (1<<SPR0) | (1<<SPR1);<br />
}<br />
<br />
void SPI_MasterTransmit(char cData)<br />
{<br />
SPDR = cData;<br />
while(!(SPSR & (1<<SPIF)));<br />
}<br />
</syntaxhighlight><br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MISO);<br />
DDRB &= ~((1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS));<br />
SPCR |= (1 << SPE); <br />
}<br />
<br />
char SPI_SlaveReceive(void)<br />
{<br />
/* Attendre la fin de la réception */<br />
while (!(SPSR & (1 << SPIF)));<br />
char receivedData = SPDR;<br />
return receivedData;<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
|}<br />
Faisons un petit test en envoyant des 'A' suivis de 'B' et enfin un 'X' pour terminer.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Test du Maitre<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
int main()<br />
{<br />
...<br />
...<br />
while (x<17)<br />
{<br />
SPI_MasterTransmit('A');<br />
_delay_ms(100);<br />
SPI_MasterTransmit('B');<br />
x++;<br />
PORTD ^= (1<<7);<br />
_delay_ms(100);<br />
}<br />
SPI_MasterTransmit('X');<br />
while(1)<br />
{<br />
}<br />
}<br />
<br />
</syntaxhighlight> <br />
| style="width:50%;" |[[Fichier:Video test SPI.mp4|centré|vignette|<div style="text-align:center;">Video test de transmission par SPI</div>]]<br />
<br />
|}Notre test fonctionne mais cela n'a pas été sans peine. Nous avons rencontré énormément de problème sur la communication SPI. La communication était clairement douteuse et aléatoire. <br />
<br />
==== Problèmes rencontrés ====<br />
Plusieurs pistes ont été considérées pour comprendre le problème qu'on avait avec le SPI, était-ce l'arduino UNO? Notre connecteur? Le shield? Notre carte?<br />
Au départ, par soucis de praticité, nous voulions utiliser l'arduino UNO qui disposait de fonctionnalités de test simple avant de passer au shield, mais à chaque essai, le SPI ne fonctionait pas correctement bien qu'on pouvait observer à l'oscilloscope que le message était bien envoyé à notre carte.<br />
<br />
Finalement, nous sommes directement passé à la communication SPI avec notre shield, qui cette fois-ci, permettait d'avoir un résultat satisfaisant. Le résultat n'était pas parfait car on remarquait que la position des fils déterminait si la communication allait fonctionner, il fallait donc trouver la position qui permettait cette communication.<br />
Pour régler ce problème, nous avons déterminé la fréquence de travail du SPI utilisé par le shield et notre carte, pour vérifier qu'il n'y ait pas de problèmes de synchronisation ou que la fréquence utilisée soit bien adaptée. Pour ce faire nous avons observé à l'oscilloscope les différentes divisions de fréquences possibles en vérifiant en même temps que la communication SPI fonctionne bien. Les résultats sont surprenant, car peu importe la fréquence de travail, aucun problème n'a été détécté.<br />
<br />
=== Communication SPI par interruption ===<br />
Il nous faut maitenant communiquer par SPI par interruption car cela offre certains avantages par rapport à la communication SPI standard sans interruption, en particulier en termes d'efficacité et de gestion du temps. En effet, l'utilisation d'interruptions permet au microcontrôleur de gérer d'autres tâches pendant les transferts SPI. Plutôt que d'attendre de manière synchrone la fin d'une transaction SPI, le microcontrôleur peut être informé via une interruption lorsque les données sont prêtes à être lues ou écrites. Cela permet un multitâche plus efficace. Ce qui va nous être trés pratique sachant que le projet comporte plusieurs cartes filles.<br />
<br />
Pour cela il nous faut coté maitre et esclave activé le mode SPI Interrupt lors de l'initialisation du SPI, on rajoute donc <code>SPCR |= (1<<SPIE);</code> lors à l'initialisation.<br />
<br />
Ensuite on génère l'interruption coté esclave à la fin de l'initalisation et on configure notre ISR.<br />
<br />
Le maitre à plusieurs type d'envoie possible :<br />
<br />
0x00 : Demande le type de la carte.<br />
<br />
0x01 : Active la communication avec la carte LCD.<br />
<br />
0xff : Met fin à la communication.<br />
<br />
Voici comment l'ISR lui fonctionne, si je recois 0x00 je renvoie on type, 0x01 je passe en mode EnReception. <br />
<br />
En mode EnReception : lorsque je recois un octet je l'ajoute à un buffer, lorsque je recois 0xff je désactive le mode en Reception.<br />
<br />
Dans mon main, une fois que mon mode EnRecption est désactivé mais que mon indice du buffer et supérieur à 0 alors je peux traiter mes octets.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code ISR<br />
! scope="col" | Code Main<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
ISR(SPI_STC_vect) {<br />
uint8_t data = SPDR;<br />
if(EnReception == 1)<br />
switch (data){<br />
case 0xff:<br />
EnReception=0;<br />
break;<br />
default :<br />
buffer[IndBuffer++]=data;<br />
}<br />
else<br />
switch (data){<br />
case 0x00: <br />
sendType();<br />
break;<br />
case 0x01:<br />
EnReception=1;<br />
break;<br />
}<br />
}<br />
</syntaxhighlight><br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
while (1) {<br />
if (EnReception == 0 && IndBuffer>0)<br />
{<br />
for(int i=0; i < IndBuffer; i++)<br />
{<br />
"Fonction de traitement"<br />
}<br />
IndBuffer=0;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
|}<br />
<br />
=== Gestion des caractères spéciaux ===<br />
Nous avons décider de gérer 4 caractères spéciaux différents : \n , \t, \b, \r<br />
<br />
Pour cela on créé la fonction <code>HD44780_Traitement</code> qui sera notre fonction principale.<br />
<br />
Si on recoit un caractère classique alors on l'affiche grâce à <code>HD44780_WriteChar</code> précédemment crée.<br />
<br />
Sinon il sagit d'un caractère spécial et alors on le traite dans un switch case :<br />
<br />
==== \n ====<br />
Si on est sur la première ligne, on se place au début de la seconde.<br />
<br />
Si on est sur la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \n<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
case '\n': //Retour à la ligne<br />
switch (*row)<br />
{<br />
case 0:<br />
(*col) = 0;<br />
(*row) = 1;<br />
break;<br />
case 1:<br />
*col = 0;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1); <br />
*ind_line1 = 0;<br />
break; <br />
}<br />
break;<br />
</syntaxhighlight><br />
| style="width:50%;" |[[Fichier:Video retour a la ligne.mp4|centré|vignette|<div style="text-align:center;">Video test du retour à la ligne </div>]]<br />
<br />
|}<br />
<br />
==== \r ====<br />
On se replace au début de la ligne sur laquelle on est actuellement en train d'écrire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \r<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
case '\r': // Retour chariot<br />
*col = 0;<br />
(*ind_line1) = 0;<br />
HD44780_EmptyLine1(line1,nbcols);<br />
break;<br />
</syntaxhighlight><br />
| style="width:50%;" |[[Fichier:Video retour charriot.mp4|centré|vignette|<div style="text-align:center;">Video test du retour chariot </div>]]<br />
<br />
|}<br />
<br />
==== \r ====<br />
On efface le caractère précédent, ajuste la position du curseur, et passe à la ligne supérieure si nécessaire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \b<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
case '\b': // Retour arrière<br />
switch (*row)<br />
{<br />
case 0:<br />
if (*col > 0)<br />
{<br />
(*col)--;//Retourne sur le caractère précédent<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);//"L'efface"<br />
_delay_ms(500);<br />
<br />
}<br />
break;<br />
case 1:<br />
if (*col > 0)<br />
{<br />
(*col)--;<br />
(*ind_line1) --;<br />
}<br />
else <br />
{<br />
(*row) = 0;<br />
(*col) = 15;<br />
}<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);<br />
break;<br />
}<br />
break;<br />
</syntaxhighlight> <br />
| style="width:50%;" |[[Fichier:Video Supprésion.mp4|centré|vignette|<div style="text-align:center;">Video test du retour arrière </div>]]<br />
<br />
|}<br />
<br />
==== \t ====<br />
On écrit 4 espaces, à la suite de notre position actuelle.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \t<br />
! scope="col" | Video Test<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
case '\t': // Tabulation de 4 caractères<br />
for (int i=0; i < 4; i++)<br />
{ <br />
char espace = ' ';<br />
HD44780_WriteChar(espace,line1,ind_line1,nbrows,nbcols,row,col);<br />
}<br />
break;<br />
</syntaxhighlight><br />
| style="width:50%;" |[[Fichier:Video Tabulation.mp4|centré|vignette|<div style="text-align:center;">Video test de la Tabulation </div>]]<br />
<br />
|}<br />
<br />
=== Gestion des codes VT100 ===<br />
Pour finir, nous allons gérer quelques codes VT100, les déplacements de curseurs.<br />
<br />
Pour envoyer un code VT100 pour déplacer le curseur le maitre doit nous envoyer:<br />
<br />
# Le code ESCAPE (0x1b)<br />
# Le CURSOR_MODE (0x1c)<br />
# Et enfin le mouvement du curseur souhaité CURSOR_UP (0x41), CURSOR_DOWN (0x42), CURSOR_RIGHT (0x43), CURSOR_LEFT (0x44).<br />
<br />
On gère cela dans la fonction VT100_Traitement.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void VT100_Traitement(char car, int nbrows, int nbcols, int* row, int* col, int* vt100_mode)<br />
{<br />
if (*vt100_mode == 1) // CURSOR_MODE<br />
{<br />
int address;<br />
<br />
switch (car)<br />
{<br />
case CURSOR_UP:<br />
*row = (*row == 1) ? 0 : *row;<br />
break;<br />
<br />
case CURSOR_DOWN:<br />
*row = (*row == 0) ? 1 : *row;<br />
break;<br />
<br />
case CURSOR_RIGHT:<br />
*col = (*col < nbcols - 1) ? (*col + 1) : *col;<br />
break;<br />
<br />
case CURSOR_LEFT:<br />
*col = (*col > 0) ? (*col - 1) : *col;<br />
break;<br />
}<br />
<br />
address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteCommand(LCD_ON | CURSOR_BLINK);<br />
}<br />
}<br />
<br />
</syntaxhighlight><br />
|}<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Video Test<br />
|-<br />
| style="width:50%;" |[[Fichier:Video VT100.mp4|centré|vignette|<div style="text-align:center;">Video test des codes VT100</div>]]<br />
|}<br />
=== Gestion des primitives systèmes ===<br />
Voici les primitives systèmes pour la carte mère, elle permettent de communiquer les chaînes de caractères à envoyer en préparant une transmission SPI constituée de l'octet de commande 0x01 et des données correspondants aux caractères.<br />
<br />
La fonction Reset_Display permet de reset l'affichage de l'écran et permet aussi à la carte mère de le remarquer en lui attribuant un numéro de port.<br />
<br />
La fonction Transmit_to_display est la fonction de transmission de données par SPI. Elle utilise les fonctions SPI créées précédemment pour envoyer les données à afficher.<br />
{| class="wikitable" style="width:50%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<syntaxhighlight lang="c" line><br />
void Reset_display(volatile uint8_t *resPort, volatile uint8_t resSel) //Utile pour reset l'ecran<br />
{<br />
*resPort &= ~(1<<resSel);<br />
_delay_ms(1);<br />
*resPort |= (1<<resSel);<br />
}<br />
<br />
<br />
void Transmit_To_display(uint8_t data, volatile uint8_t *ssPort, volatile uint8_t ss)<br />
{<br />
selectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
transferSPI(data);<br />
_delay_ms(1);<br />
unselectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
}<br />
</syntaxhighlight><br />
|}<br />
<br />
= Conclusion =<br />
Pour conclure, faisons un bilan de ce qui a été produit:<br />
<br />
-Une carte fille fonctionnelle qui gère l'affichage d'un écran LCD<br />
<br />
-Communication SPI par interruption<br />
<br />
-Ordonnanceur avec un système de priorité (sémaphore)<br />
<br />
-Défilement de automatique de l'écran<br />
<br />
-Gestion des caractères spéciaux<br />
<br />
-Primitives systèmes pour la carte mère<br />
<br />
Malheureusement, par manque de temps, nous n'avons pas pu faire communiquer les cartes filles ensemble en les connectant à la carte mère. Nous restons cependant très satisfait du résultat et des fonctionnalités de notre carte!<br />
<br />
= Références utiles =<br />
Lien du git :<br />
<br />
https://archives.plil.fr/mchauvel/PICO_Taha_NEHARI_Martin_CHAUVELIERE.git</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-1&diff=2835SE4Binome2023-12024-01-16T16:54:22Z<p>Tnehari : </p>
<hr />
<div>= Ordonnanceur =<br />
<br />
== Soudure et Test du SHIELD ==<br />
Au cours des 2 premières séances nous avons soudé et testé notre Shield<br />
[[Fichier:ShieldSoudé.jpg|thumb|center|300x300px|<div style="text-align:center;">Shield soudé et monté sur Arduino</div>]]<br />
<br />
Sur l'un des connecteurs, la led est abîmée dû à une soudure excessive. Sachant que les leds sont uniquement utilisées en tant qu'indicateurs pour savoir quelle carte fille à le contrôle et que nous n'en utiliserons pas plus de 3 pour tester nos programmes, cela ne vas pas avoir d'influence négative.<br />
Le potentiomètre permet de régler le niveau de luminosité de l'écran et le connecteur HE10 permettra de comuniquer avec l'écran.<br />
Les problèmes rencontrés sont les suivants : Au départ, la carte ne fonctionnait pas, le soucis étant le quartz mal soudé, c'est à l'aide d'un pistolet à air chaud que celui-ci à été ressoudé. Un autre problème était le reset de la carte fille qui ne fonctionnait pas non plus, une ressoudure classique a permis de le faire fonctionner.<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Code<br />
! scope="col"| Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#include <avr/io.h><br />
<br />
void init_led(){<br />
DDRD=0x92;<br />
DDRC=0x09;<br />
}<br />
<br />
int main(){<br />
init_led();<br />
while(1)<br />
{<br />
PORTD=0x92;<br />
PORTC=0x09;<br />
}<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
[[Fichier:ShieldLed.jpg|thumb|center|300x300px|<div style="text-align:center;">Test des Leds du Shield</div>]]<br />
|}<br />
Puis nous avons aussi soudé l'adaptateur HE10 pour l'utilisation de la matrice de leds[[Fichier:Adaptateur HE10.jpg|thumb|center|300x300px|<div style="text-align:center;">Adaptateur HE10 pour Matrice de leds</div>]]<br />
<br />
== Programmation de l'Ordonnanceur ==<br />
Nous commençons maintenant l'ordonnanceur, tout d'abord nous créeons la structure de nos Taches.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
struct TacheInfo{<br />
void (*depart)(void);<br />
uint16_t SPointeur;<br />
int etat;<br />
};<br />
</pre> <br />
|}<br />
Puis nous ajoutons les 2 premières taches demandées qui sont de faire clignoter 2 leds différentes à des timing différents.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheA(){<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
_delay_ms(300);<br />
}<br />
}<br />
<br />
void TacheB(){<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
struct TacheInfo Taches[2]={<br />
{TacheA,0x0600,0},<br />
{TacheB,0x0700,0}<br />
};<br />
<br />
</pre> <br />
|}<br />
On s'occupe maintenant de l'ordonnanceur, ainsi que de l'ISR.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{ <br />
PORTD ^= 0x02;<br />
courant++;<br />
if (courant == NBR_TACHE) courant = 0;<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect,ISR_NAKED)<br />
{<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTER();<br />
Taches[courant].SPointeur = SP;<br />
<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].SPointeur;<br />
RESTORE_REGISTER();<br />
asm volatile ( "reti" );<br />
}<br />
</pre><br />
|}<br />
Nous avons décider de faire clignoter une LED (PORTD ^= 0x02) à chaques utilisations de la fonction ordonnanceur() dans l'ISR.<br />
<br />
La variable courant indique la Tache qui est actuellement en cours.<br />
<br />
A chaque chaques changements de tache, l'ISR se déclenche enregistre la tache en cours (les registres ainsi que le Stack Pointer), appel l'ordonnanceur, puis change "charge" la tache suivante.<br />
<br />
On oublie pas maintenant de générer l'interruption toute les 20ms, pour cela on choisit un prescaler de 1024 et un nombre de ticks de 312.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define PRESCALER 1024<br />
#define NB_TICK 312<br />
#define CTC1 WGM12<br />
<br />
void init_timer(){<br />
TCCR1A = 0; // No output pin connected, no PWM mode enabled<br />
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match<br />
#if (PRESCALER==1024)<br />
TCCR1B |= (1<<CS12 | 1<<CS10);<br />
#endif<br />
OCR1A = NB_TICK;<br />
TCNT1 = 0;<br />
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt<br />
}<br />
</pre><br />
|}<br />
Ainsi que d'initialiser les Taches pour assurer le bon fonctionnement de notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_taches(int pid)<br />
{<br />
int save=SP;<br />
SP=Taches[pid].SPointeur;<br />
uint16_t adresse=(uint16_t)Taches[pid].depart;<br />
asm volatile ("push %0 \n\t" : : "r" (adresse & 0x00ff));<br />
asm volatile ("push %0 \n\t" : : "r" ((adresse & 0xff00) >> 8));<br />
SAVE_REGISTER();<br />
Taches[pid].SPointeur=SP;<br />
SP=save;<br />
}<br />
</pre><br />
|}<br />
On peut maintenant tester notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Vidéo<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define NBR_TACHE 2<br />
int main(void){<br />
init_ports();<br />
init_timer();<br />
init_taches(1);<br />
sei();<br />
SP = Taches[courant].SPointeur;<br />
Taches[courant].depart();<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
Les 2 leds clignotent bien avec le bon timing, et la led témoin de l'ordonnanceur clignotent aussi, ce qui indique que l'ISR est bien actif.<br />
<br />
Nous pouvons donc maitenant passer à la gestion des "sleeps".<br />
<br />
En effet, l'utilisation de _delay_ms dans chaque tache n'est pas la manière la plus optimale de procéder. Et meme cela nous bloquera par la suite.<br />
<br />
Nous ajoute donc à la structure de nos Taches, une structure InfoEndormi, qui, comme son nom l'indique nous donne des informations si la tache est endormie. A savoir la raison mais aussi des donnees comme par exemple le temps que cette tache doit passer endormie.<br />
<br />
Puis afin de remplacer _delay_ms, nous créeons une fonction Attente qui endors une tache pour un temps donné.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define REVEILLE 0<br />
#define ENDORMI 1<br />
#define RAISON_DELAY 0<br />
<br />
struct InfoEndormi{<br />
int raison;<br />
uint16_t donnee;<br />
}sleep_t;<br />
<br />
<br />
struct TacheInfo{<br />
void (*depart)(void); <br />
uint16_t SPointeur;<br />
int etat;<br />
struct InfoEndormi endormi;<br />
};<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void Attente(uint16_t temps_ms){<br />
cli();<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_DELAY;<br />
Taches[Tache_courante].endormi.donnee = temps_ms;<br />
TCNT1 = 0;<br />
sei();<br />
}<br />
</pre><br />
<br />
|}<br />
Voila maitenant nos taches, il est important de créer une TacheZombie qui comme son nom l'indique est toujours révéillée.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheZombie() //Tache toujours réveillé<br />
{<br />
while(1)<br />
{<br />
_delay_ms(1.5*PERIODE_INTERUPTION); //Delay légèrement supèrieur à la periode pour éviter tout soucis<br />
}<br />
}<br />
<br />
void TacheA()<br />
{<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
Attente(300);<br />
}<br />
}<br />
<br />
void TacheB()<br />
{<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
Attente(500);<br />
}<br />
}<br />
</pre><br />
|}<br />
Il est important maitenant de modifier notre ordonnanceur afin que celui-ci puisse recalculer le nouveau temps de sleep d'une tache et si ce temps devient inférieur ou ègale à 0 alors l'ordonnacnceur réveille la tache.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{<br />
PORTD ^= 0x02;<br />
for(int i = 0; i < NBR_TACHE; i++)<br />
{<br />
if(Taches[i].etat == ENDORMI && Taches[Tache_courante].endormi.raison == RAISON_DELAY)<br />
{<br />
uint16_t diff_temps = PERIODE_INTERUPTION;<br />
if(TCNT1 != 0)<br />
{<br />
//Calcul précis de la différence de temps (pas obligatoirement 20 ms)<br />
diff_temps = ((TCNT1*PERIODE_INTERUPTION*10)/OCR1A)/10;<br />
TCNT1 = 0;<br />
}<br />
Taches[i].endormi.donnee -= diff_temps;<br />
<br />
if(Taches[i].endormi.donnee <= 0)<br />
{<br />
Taches[i].etat = REVEILLE;<br />
}<br />
}<br />
}<br />
<br />
do<br />
{<br />
Tache_courante++;<br />
if (Tache_courante == NBR_TACHE) Tache_courante = 0;<br />
}<br />
while(Taches[Tache_courante].etat == ENDORMI);<br />
}<br />
<br />
</pre><br />
|}<br />
Maintenant que cela est fait, nous pouvons ajouter 2 nouvelles taches qui sont la lecture et l'ecriture sur le port série.<br />
<br />
Pour cela, nous allons procéder avec des sémaphores. En effet, il ne peut y avoir que 1 seule tache en écriture ou en lecture, il faut donc que si plusieurs taches essaient de prendre la ressource, cette ressource soit donner à la première arrivé et que les autres taches en attendant patientent.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void semaphore_e(int ACTION){<br />
if (ACTION == PRENDRE)<br />
{<br />
while(1)<br />
{<br />
cli();<br />
if (semaphore_ecriture > 0) //Si ressource dispo <br />
{<br />
semaphore_ecriture = 0;<br />
sei();<br />
break;<br />
} else<br />
{<br />
// La ressource est occupée, on endort la tache<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_ECRITURE;<br />
TCNT1=0;<br />
TIMER1_COMPA_vect();<br />
}<br />
sei();<br />
while(semaphore_ecriture==0);<br />
}<br />
<br />
}<br />
else if (ACTION == LAISSER)<br />
{<br />
cli();<br />
semaphore_ecriture = 1;<br />
sei();<br />
}<br />
}<br />
</pre><br />
|}<br />
On fait la meme chose pour la lecture.<br />
<br />
On oublie pas d'initialiser le port série avec les bons paramètres, créer les taches, puis on test.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_serie(long int vitesse){<br />
UBRR0=FREQ_CPU/(((unsigned long int)vitesse)<<4)-1; <br />
// configure la vitesse<br />
UCSR0B=(1<<TXEN0 | 1<<RXEN0); // autorise l'envoi et la réception<br />
UCSR0C=(1<<UCSZ01 | 1<<UCSZ00); // 8 bits et 1 bit de stop<br />
UCSR0A &= ~(1 << U2X0); // double vitesse désactivée<br />
}<br />
<br />
</pre><br />
| style="width:50%;" |[[Fichier:Lecture EcritureSerie.jpg|centré|vignette|356x356px|<div style="text-align:center;">Test de la lecture et de l'écriture sur le port série.(On écrie 9 caractères puis le shield nous renvoie les mêmes 9) </div>]]<br />
<br />
|}<br />
= Carte FPGA =<br />
<br />
= Carte électronique numérique =<br />
<br />
== Conception et Création ==<br />
Nous avons choisi la Carte Fille : Ecran LCD <br />
<br />
Pendant la 3ème séance nous avons finis le Schématic de la carte <br />
[[Fichier:SCH.png|centré|vignette|700x700px|<div style="text-align:center;">Schematic de la Carte Fille : Ecran LCD</div>]]<br />
Puis nous avons Routé la carte et envoyé à la Fabrication<br />
[[Fichier:PCB LCD.png|centré|vignette|550x550px|<div style="text-align:center;">Routage de la Carte Fille : Ecran LCD</div>]]<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Carte non soudée<br />
! scope="col"| Carte soudé<br />
! scope="col"| Video Test<br />
|-<br />
| style="width:50%;" |[[Fichier:Carte LCD non soudée.jpg|centré|vignette|300x300px|<div style="text-align:center;">Carte non soudée</div>]]<br />
| style="width:50%;" |[[Fichier:Carte LCD soudee.jpg|centré|vignette|400x400px|<div style="text-align:center;">Carte soudée</div>]]<br />
<br />
|}<br />
<br />
== Programmation de la carte LCD ==<br />
Tout d'abord, nous avons voulu tester le bon fonctionnement de notre carte mais surtout du bon controle de l'ecran HD44780 grâce à l'IDE Arduino.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
const int rs = 2, en = 18, d4 = 14, d5 = 15, d6 = 16, d7 = 17;<br />
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);<br />
<br />
void setup() {<br />
// set up the LCD's number of columns and rows:<br />
pinMode(9,OUTPUT);<br />
digitalWrite(9,LOW);<br />
lcd.begin(16, 2);<br />
// Print a message to the LCD.<br />
lcd.print("Je compte");<br />
}<br />
<br />
void loop() {<br />
// set the cursor to column 0, line 1<br />
// (note: line 1 is the second row, since counting begins with 0):<br />
lcd.setCursor(0, 1);<br />
// print the number of seconds since reset:<br />
lcd.print(millis() / 1000);<br />
}<br />
</pre><br />
| style="width:50%;" |[[Fichier:TestLCDArduino.jpg|centré|vignette|375x375px|<div style="text-align:center;">Test LCD via IDE Arduino</div>]]<br />
<br />
|}<br />
Maintenant que cela fonctionne, nous pouvons commencer à écrire notre Librairie pour faire fonctionner notre carte.<br />
<br />
=== Librairie HD44780 ===<br />
Nous avons commencer par reprendre la librairie d'ancien élève, merci à eux pour leur travail.<br />
<br />
Dans notre cas, pour l'utilisation la plus simple nous avons besoin de plusieurs fonctions. La première écrit un caractère sur l'écran, la deuxième copie une ligne et la dernière efface une ligne.<br />
<br />
HD44780_CopyLine1in0 :<br />
<br />
Permet de copier la seconde ligne sur la première. Pour ce faire, on se place au début de la première ligne, on écrit le contenu du tableau de caractère, et on le vide ensuite (EmptyLine1).<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_CopyLine1in0(char line1[], int nbrows, int nbcols, int ind_line1) {<br />
for (int i = 0; i < ind_line1; i++) {<br />
int address_ligne0 = HD44780_XY2Adrr(nbrows, nbcols, 0, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_ligne0);<br />
HD44780_WriteData(line1[i],0);<br />
}<br />
HD44780_EmptyLine1(line1,nbcols);<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_EraseLine :<br />
<br />
Permet d'effacer une ligne. Pour ce faire on se place au début de la ligne voulue, et on écrit une suite de caractère vide.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_EraseLine(int nbrows, int nbcols, int line) {<br />
int address_line1;<br />
char espace = ' ';<br />
for (int i = 0; i < nbcols; i++) {<br />
address_line1 = HD44780_XY2Adrr(nbrows, nbcols, line, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_line1);<br />
HD44780_WriteData(espace,0);<br />
}<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_WriteChar :<br />
<br />
Permet d'écrire un caractère sur l'écran. Chaque caractère écrit sur la seconde ligne est placé dans un tableau de caractère. <br />
<br />
Lorsqu'on arrive au bout d'une ligne : Si nous sommes à la première ligne (Ligne 0), on passe à la seconde (Ligne 1) et on se replace au début des colonnes. Si nous sommes à la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_WriteChar(char car, char line1[], int* ind_line1, int nbrows, int nbcols, int* row, int* col) {<br />
if ((*col) == nbcols) {<br />
(*col) = 0;<br />
if ((*row) <= 1) (*row)++;<br />
if ((*row) > 1) {<br />
(*row) = 1;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1);<br />
}<br />
(*ind_line1) = 0;<br />
}<br />
<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(car,1);<br />
(*col)++;<br />
if ((*row) == 1) <br />
{<br />
line1[*ind_line1] = car;<br />
(*ind_line1)++;<br />
}<br />
}<br />
</pre><br />
|}VIDEO <br />
<br />
Super, ca fonctionne ! <br />
<br />
Désormais, nous voulons que notre écran affiche ce qu'il recoit via le bus SPI. <br />
<br />
=== Communication SPI ===<br />
Pour cela il nous faut initialiser le maitre (un arduino UNO) et l'esclave (notre carte LCD). <br />
<br />
Puis que le maitre transmette des données et que l'esclave les recoivent. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Maitre<br />
! scope="col" | Code Esclave<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS);<br />
DDRB &= ~(1 << SPI_MISO);<br />
SPCR |= (1 << MSTR);<br />
SPCR |= (1 << SPE) | (1<<SPR0) | (1<<SPR1);<br />
}<br />
<br />
void SPI_MasterTransmit(char cData)<br />
{<br />
SPDR = cData;<br />
while(!(SPSR & (1<<SPIF)));<br />
}<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MISO);<br />
DDRB &= ~((1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS));<br />
SPCR |= (1 << SPE); <br />
}<br />
<br />
char SPI_SlaveReceive(void)<br />
{<br />
/* Attendre la fin de la réception */<br />
while (!(SPSR & (1 << SPIF)));<br />
char receivedData = SPDR;<br />
return receivedData;<br />
}<br />
<br />
</pre><br />
<br />
|}<br />
Faisons un petit test en envoyant des 'A' suivis de 'B' et enfin un 'X' pour terminer.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Test du Maitre<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
int main()<br />
{<br />
...<br />
...<br />
while (x<17)<br />
{<br />
SPI_MasterTransmit('A');<br />
_delay_ms(100);<br />
SPI_MasterTransmit('B');<br />
x++;<br />
PORTD ^= (1<<7);<br />
_delay_ms(100);<br />
}<br />
SPI_MasterTransmit('X');<br />
while(1)<br />
{<br />
}<br />
}<br />
<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}Notre test fonctionne mais cela n'a pas été sans peine. Nous avons rencontré énormément de problème sur la communication SPI. La communication était clairement douteuse et aléatoire. <br />
<br />
==== Problèmes rencontrés ====<br />
Plusieurs pistes ont été considérées pour comprendre le problème qu'on avait avec le SPI, était-ce l'arduino UNO? Notre connecteur? Le shield? Notre carte?<br />
Au départ, par soucis de praticité, nous voulions utiliser l'arduino UNO qui disposait de fonctionnalités de test simple avant de passer au shield, mais à chaque essai, le SPI ne fonctionait pas correctement bien qu'on pouvait observer à l'oscilloscope que le message était bien envoyé à notre carte.<br />
<br />
Finalement, nous sommes directement passé à la communication SPI avec notre shield, qui cette fois-ci, permettait d'avoir un résultat satisfaisant. Le résultat n'était pas parfait car on remarquait que la position des fils déterminait si la communication allait fonctionner, il fallait donc trouver la position qui permettait cette communication.<br />
Pour régler ce problème, nous avons déterminé la fréquence de travail du SPI utilisé par le shield et notre carte, pour vérifier qu'il n'y ait pas de problèmes de synchronisation ou que la fréquence utilisée soit bien adaptée. Pour ce faire nous avons observé à l'oscilloscope les différentes divisions de fréquences possibles en vérifiant en même temps que la communication SPI fonctionne bien. Les résultats sont surprenant, car peu importe la fréquence de travail, aucun problème n'a été détécté.<br />
<br />
=== Communication SPI par interruption ===<br />
Il nous faut maitenant communiquer par SPI par interruption car cela offre certains avantages par rapport à la communication SPI standard sans interruption, en particulier en termes d'efficacité et de gestion du temps. En effet, l'utilisation d'interruptions permet au microcontrôleur de gérer d'autres tâches pendant les transferts SPI. Plutôt que d'attendre de manière synchrone la fin d'une transaction SPI, le microcontrôleur peut être informé via une interruption lorsque les données sont prêtes à être lues ou écrites. Cela permet un multitâche plus efficace. Ce qui va nous être trés pratique sachant que le projet comporte plusieurs cartes filles.<br />
<br />
Pour cela il nous faut coté maitre et esclave activé le mode SPI Interrupt lors de l'initialisation du SPI, on rajoute donc <code>SPCR |= (1<<SPIE);</code> lors à l'initialisation.<br />
<br />
Ensuite on génère l'interruption coté esclave à la fin de l'initalisation et on configure notre ISR.<br />
<br />
Le maitre à plusieurs type d'envoie possible :<br />
<br />
0x00 : Demande le type de la carte.<br />
<br />
0x01 : Active la communication avec la carte LCD.<br />
<br />
0xff : Met fin à la communication.<br />
<br />
Voici comment l'ISR lui fonctionne, si je recois 0x00 je renvoie on type, 0x01 je passe en mode EnReception. <br />
<br />
En mode EnReception : lorsque je recois un octet je l'ajoute à un buffer, lorsque je recois 0xff je désactive le mode en Reception.<br />
<br />
Dans mon main, une fois que mon mode EnRecption est désactivé mais que mon indice du buffer et supérieur à 0 alors je peux traiter mes octets.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code ISR<br />
! scope="col" | Code Main<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
ISR(SPI_STC_vect) {<br />
uint8_t data = SPDR;<br />
if(EnReception == 1)<br />
switch (data){<br />
case 0xff:<br />
EnReception=0;<br />
break;<br />
default :<br />
buffer[IndBuffer++]=data;<br />
}<br />
else<br />
switch (data){<br />
case 0x00: <br />
sendType();<br />
break;<br />
case 0x01:<br />
EnReception=1;<br />
break;<br />
}<br />
}<br />
</pre> <br />
| style="width:50%;" |<pre><br />
while (1) {<br />
if (EnReception == 0 && IndBuffer>0)<br />
{<br />
for(int i=0; i < IndBuffer; i++)<br />
{<br />
"Fonction de traitement"<br />
}<br />
IndBuffer=0;<br />
}<br />
}<br />
</pre><br />
<br />
|}<br />
<br />
=== Gestion des caractères spéciaux ===<br />
Nous avons décider de gérer 4 caractères spéciaux différents : \n , \t, \b, \r<br />
<br />
Pour cela on créé la fonction <code>HD44780_Traitement</code> qui sera notre fonction principale.<br />
<br />
Si on recoit un caractère classique alors on l'affiche grâce à <code>HD44780_WriteChar</code> précédemment crée.<br />
<br />
Sinon il sagit d'un caractère spécial et alors on le traite dans un switch case :<br />
<br />
==== \n ====<br />
Si on est sur la première ligne, on se place au début de la seconde.<br />
<br />
Si on est sur la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \n<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\n': //Retour à la ligne<br />
switch (*row)<br />
{<br />
case 0:<br />
(*col) = 0;<br />
(*row) = 1;<br />
break;<br />
case 1:<br />
*col = 0;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1); <br />
*ind_line1 = 0;<br />
break; <br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \r ====<br />
On se replace au début de la ligne sur laquelle on est actuellement en train d'écrire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \r<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\r': // Retour chariot<br />
*col = 0;<br />
(*ind_line1) = 0;<br />
HD44780_EmptyLine1(line1,nbcols);<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \r ====<br />
On efface le caractère précédent, ajuste la position du curseur, et passe à la ligne supérieure si nécessaire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \b<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\b': // Retour arrière<br />
switch (*row)<br />
{<br />
case 0:<br />
if (*col > 0)<br />
{<br />
(*col)--;//Retourne sur le caractère précédent<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);//"L'efface"<br />
_delay_ms(500);<br />
<br />
}<br />
break;<br />
case 1:<br />
if (*col > 0)<br />
{<br />
(*col)--;<br />
(*ind_line1) --;<br />
}<br />
else <br />
{<br />
(*row) = 0;<br />
(*col) = 15;<br />
}<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);<br />
break;<br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \t ====<br />
On écrit 4 espaces, à la suite de notre position actuelle.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \t<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\t': // Tabulation de 4 caractères<br />
for (int i=0; i < 4; i++)<br />
{ <br />
char espace = ' ';<br />
HD44780_WriteChar(espace,line1,ind_line1,nbrows,nbcols,row,col);<br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
=== Gestion des codes VT100 ===<br />
Pour finir, nous allons gérer quelques codes VT100, les déplacements de curseurs.<br />
<br />
Pour envoyer un code VT100 pour déplacer le curseur le maitre doit nous envoyer:<br />
<br />
# Le code ESCAPE (0x1b)<br />
# Le CURSOR_MODE (0x1c)<br />
# Et enfin le mouvement du curseur souhaité CURSOR_UP (0x41), CURSOR_DOWN (0x42), CURSOR_RIGHT (0x43), CURSOR_LEFT (0x44).<br />
<br />
On gère cela dans la fonction VT100_Traitement.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void VT100_Traitement(char car, int nbrows, int nbcols, int* row, int* col, int* vt100_mode)<br />
{<br />
if (*vt100_mode == 1) // CURSOR_MODE<br />
{<br />
int address;<br />
<br />
switch (car)<br />
{<br />
case CURSOR_UP:<br />
*row = (*row == 1) ? 0 : *row;<br />
break;<br />
<br />
case CURSOR_DOWN:<br />
*row = (*row == 0) ? 1 : *row;<br />
break;<br />
<br />
case CURSOR_RIGHT:<br />
*col = (*col < nbcols - 1) ? (*col + 1) : *col;<br />
break;<br />
<br />
case CURSOR_LEFT:<br />
*col = (*col > 0) ? (*col - 1) : *col;<br />
break;<br />
}<br />
<br />
address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteCommand(LCD_ON | CURSOR_BLINK);<br />
}<br />
}<br />
<br />
</pre><br />
|}<br />
VIDEO<br />
<br />
=== '''Gestion des primitives systèmes''' ===<br />
Voici les primitives systèmes pour la carte mère, elle permettent de communiquer les chaînes de caractères à envoyer en préparant une transmission SPI constituée de l'octet de commande 0x01 et des données correspondants aux caractères.<br />
<br />
La fonction Reset_Display permet de reset l'affichage de l'écran et permet aussi à la carte mère de le remarquer en lui attribuant un numéro de port.<br />
<br />
La fonction Transmit_to_display est la fonction de transmission de données par SPI. Elle utilise les fonctions SPI créées précédemment pour envoyer les données à afficher.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<code><nowiki>#include "display.h"<br />
<br />
void Reset_display(volatile uint8_t *resPort, volatile uint8_t resSel) //Utile pour reset l'ecran<br />
{<br />
*resPort &= ~(1<<resSel);<br />
_delay_ms(1);<br />
*resPort |= (1<<resSel);<br />
}<br />
<br />
<br />
void Transmit_To_display(uint8_t data, volatile uint8_t *ssPort, volatile uint8_t ss)<br />
{<br />
selectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
transferSPI(data);<br />
_delay_ms(1);<br />
unselectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
}</nowiki></code><br />
|}<br />
= Références utiles =<br />
Lien du git :<br />
<br />
https://archives.plil.fr/mchauvel/PICO_Taha_NEHARI_Martin_CHAUVELIERE.git<br />
<br />
https://github.com/Matiasus/HD44780<br />
<br />
NHD-C12832A1Z-FSW-FBW-3V3-ND<br />
<br />
http://cdzillidan.free.fr/electronique-numerique/modules/afficheurs-lcd/hd44780/fonctionnement-interne.html<br />
<br />
https://michlstechblog.info/blog/raspberry-pi-connecting-a-hd44780-display-with-i2c-bus/<br />
<br />
ReX : Merci d'utiliser le squelette de page présenté en séance.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-1&diff=2834SE4Binome2023-12024-01-16T16:53:27Z<p>Tnehari : </p>
<hr />
<div>= Ordonnanceur =<br />
<br />
== Soudure et Test du SHIELD ==<br />
Au cours des 2 premières séances nous avons soudé et testé notre Shield<br />
[[Fichier:ShieldSoudé.jpg|thumb|center|300x300px|<div style="text-align:center;">Shield soudé et monté sur Arduino</div>]]<br />
<br />
Sur l'un des connecteurs, la led est abîmée dû à une soudure excessive. Sachant que les leds sont uniquement utilisées en tant qu'indicateurs pour savoir quelle carte fille à le contrôle et que nous n'en utiliserons pas plus de 3 pour tester nos programmes, cela ne vas pas avoir d'influence négative.<br />
Le potentiomètre permet de régler le niveau de luminosité de l'écran et le connecteur HE10 permettra de comuniquer avec l'écran.<br />
Les problèmes rencontrés sont les suivants : Au départ, la carte ne fonctionnait pas, le soucis étant le quartz mal soudé, c'est à l'aide d'un pistolet à air chaud que celui-ci à été ressoudé. Un autre problème était le reset de la carte fille qui ne fonctionnait pas non plus, une ressoudure classique a permis de le faire fonctionner.<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Code<br />
! scope="col"| Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#include <avr/io.h><br />
<br />
void init_led(){<br />
DDRD=0x92;<br />
DDRC=0x09;<br />
}<br />
<br />
int main(){<br />
init_led();<br />
while(1)<br />
{<br />
PORTD=0x92;<br />
PORTC=0x09;<br />
}<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
[[Fichier:ShieldLed.jpg|thumb|center|300x300px|<div style="text-align:center;">Test des Leds du Shield</div>]]<br />
|}<br />
Puis nous avons aussi soudé l'adaptateur HE10 pour l'utilisation de la matrice de leds[[Fichier:Adaptateur HE10.jpg|thumb|center|300x300px|<div style="text-align:center;">Adaptateur HE10 pour Matrice de leds</div>]]<br />
<br />
== Programmation de l'Ordonnanceur ==<br />
Nous commençons maintenant l'ordonnanceur, tout d'abord nous créeons la structure de nos Taches.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
struct TacheInfo{<br />
void (*depart)(void);<br />
uint16_t SPointeur;<br />
int etat;<br />
};<br />
</pre> <br />
|}<br />
Puis nous ajoutons les 2 premières taches demandées qui sont de faire clignoter 2 leds différentes à des timing différents.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheA(){<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
_delay_ms(300);<br />
}<br />
}<br />
<br />
void TacheB(){<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
struct TacheInfo Taches[2]={<br />
{TacheA,0x0600,0},<br />
{TacheB,0x0700,0}<br />
};<br />
<br />
</pre> <br />
|}<br />
On s'occupe maintenant de l'ordonnanceur, ainsi que de l'ISR.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{ <br />
PORTD ^= 0x02;<br />
courant++;<br />
if (courant == NBR_TACHE) courant = 0;<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect,ISR_NAKED)<br />
{<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTER();<br />
Taches[courant].SPointeur = SP;<br />
<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].SPointeur;<br />
RESTORE_REGISTER();<br />
asm volatile ( "reti" );<br />
}<br />
</pre><br />
|}<br />
Nous avons décider de faire clignoter une LED (PORTD ^= 0x02) à chaques utilisations de la fonction ordonnanceur() dans l'ISR.<br />
<br />
La variable courant indique la Tache qui est actuellement en cours.<br />
<br />
A chaque chaques changements de tache, l'ISR se déclenche enregistre la tache en cours (les registres ainsi que le Stack Pointer), appel l'ordonnanceur, puis change "charge" la tache suivante.<br />
<br />
On oublie pas maintenant de générer l'interruption toute les 20ms, pour cela on choisit un prescaler de 1024 et un nombre de ticks de 312.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define PRESCALER 1024<br />
#define NB_TICK 312<br />
#define CTC1 WGM12<br />
<br />
void init_timer(){<br />
TCCR1A = 0; // No output pin connected, no PWM mode enabled<br />
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match<br />
#if (PRESCALER==1024)<br />
TCCR1B |= (1<<CS12 | 1<<CS10);<br />
#endif<br />
OCR1A = NB_TICK;<br />
TCNT1 = 0;<br />
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt<br />
}<br />
</pre><br />
|}<br />
Ainsi que d'initialiser les Taches pour assurer le bon fonctionnement de notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_taches(int pid)<br />
{<br />
int save=SP;<br />
SP=Taches[pid].SPointeur;<br />
uint16_t adresse=(uint16_t)Taches[pid].depart;<br />
asm volatile ("push %0 \n\t" : : "r" (adresse & 0x00ff));<br />
asm volatile ("push %0 \n\t" : : "r" ((adresse & 0xff00) >> 8));<br />
SAVE_REGISTER();<br />
Taches[pid].SPointeur=SP;<br />
SP=save;<br />
}<br />
</pre><br />
|}<br />
On peut maintenant tester notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Vidéo<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define NBR_TACHE 2<br />
int main(void){<br />
init_ports();<br />
init_timer();<br />
init_taches(1);<br />
sei();<br />
SP = Taches[courant].SPointeur;<br />
Taches[courant].depart();<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
Les 2 leds clignotent bien avec le bon timing, et la led témoin de l'ordonnanceur clignotent aussi, ce qui indique que l'ISR est bien actif.<br />
<br />
Nous pouvons donc maitenant passer à la gestion des "sleeps".<br />
<br />
En effet, l'utilisation de _delay_ms dans chaque tache n'est pas la manière la plus optimale de procéder. Et meme cela nous bloquera par la suite.<br />
<br />
Nous ajoute donc à la structure de nos Taches, une structure InfoEndormi, qui, comme son nom l'indique nous donne des informations si la tache est endormie. A savoir la raison mais aussi des donnees comme par exemple le temps que cette tache doit passer endormie.<br />
<br />
Puis afin de remplacer _delay_ms, nous créeons une fonction Attente qui endors une tache pour un temps donné.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define REVEILLE 0<br />
#define ENDORMI 1<br />
#define RAISON_DELAY 0<br />
<br />
struct InfoEndormi{<br />
int raison;<br />
uint16_t donnee;<br />
}sleep_t;<br />
<br />
<br />
struct TacheInfo{<br />
void (*depart)(void); <br />
uint16_t SPointeur;<br />
int etat;<br />
struct InfoEndormi endormi;<br />
};<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void Attente(uint16_t temps_ms){<br />
cli();<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_DELAY;<br />
Taches[Tache_courante].endormi.donnee = temps_ms;<br />
TCNT1 = 0;<br />
sei();<br />
}<br />
</pre><br />
<br />
|}<br />
Voila maitenant nos taches, il est important de créer une TacheZombie qui comme son nom l'indique est toujours révéillée.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheZombie() //Tache toujours réveillé<br />
{<br />
while(1)<br />
{<br />
_delay_ms(1.5*PERIODE_INTERUPTION); //Delay légèrement supèrieur à la periode pour éviter tout soucis<br />
}<br />
}<br />
<br />
void TacheA()<br />
{<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
Attente(300);<br />
}<br />
}<br />
<br />
void TacheB()<br />
{<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
Attente(500);<br />
}<br />
}<br />
</pre><br />
|}<br />
Il est important maitenant de modifier notre ordonnanceur afin que celui-ci puisse recalculer le nouveau temps de sleep d'une tache et si ce temps devient inférieur ou ègale à 0 alors l'ordonnacnceur réveille la tache.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{<br />
PORTD ^= 0x02;<br />
for(int i = 0; i < NBR_TACHE; i++)<br />
{<br />
if(Taches[i].etat == ENDORMI && Taches[Tache_courante].endormi.raison == RAISON_DELAY)<br />
{<br />
uint16_t diff_temps = PERIODE_INTERUPTION;<br />
if(TCNT1 != 0)<br />
{<br />
//Calcul précis de la différence de temps (pas obligatoirement 20 ms)<br />
diff_temps = ((TCNT1*PERIODE_INTERUPTION*10)/OCR1A)/10;<br />
TCNT1 = 0;<br />
}<br />
Taches[i].endormi.donnee -= diff_temps;<br />
<br />
if(Taches[i].endormi.donnee <= 0)<br />
{<br />
Taches[i].etat = REVEILLE;<br />
}<br />
}<br />
}<br />
<br />
do<br />
{<br />
Tache_courante++;<br />
if (Tache_courante == NBR_TACHE) Tache_courante = 0;<br />
}<br />
while(Taches[Tache_courante].etat == ENDORMI);<br />
}<br />
<br />
</pre><br />
|}<br />
Maintenant que cela est fait, nous pouvons ajouter 2 nouvelles taches qui sont la lecture et l'ecriture sur le port série.<br />
<br />
Pour cela, nous allons procéder avec des sémaphores. En effet, il ne peut y avoir que 1 seule tache en écriture ou en lecture, il faut donc que si plusieurs taches essaient de prendre la ressource, cette ressource soit donner à la première arrivé et que les autres taches en attendant patientent.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void semaphore_e(int ACTION){<br />
if (ACTION == PRENDRE)<br />
{<br />
while(1)<br />
{<br />
cli();<br />
if (semaphore_ecriture > 0) //Si ressource dispo <br />
{<br />
semaphore_ecriture = 0;<br />
sei();<br />
break;<br />
} else<br />
{<br />
// La ressource est occupée, on endort la tache<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_ECRITURE;<br />
TCNT1=0;<br />
TIMER1_COMPA_vect();<br />
}<br />
sei();<br />
while(semaphore_ecriture==0);<br />
}<br />
<br />
}<br />
else if (ACTION == LAISSER)<br />
{<br />
cli();<br />
semaphore_ecriture = 1;<br />
sei();<br />
}<br />
}<br />
</pre><br />
|}<br />
On fait la meme chose pour la lecture.<br />
<br />
On oublie pas d'initialiser le port série avec les bons paramètres, créer les taches, puis on test.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_serie(long int vitesse){<br />
UBRR0=FREQ_CPU/(((unsigned long int)vitesse)<<4)-1; <br />
// configure la vitesse<br />
UCSR0B=(1<<TXEN0 | 1<<RXEN0); // autorise l'envoi et la réception<br />
UCSR0C=(1<<UCSZ01 | 1<<UCSZ00); // 8 bits et 1 bit de stop<br />
UCSR0A &= ~(1 << U2X0); // double vitesse désactivée<br />
}<br />
<br />
</pre><br />
| style="width:50%;" |[[Fichier:Lecture EcritureSerie.jpg|centré|vignette|356x356px|<div style="text-align:center;">Test de la lecture et de l'écriture sur le port série.(On écrie 9 caractères puis le shield nous renvoie les mêmes 9) </div>]]<br />
<br />
|}<br />
= Carte FPGA =<br />
<br />
= Carte électronique numérique =<br />
<br />
== Conception et Création ==<br />
Nous avons choisi la Carte Fille : Ecran LCD <br />
<br />
Pendant la 3ème séance nous avons finis le Schématic de la carte <br />
[[Fichier:SCH.png|centré|vignette|700x700px|<div style="text-align:center;">Schematic de la Carte Fille : Ecran LCD</div>]]<br />
Puis nous avons Routé la carte et envoyé à la Fabrication<br />
[[Fichier:PCB LCD.png|centré|vignette|550x550px|<div style="text-align:center;">Routage de la Carte Fille : Ecran LCD</div>]]<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Carte non soudée<br />
! scope="col"| Carte soudé<br />
! scope="col"| Video Test<br />
|-<br />
| style="width:50%;" |[[Fichier:Carte LCD non soudée.jpg|centré|vignette|300x300px|<div style="text-align:center;">Carte non soudée</div>]]<br />
| style="width:50%;" |[[Fichier:Carte LCD soudee.jpg|centré|vignette|400x400px|<div style="text-align:center;">Carte soudée</div>]]<br />
<br />
|}<br />
<br />
== Programmation de la carte LCD ==<br />
Tout d'abord, nous avons voulu tester le bon fonctionnement de notre carte mais surtout du bon controle de l'ecran HD44780 grâce à l'IDE Arduino.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
const int rs = 2, en = 18, d4 = 14, d5 = 15, d6 = 16, d7 = 17;<br />
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);<br />
<br />
void setup() {<br />
// set up the LCD's number of columns and rows:<br />
pinMode(9,OUTPUT);<br />
digitalWrite(9,LOW);<br />
lcd.begin(16, 2);<br />
// Print a message to the LCD.<br />
lcd.print("Je compte");<br />
}<br />
<br />
void loop() {<br />
// set the cursor to column 0, line 1<br />
// (note: line 1 is the second row, since counting begins with 0):<br />
lcd.setCursor(0, 1);<br />
// print the number of seconds since reset:<br />
lcd.print(millis() / 1000);<br />
}<br />
</pre><br />
| style="width:50%;" |[[Fichier:TestLCDArduino.jpg|centré|vignette|375x375px|<div style="text-align:center;">Test LCD via IDE Arduino</div>]]<br />
<br />
|}<br />
Maintenant que cela fonctionne, nous pouvons commencer à écrire notre Librairie pour faire fonctionner notre carte.<br />
<br />
=== Librairie HD44780 ===<br />
Nous avons commencer par reprendre la librairie d'ancien élève, merci à eux pour leur travail.<br />
<br />
Dans notre cas, pour l'utilisation la plus simple nous avons besoin de plusieurs fonctions. La première écrit un caractère sur l'écran, la deuxième copie une ligne et la dernière efface une ligne.<br />
<br />
HD44780_CopyLine1in0 :<br />
<br />
Permet de copier la seconde ligne sur la première. Pour ce faire, on se place au début de la première ligne, on écrit le contenu du tableau de caractère, et on le vide ensuite (EmptyLine1).<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_CopyLine1in0(char line1[], int nbrows, int nbcols, int ind_line1) {<br />
for (int i = 0; i < ind_line1; i++) {<br />
int address_ligne0 = HD44780_XY2Adrr(nbrows, nbcols, 0, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_ligne0);<br />
HD44780_WriteData(line1[i],0);<br />
}<br />
HD44780_EmptyLine1(line1,nbcols);<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_EraseLine :<br />
<br />
Permet d'effacer une ligne. Pour ce faire on se place au début de la ligne voulue, et on écrit une suite de caractère vide.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_EraseLine(int nbrows, int nbcols, int line) {<br />
int address_line1;<br />
char espace = ' ';<br />
for (int i = 0; i < nbcols; i++) {<br />
address_line1 = HD44780_XY2Adrr(nbrows, nbcols, line, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_line1);<br />
HD44780_WriteData(espace,0);<br />
}<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_WriteChar :<br />
<br />
Permet d'écrire un caractère sur l'écran. Chaque caractère écrit sur la seconde ligne est placé dans un tableau de caractère. <br />
<br />
Lorsqu'on arrive au bout d'une ligne : Si nous sommes à la première ligne (Ligne 0), on passe à la seconde (Ligne 1) et on se replace au début des colonnes. Si nous sommes à la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_WriteChar(char car, char line1[], int* ind_line1, int nbrows, int nbcols, int* row, int* col) {<br />
if ((*col) == nbcols) {<br />
(*col) = 0;<br />
if ((*row) <= 1) (*row)++;<br />
if ((*row) > 1) {<br />
(*row) = 1;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1);<br />
}<br />
(*ind_line1) = 0;<br />
}<br />
<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(car,1);<br />
(*col)++;<br />
if ((*row) == 1) <br />
{<br />
line1[*ind_line1] = car;<br />
(*ind_line1)++;<br />
}<br />
}<br />
</pre><br />
|}VIDEO <br />
<br />
Super, ca fonctionne ! <br />
<br />
Désormais, nous voulons que notre écran affiche ce qu'il recoit via le bus SPI. <br />
<br />
=== Communication SPI ===<br />
Pour cela il nous faut initialiser le maitre (un arduino UNO) et l'esclave (notre carte LCD). <br />
<br />
Puis que le maitre transmette des données et que l'esclave les recoivent. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Maitre<br />
! scope="col" | Code Esclave<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS);<br />
DDRB &= ~(1 << SPI_MISO);<br />
SPCR |= (1 << MSTR);<br />
SPCR |= (1 << SPE) | (1<<SPR0) | (1<<SPR1);<br />
}<br />
<br />
void SPI_MasterTransmit(char cData)<br />
{<br />
SPDR = cData;<br />
while(!(SPSR & (1<<SPIF)));<br />
}<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MISO);<br />
DDRB &= ~((1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS));<br />
SPCR |= (1 << SPE); <br />
}<br />
<br />
char SPI_SlaveReceive(void)<br />
{<br />
/* Attendre la fin de la réception */<br />
while (!(SPSR & (1 << SPIF)));<br />
char receivedData = SPDR;<br />
return receivedData;<br />
}<br />
<br />
</pre><br />
<br />
|}<br />
Faisons un petit test en envoyant des 'A' suivis de 'B' et enfin un 'X' pour terminer.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Test du Maitre<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
int main()<br />
{<br />
...<br />
...<br />
while (x<17)<br />
{<br />
SPI_MasterTransmit('A');<br />
_delay_ms(100);<br />
SPI_MasterTransmit('B');<br />
x++;<br />
PORTD ^= (1<<7);<br />
_delay_ms(100);<br />
}<br />
SPI_MasterTransmit('X');<br />
while(1)<br />
{<br />
}<br />
}<br />
<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}Notre test fonctionne mais cela n'a pas été sans peine. Nous avons rencontré énormément de problème sur la communication SPI. La communication était clairement douteuse et aléatoire. <br />
<br />
==== Problèmes rencontrés ====<br />
Plusieurs pistes ont été considérées pour comprendre le problème qu'on avait avec le SPI, était-ce l'arduino UNO? Notre connecteur? Le shield? Notre carte?<br />
Au départ, par soucis de praticité, nous voulions utiliser l'arduino UNO qui disposait de fonctionnalités de test simple avant de passer au shield, mais à chaque essai, le SPI ne fonctionait pas correctement bien qu'on pouvait observer à l'oscilloscope que le message était bien envoyé à notre carte.<br />
<br />
Finalement, nous sommes directement passé à la communication SPI avec notre shield, qui cette fois-ci, permettait d'avoir un résultat satisfaisant. Le résultat n'était pas parfait car on remarquait que la position des fils déterminait si la communication allait fonctionner, il fallait donc trouver la position qui permettait cette communication.<br />
Pour régler ce problème, nous avons déterminé la fréquence de travail du SPI utilisé par le shield et notre carte, pour vérifier qu'il n'y ait pas de problèmes de synchronisation ou que la fréquence utilisée soit bien adaptée. Pour ce faire nous avons observé à l'oscilloscope les différentes divisions de fréquences possibles en vérifiant en même temps que la communication SPI fonctionne bien. Les résultats sont surprenant, car peu importe la fréquence de travail, aucun problème n'a été détécté.<br />
<br />
=== Communication SPI par interruption ===<br />
Il nous faut maitenant communiquer par SPI par interruption car cela offre certains avantages par rapport à la communication SPI standard sans interruption, en particulier en termes d'efficacité et de gestion du temps. En effet, l'utilisation d'interruptions permet au microcontrôleur de gérer d'autres tâches pendant les transferts SPI. Plutôt que d'attendre de manière synchrone la fin d'une transaction SPI, le microcontrôleur peut être informé via une interruption lorsque les données sont prêtes à être lues ou écrites. Cela permet un multitâche plus efficace. Ce qui va nous être trés pratique sachant que le projet comporte plusieurs cartes filles.<br />
<br />
Pour cela il nous faut coté maitre et esclave activé le mode SPI Interrupt lors de l'initialisation du SPI, on rajoute donc <code>SPCR |= (1<<SPIE);</code> lors à l'initialisation.<br />
<br />
Ensuite on génère l'interruption coté esclave à la fin de l'initalisation et on configure notre ISR.<br />
<br />
Le maitre à plusieurs type d'envoie possible :<br />
<br />
0x00 : Demande le type de la carte.<br />
<br />
0x01 : Active la communication avec la carte LCD.<br />
<br />
0xff : Met fin à la communication.<br />
<br />
Voici comment l'ISR lui fonctionne, si je recois 0x00 je renvoie on type, 0x01 je passe en mode EnReception. <br />
<br />
En mode EnReception : lorsque je recois un octet je l'ajoute à un buffer, lorsque je recois 0xff je désactive le mode en Reception.<br />
<br />
Dans mon main, une fois que mon mode EnRecption est désactivé mais que mon indice du buffer et supérieur à 0 alors je peux traiter mes octets.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code ISR<br />
! scope="col" | Code Main<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
ISR(SPI_STC_vect) {<br />
uint8_t data = SPDR;<br />
if(EnReception == 1)<br />
switch (data){<br />
case 0xff:<br />
EnReception=0;<br />
break;<br />
default :<br />
buffer[IndBuffer++]=data;<br />
}<br />
else<br />
switch (data){<br />
case 0x00: <br />
sendType();<br />
break;<br />
case 0x01:<br />
EnReception=1;<br />
break;<br />
}<br />
}<br />
</pre> <br />
| style="width:50%;" |<pre><br />
while (1) {<br />
if (EnReception == 0 && IndBuffer>0)<br />
{<br />
for(int i=0; i < IndBuffer; i++)<br />
{<br />
"Fonction de traitement"<br />
}<br />
IndBuffer=0;<br />
}<br />
}<br />
</pre><br />
<br />
|}<br />
<br />
=== Gestion des caractères spéciaux ===<br />
Nous avons décider de gérer 4 caractères spéciaux différents : \n , \t, \b, \r<br />
<br />
Pour cela on créé la fonction <code>HD44780_Traitement</code> qui sera notre fonction principale.<br />
<br />
Si on recoit un caractère classique alors on l'affiche grâce à <code>HD44780_WriteChar</code> précédemment crée.<br />
<br />
Sinon il sagit d'un caractère spécial et alors on le traite dans un switch case :<br />
<br />
==== \n ====<br />
Si on est sur la première ligne, on se place au début de la seconde.<br />
<br />
Si on est sur la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \n<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\n': //Retour à la ligne<br />
switch (*row)<br />
{<br />
case 0:<br />
(*col) = 0;<br />
(*row) = 1;<br />
break;<br />
case 1:<br />
*col = 0;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1); <br />
*ind_line1 = 0;<br />
break; <br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \r ====<br />
On se replace au début de la ligne sur laquelle on est actuellement en train d'écrire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \r<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\r': // Retour chariot<br />
*col = 0;<br />
(*ind_line1) = 0;<br />
HD44780_EmptyLine1(line1,nbcols);<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \r ====<br />
On efface le caractère précédent, ajuste la position du curseur, et passe à la ligne supérieure si nécessaire.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \b<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\b': // Retour arrière<br />
switch (*row)<br />
{<br />
case 0:<br />
if (*col > 0)<br />
{<br />
(*col)--;//Retourne sur le caractère précédent<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);//"L'efface"<br />
_delay_ms(500);<br />
<br />
}<br />
break;<br />
case 1:<br />
if (*col > 0)<br />
{<br />
(*col)--;<br />
(*ind_line1) --;<br />
}<br />
else <br />
{<br />
(*row) = 0;<br />
(*col) = 15;<br />
}<br />
char espace = ' ';<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(espace, 1);<br />
break;<br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
==== \t ====<br />
On écrit 4 espaces, à la suite de notre position actuelle.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code \t<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
case '\t': // Tabulation de 4 caractères<br />
for (int i=0; i < 4; i++)<br />
{ <br />
char espace = ' ';<br />
HD44780_WriteChar(espace,line1,ind_line1,nbrows,nbcols,row,col);<br />
}<br />
break;<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
<br />
=== Gestion des codes VT100 ===<br />
Pour finir, nous allons gérer quelques codes VT100, les déplacements de curseurs.<br />
<br />
Pour envoyer un code VT100 pour déplacer le curseur le maitre doit nous envoyer:<br />
<br />
# Le code ESCAPE (0x1b)<br />
# Le CURSOR_MODE (0x1c)<br />
# Et enfin le mouvement du curseur souhaité CURSOR_UP (0x41), CURSOR_DOWN (0x42), CURSOR_RIGHT (0x43), CURSOR_LEFT (0x44).<br />
<br />
On gère cela dans la fonction VT100_Traitement.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void VT100_Traitement(char car, int nbrows, int nbcols, int* row, int* col, int* vt100_mode)<br />
{<br />
if (*vt100_mode == 1) // CURSOR_MODE<br />
{<br />
int address;<br />
<br />
switch (car)<br />
{<br />
case CURSOR_UP:<br />
*row = (*row == 1) ? 0 : *row;<br />
break;<br />
<br />
case CURSOR_DOWN:<br />
*row = (*row == 0) ? 1 : *row;<br />
break;<br />
<br />
case CURSOR_RIGHT:<br />
*col = (*col < nbcols - 1) ? (*col + 1) : *col;<br />
break;<br />
<br />
case CURSOR_LEFT:<br />
*col = (*col > 0) ? (*col - 1) : *col;<br />
break;<br />
}<br />
<br />
address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteCommand(LCD_ON | CURSOR_BLINK);<br />
}<br />
}<br />
<br />
</pre><br />
|}<br />
VIDEO<br />
<br />
'''Gestion des codes VT100'''<br />
<br />
Voici les primitives systèmes pour la carte mère, elle permettent de communiquer les chaînes de caractères à envoyer en préparant une transmission SPI constituée de l'octet de commande 0x01 et des données correspondants aux caractères.<br />
<br />
La fonction Reset_Display permet de reset l'affichage de l'écran et permet aussi à la carte mère de le remarquer en lui attribuant un numéro de port.<br />
<br />
La fonction Transmit_to_display est la fonction de transmission de données par SPI. Elle utilise les fonctions SPI créées précédemment pour envoyer les données à afficher.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<code><nowiki>#include "display.h"<br />
<br />
void Reset_display(volatile uint8_t *resPort, volatile uint8_t resSel) //Utile pour reset l'ecran<br />
{<br />
*resPort &= ~(1<<resSel);<br />
_delay_ms(1);<br />
*resPort |= (1<<resSel);<br />
}<br />
<br />
<br />
void Transmit_To_display(uint8_t data, volatile uint8_t *ssPort, volatile uint8_t ss)<br />
{<br />
selectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
transferSPI(data);<br />
_delay_ms(1);<br />
unselectSlaveSPI(ssPort,ss);<br />
_delay_ms(1);<br />
}</nowiki></code><br />
|}<br />
= Références utiles =<br />
Lien du git :<br />
<br />
https://archives.plil.fr/mchauvel/PICO_Taha_NEHARI_Martin_CHAUVELIERE.git<br />
<br />
https://github.com/Matiasus/HD44780<br />
<br />
NHD-C12832A1Z-FSW-FBW-3V3-ND<br />
<br />
http://cdzillidan.free.fr/electronique-numerique/modules/afficheurs-lcd/hd44780/fonctionnement-interne.html<br />
<br />
https://michlstechblog.info/blog/raspberry-pi-connecting-a-hd44780-display-with-i2c-bus/<br />
<br />
ReX : Merci d'utiliser le squelette de page présenté en séance.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-1&diff=2824SE4Binome2023-12024-01-16T15:54:47Z<p>Tnehari : </p>
<hr />
<div>= Ordonnanceur =<br />
<br />
== Soudure et Test du SHIELD ==<br />
Au cours des 2 premières séances nous avons soudé et testé notre Shield<br />
[[Fichier:ShieldSoudé.jpg|thumb|center|300x300px|<div style="text-align:center;">Shield soudé et monté sur Arduino</div>]]<br />
<br />
Sur l'un des connecteurs, la led est abîmée dû à une soudure excessive. Sachant que les leds sont uniquement utilisées en tant qu'indicateurs pour savoir quelle carte fille à le contrôle et que nous n'en utiliserons pas plus de 3 pour tester nos programmes, cela ne vas pas avoir d'influence négative.<br />
Le potentiomètre permet de régler le niveau de luminosité de l'écran et le connecteur HE10 permettra de comuniquer avec l'écran.<br />
Les problèmes rencontrés sont les suivants : Au départ, la carte ne fonctionnait pas, le soucis étant le quartz mal soudé, c'est à l'aide d'un pistolet à air chaud que celui-ci à été ressoudé. Un autre problème était le reset de la carte fille qui ne fonctionnait pas non plus, une ressoudure classique a permis de le faire fonctionner.<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Code<br />
! scope="col"| Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#include <avr/io.h><br />
<br />
void init_led(){<br />
DDRD=0x92;<br />
DDRC=0x09;<br />
}<br />
<br />
int main(){<br />
init_led();<br />
while(1)<br />
{<br />
PORTD=0x92;<br />
PORTC=0x09;<br />
}<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
[[Fichier:ShieldLed.jpg|thumb|center|300x300px|<div style="text-align:center;">Test des Leds du Shield</div>]]<br />
|}<br />
Puis nous avons aussi soudé l'adaptateur HE10 pour l'utilisation de la matrice de leds[[Fichier:Adaptateur HE10.jpg|thumb|center|300x300px|<div style="text-align:center;">Adaptateur HE10 pour Matrice de leds</div>]]<br />
<br />
== Programmation de l'Ordonnanceur ==<br />
Nous commençons maintenant l'ordonnanceur, tout d'abord nous créeons la structure de nos Taches.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
struct TacheInfo{<br />
void (*depart)(void);<br />
uint16_t SPointeur;<br />
int etat;<br />
};<br />
</pre> <br />
|}<br />
Puis nous ajoutons les 2 premières taches demandées qui sont de faire clignoter 2 leds différentes à des timing différents.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheA(){<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
_delay_ms(300);<br />
}<br />
}<br />
<br />
void TacheB(){<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
struct TacheInfo Taches[2]={<br />
{TacheA,0x0600,0},<br />
{TacheB,0x0700,0}<br />
};<br />
<br />
</pre> <br />
|}<br />
On s'occupe maintenant de l'ordonnanceur, ainsi que de l'ISR.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{ <br />
PORTD ^= 0x02;<br />
courant++;<br />
if (courant == NBR_TACHE) courant = 0;<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect,ISR_NAKED)<br />
{<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTER();<br />
Taches[courant].SPointeur = SP;<br />
<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].SPointeur;<br />
RESTORE_REGISTER();<br />
asm volatile ( "reti" );<br />
}<br />
</pre><br />
|}<br />
Nous avons décider de faire clignoter une LED (PORTD ^= 0x02) à chaques utilisations de la fonction ordonnanceur() dans l'ISR.<br />
<br />
La variable courant indique la Tache qui est actuellement en cours.<br />
<br />
A chaque chaques changements de tache, l'ISR se déclenche enregistre la tache en cours (les registres ainsi que le Stack Pointer), appel l'ordonnanceur, puis change "charge" la tache suivante.<br />
<br />
On oublie pas maintenant de générer l'interruption toute les 20ms, pour cela on choisit un prescaler de 1024 et un nombre de ticks de 312.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define PRESCALER 1024<br />
#define NB_TICK 312<br />
#define CTC1 WGM12<br />
<br />
void init_timer(){<br />
TCCR1A = 0; // No output pin connected, no PWM mode enabled<br />
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match<br />
#if (PRESCALER==1024)<br />
TCCR1B |= (1<<CS12 | 1<<CS10);<br />
#endif<br />
OCR1A = NB_TICK;<br />
TCNT1 = 0;<br />
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt<br />
}<br />
</pre><br />
|}<br />
Ainsi que d'initialiser les Taches pour assurer le bon fonctionnement de notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_taches(int pid)<br />
{<br />
int save=SP;<br />
SP=Taches[pid].SPointeur;<br />
uint16_t adresse=(uint16_t)Taches[pid].depart;<br />
asm volatile ("push %0 \n\t" : : "r" (adresse & 0x00ff));<br />
asm volatile ("push %0 \n\t" : : "r" ((adresse & 0xff00) >> 8));<br />
SAVE_REGISTER();<br />
Taches[pid].SPointeur=SP;<br />
SP=save;<br />
}<br />
</pre><br />
|}<br />
On peut maintenant tester notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Vidéo<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define NBR_TACHE 2<br />
int main(void){<br />
init_ports();<br />
init_timer();<br />
init_taches(1);<br />
sei();<br />
SP = Taches[courant].SPointeur;<br />
Taches[courant].depart();<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
Les 2 leds clignotent bien avec le bon timing, et la led témoin de l'ordonnanceur clignotent aussi, ce qui indique que l'ISR est bien actif.<br />
<br />
Nous pouvons donc maitenant passer à la gestion des "sleeps".<br />
<br />
En effet, l'utilisation de _delay_ms dans chaque tache n'est pas la manière la plus optimale de procéder. Et meme cela nous bloquera par la suite.<br />
<br />
Nous ajoute donc à la structure de nos Taches, une structure InfoEndormi, qui, comme son nom l'indique nous donne des informations si la tache est endormie. A savoir la raison mais aussi des donnees comme par exemple le temps que cette tache doit passer endormie.<br />
<br />
Puis afin de remplacer _delay_ms, nous créeons une fonction Attente qui endors une tache pour un temps donné.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define REVEILLE 0<br />
#define ENDORMI 1<br />
#define RAISON_DELAY 0<br />
<br />
struct InfoEndormi{<br />
int raison;<br />
uint16_t donnee;<br />
}sleep_t;<br />
<br />
<br />
struct TacheInfo{<br />
void (*depart)(void); <br />
uint16_t SPointeur;<br />
int etat;<br />
struct InfoEndormi endormi;<br />
};<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void Attente(uint16_t temps_ms){<br />
cli();<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_DELAY;<br />
Taches[Tache_courante].endormi.donnee = temps_ms;<br />
TCNT1 = 0;<br />
sei();<br />
}<br />
</pre><br />
<br />
|}<br />
Voila maitenant nos taches, il est important de créer une TacheZombie qui comme son nom l'indique est toujours révéillée.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheZombie() //Tache toujours réveillé<br />
{<br />
while(1)<br />
{<br />
_delay_ms(1.5*PERIODE_INTERUPTION); //Delay légèrement supèrieur à la periode pour éviter tout soucis<br />
}<br />
}<br />
<br />
void TacheA()<br />
{<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
Attente(300);<br />
}<br />
}<br />
<br />
void TacheB()<br />
{<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
Attente(500);<br />
}<br />
}<br />
</pre><br />
|}<br />
Il est important maitenant de modifier notre ordonnanceur afin que celui-ci puisse recalculer le nouveau temps de sleep d'une tache et si ce temps devient inférieur ou ègale à 0 alors l'ordonnacnceur réveille la tache.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{<br />
PORTD ^= 0x02;<br />
for(int i = 0; i < NBR_TACHE; i++)<br />
{<br />
if(Taches[i].etat == ENDORMI && Taches[Tache_courante].endormi.raison == RAISON_DELAY)<br />
{<br />
uint16_t diff_temps = PERIODE_INTERUPTION;<br />
if(TCNT1 != 0)<br />
{<br />
//Calcul précis de la différence de temps (pas obligatoirement 20 ms)<br />
diff_temps = ((TCNT1*PERIODE_INTERUPTION*10)/OCR1A)/10;<br />
TCNT1 = 0;<br />
}<br />
Taches[i].endormi.donnee -= diff_temps;<br />
<br />
if(Taches[i].endormi.donnee <= 0)<br />
{<br />
Taches[i].etat = REVEILLE;<br />
}<br />
}<br />
}<br />
<br />
do<br />
{<br />
Tache_courante++;<br />
if (Tache_courante == NBR_TACHE) Tache_courante = 0;<br />
}<br />
while(Taches[Tache_courante].etat == ENDORMI);<br />
}<br />
<br />
</pre><br />
|}<br />
Maintenant que cela est fait, nous pouvons ajouter 2 nouvelles taches qui sont la lecture et l'ecriture sur le port série.<br />
<br />
Pour cela, nous allons procéder avec des sémaphores. En effet, il ne peut y avoir que 1 seule tache en écriture ou en lecture, il faut donc que si plusieurs taches essaient de prendre la ressource, cette ressource soit donner à la première arrivé et que les autres taches en attendant patientent.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void semaphore_e(int ACTION){<br />
if (ACTION == PRENDRE)<br />
{<br />
while(1)<br />
{<br />
cli();<br />
if (semaphore_ecriture > 0) //Si ressource dispo <br />
{<br />
semaphore_ecriture = 0;<br />
sei();<br />
break;<br />
} else<br />
{<br />
// La ressource est occupée, on endort la tache<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_ECRITURE;<br />
TCNT1=0;<br />
TIMER1_COMPA_vect();<br />
}<br />
sei();<br />
while(semaphore_ecriture==0);<br />
}<br />
<br />
}<br />
else if (ACTION == LAISSER)<br />
{<br />
cli();<br />
semaphore_ecriture = 1;<br />
sei();<br />
}<br />
}<br />
</pre><br />
|}<br />
On fait la meme chose pour la lecture.<br />
<br />
On oublie pas d'initialiser le port série avec les bons paramètres, créer les taches, puis on test.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_serie(long int vitesse){<br />
UBRR0=FREQ_CPU/(((unsigned long int)vitesse)<<4)-1; <br />
// configure la vitesse<br />
UCSR0B=(1<<TXEN0 | 1<<RXEN0); // autorise l'envoi et la réception<br />
UCSR0C=(1<<UCSZ01 | 1<<UCSZ00); // 8 bits et 1 bit de stop<br />
UCSR0A &= ~(1 << U2X0); // double vitesse désactivée<br />
}<br />
<br />
</pre><br />
| style="width:50%;" |[[Fichier:Lecture EcritureSerie.jpg|centré|vignette|356x356px|<div style="text-align:center;">Test de la lecture et de l'écriture sur le port série.(On écrie 9 caractères puis le shield nous renvoie les mêmes 9) </div>]]<br />
<br />
|}<br />
= Carte FPGA =<br />
<br />
= Carte électronique numérique =<br />
<br />
== Conception et Création ==<br />
Nous avons choisi la Carte Fille : Ecran LCD <br />
<br />
Pendant la 3ème séance nous avons finis le Schématic de la carte <br />
[[Fichier:SCH.png|centré|vignette|700x700px|<div style="text-align:center;">Schematic de la Carte Fille : Ecran LCD</div>]]<br />
Puis nous avons Routé la carte et envoyé à la Fabrication<br />
[[Fichier:PCB LCD.png|centré|vignette|550x550px|<div style="text-align:center;">Routage de la Carte Fille : Ecran LCD</div>]]<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Carte non soudée<br />
! scope="col"| Carte soudé<br />
! scope="col"| Video Test<br />
|-<br />
| style="width:50%;" |[[Fichier:Carte LCD non soudée.jpg|centré|vignette|300x300px|<div style="text-align:center;">Carte non soudée</div>]]<br />
| style="width:50%;" |[[Fichier:Carte LCD soudee.jpg|centré|vignette|400x400px|<div style="text-align:center;">Carte soudée</div>]]<br />
<br />
|}<br />
<br />
== Programmation de la carte LCD ==<br />
Tout d'abord, nous avons voulu tester le bon fonctionnement de notre carte mais surtout du bon controle de l'ecran HD44780 grâce à l'IDE Arduino.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
const int rs = 2, en = 18, d4 = 14, d5 = 15, d6 = 16, d7 = 17;<br />
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);<br />
<br />
void setup() {<br />
// set up the LCD's number of columns and rows:<br />
pinMode(9,OUTPUT);<br />
digitalWrite(9,LOW);<br />
lcd.begin(16, 2);<br />
// Print a message to the LCD.<br />
lcd.print("Je compte");<br />
}<br />
<br />
void loop() {<br />
// set the cursor to column 0, line 1<br />
// (note: line 1 is the second row, since counting begins with 0):<br />
lcd.setCursor(0, 1);<br />
// print the number of seconds since reset:<br />
lcd.print(millis() / 1000);<br />
}<br />
</pre><br />
| style="width:50%;" |[[Fichier:TestLCDArduino.jpg|centré|vignette|375x375px|<div style="text-align:center;">Test LCD via IDE Arduino</div>]]<br />
<br />
|}<br />
Maintenant que cela fonctionne, nous pouvons commencer à écrire notre Librairie pour faire fonctionner notre carte.<br />
<br />
=== Librairie HD44780 ===<br />
Nous avons commencer par reprendre la librairie d'ancien élève, merci à eux pour leur travail.<br />
<br />
Dans notre cas, pour l'utilisation la plus simple nous avons besoin de plusieurs fonctions. La première écrit un caractère sur l'écran, la deuxième copie une ligne et la dernière efface une ligne.<br />
<br />
HD44780_CopyLine1in0 :<br />
<br />
Permet de copier la seconde ligne sur la première. Pour ce faire, on se place au début de la première ligne, on écrit le contenu du tableau de caractère, et on le vide ensuite (EmptyLine1).<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_CopyLine1in0(char line1[], int nbrows, int nbcols, int ind_line1) {<br />
for (int i = 0; i < ind_line1; i++) {<br />
int address_ligne0 = HD44780_XY2Adrr(nbrows, nbcols, 0, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_ligne0);<br />
HD44780_WriteData(line1[i],0);<br />
}<br />
HD44780_EmptyLine1(line1,nbcols);<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_EraseLine :<br />
<br />
Permet d'effacer une ligne. Pour ce faire on se place au début de la ligne voulue, et on écrit une suite de caractère vide.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_EraseLine(int nbrows, int nbcols, int line) {<br />
int address_line1;<br />
char espace = ' ';<br />
for (int i = 0; i < nbcols; i++) {<br />
address_line1 = HD44780_XY2Adrr(nbrows, nbcols, line, i);<br />
HD44780_WriteCommand(LCD_ADDRSET | address_line1);<br />
HD44780_WriteData(espace,0);<br />
}<br />
}<br />
</pre><br />
|}<br />
<br />
<br />
HD44780_WriteChar :<br />
<br />
Permet d'écrire un caractère sur l'écran. Chaque caractère écrit sur la seconde ligne est placé dans un tableau de caractère. <br />
<br />
Lorsqu'on arrive au bout d'une ligne : Si nous sommes à la première ligne (Ligne 0), on passe à la seconde (Ligne 1) et on se replace au début des colonnes. Si nous sommes à la seconde ligne, on efface les deux lignes et on copie la seconde ligne sur la première ligne de l'écran, et on se replace au début de la seconde. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" |Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void HD44780_WriteChar(char car, char line1[], int* ind_line1, int nbrows, int nbcols, int* row, int* col) {<br />
if ((*col) == nbcols) {<br />
(*col) = 0;<br />
if ((*row) <= 1) (*row)++;<br />
if ((*row) > 1) {<br />
(*row) = 1;<br />
HD44780_EraseLine(nbrows, nbcols,0);<br />
HD44780_EraseLine(nbrows, nbcols,1);<br />
HD44780_CopyLine1in0(line1, nbrows, nbcols,*ind_line1);<br />
}<br />
(*ind_line1) = 0;<br />
}<br />
<br />
int address = HD44780_XY2Adrr(nbrows, nbcols, *row, *col);<br />
HD44780_WriteCommand(LCD_ADDRSET | address);<br />
HD44780_WriteData(car,1);<br />
(*col)++;<br />
if ((*row) == 1) <br />
{<br />
line1[*ind_line1] = car;<br />
(*ind_line1)++;<br />
}<br />
}<br />
</pre><br />
|}VIDEO <br />
<br />
Super, ca fonctionne ! <br />
<br />
Désormais, nous voulons que notre écran affiche ce qu'il recoit via le bus SPI. <br />
<br />
=== Communication SPI ===<br />
Pour cela il nous faut initialiser le maitre (un arduino UNO) et l'esclave (notre carte LCD). <br />
<br />
Puis que le maitre transmette des données et que l'esclave les recoivent. <br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Maitre<br />
! scope="col" | Code Esclave<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS);<br />
DDRB &= ~(1 << SPI_MISO);<br />
SPCR |= (1 << MSTR);<br />
SPCR |= (1 << SPE) | (1<<SPR0) | (1<<SPR1);<br />
}<br />
<br />
void SPI_MasterTransmit(char cData)<br />
{<br />
SPDR = cData;<br />
while(!(SPSR & (1<<SPIF)));<br />
}<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void SPI_init()<br />
{<br />
DDRB |= (1 << SPI_MISO);<br />
DDRB &= ~((1 << SPI_MOSI) | (1 << SPI_SCK) | (1 << SPI_SS));<br />
SPCR |= (1 << SPE); <br />
}<br />
<br />
char SPI_SlaveReceive(void)<br />
{<br />
/* Attendre la fin de la réception */<br />
while (!(SPSR & (1 << SPIF)));<br />
char receivedData = SPDR;<br />
return receivedData;<br />
}<br />
<br />
</pre><br />
<br />
|}<br />
Faisons un petit test en envoyant des 'A' suivis de 'B' et enfin un 'X' pour terminer.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code Test du Maitre<br />
! scope="col" | Video<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
int main()<br />
{<br />
...<br />
...<br />
while (x<17)<br />
{<br />
SPI_MasterTransmit('A');<br />
_delay_ms(100);<br />
SPI_MasterTransmit('B');<br />
x++;<br />
PORTD ^= (1<<7);<br />
_delay_ms(100);<br />
}<br />
SPI_MasterTransmit('X');<br />
while(1)<br />
{<br />
}<br />
}<br />
<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}Notre test fonctionne mais cela n'a pas été sans peine. Nous avons rencontré énormément de problème sur la communication SPI. La communication était clairement douteuse et aléatoire. <br />
<br />
==== Problèmes rencontrés ====<br />
Plusieurs pistes ont été considérées pour comprendre le problème qu'on avait avec le SPI, était-ce l'arduino UNO? Notre connecteur? Le shield? Notre carte?<br />
Au départ, par soucis de praticité, nous voulions utiliser l'arduino UNO qui disposait de fonctionnalités de test simple avant de passer au shield, mais à chaque essai, le SPI ne fonctionait pas correctement bien qu'on pouvait observer à l'oscilloscope que le message était bien envoyé à notre carte.<br />
Finalement, nous sommes directement passé à la communication SPI avec notre shield, qui cette fois-ci, permettait d'avoir un résultat satisfaisant. Le résultat n'était pas parfait car on remarquait que la position des fils déterminait si la communication allait fonctionner, il fallait donc trouver la position qui permettait cette communication.<br />
Pour régler ce problème, nous avons déterminé la fréquence de travail du SPI utilisé par le shield et notre carte, pour vérifier qu'il n'y ait pas de problèmes de synchronisation ou que la fréquence utilisée soit bien adaptée. Pour ce faire nous avons observé à l'oscilloscope les différentes divisions de fréquences possibles en vérifiant en même temps que la communication SPI fonctionne bien. Les résultats sont surprenant, car peu importe la fréquence de travail, aucun problème n'a été détécté.<br />
<br />
= Références utiles =<br />
Lien du git :<br />
<br />
https://archives.plil.fr/mchauvel/PICO_Taha_NEHARI_Martin_CHAUVELIERE.git<br />
<br />
https://github.com/Matiasus/HD44780<br />
<br />
NHD-C12832A1Z-FSW-FBW-3V3-ND<br />
<br />
http://cdzillidan.free.fr/electronique-numerique/modules/afficheurs-lcd/hd44780/fonctionnement-interne.html<br />
<br />
https://michlstechblog.info/blog/raspberry-pi-connecting-a-hd44780-display-with-i2c-bus/<br />
<br />
ReX : Merci d'utiliser le squelette de page présenté en séance.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-1&diff=2789SE4Binome2023-12024-01-16T14:04:56Z<p>Tnehari : </p>
<hr />
<div>= Ordonnanceur =<br />
<br />
== Soudure et Test du SHIELD ==<br />
Au cours des 2 premières séances nous avons soudé et testé notre Shield<br />
[[Fichier:ShieldSoudé.jpg|thumb|center|300x300px|<div style="text-align:center;">Shield soudé et monté sur Arduino</div>]]<br />
<br />
Sur l'un des connecteurs, la led est abîmée dû à une soudure excessive. Sachant que les leds sont uniquement utilisées en tant qu'indicateurs pour savoir quelle carte fille à le contrôle et que nous n'en utiliserons pas plus de 3 pour tester nos programmes, cela ne vas pas avoir d'influence négative.<br />
Le potentiomètre permet de régler le niveau de luminosité de l'écran et le connecteur HE10 permettra de comuniquer avec l'écran.<br />
Les problèmes rencontrés sont les suivants : Au départ, la carte ne fonctionnait pas, le soucis étant le quartz mal soudé, c'est à l'aide d'un pistolet à air chaud que celui-ci à été ressoudé. Un autre problème était le reset de la carte fille qui ne fonctionnait pas non plus, une ressoudure classique a permis de le faire fonctionner.<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Code<br />
! scope="col"| Image<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#include <avr/io.h><br />
<br />
void init_led(){<br />
DDRD=0x92;<br />
DDRC=0x09;<br />
}<br />
<br />
int main(){<br />
init_led();<br />
while(1)<br />
{<br />
PORTD=0x92;<br />
PORTC=0x09;<br />
}<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
[[Fichier:ShieldLed.jpg|thumb|center|300x300px|<div style="text-align:center;">Test des Leds du Shield</div>]]<br />
|}<br />
Puis nous avons aussi soudé l'adaptateur HE10 pour l'utilisation de la matrice de leds[[Fichier:Adaptateur HE10.jpg|thumb|center|300x300px|<div style="text-align:center;">Adaptateur HE10 pour Matrice de leds</div>]]<br />
<br />
= Codage de l'Ordonnanceur =<br />
Nous commençons maintenant l'ordonnanceur, tout d'abord nous créeons la structure de nos Taches.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
struct TacheInfo{<br />
void (*depart)(void);<br />
uint16_t SPointeur;<br />
int etat;<br />
};<br />
</pre> <br />
|}<br />
Puis nous ajoutons les 2 premières taches demandées qui sont de faire clignoter 2 leds différentes à des timing différents.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheA(){<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
_delay_ms(300);<br />
}<br />
}<br />
<br />
void TacheB(){<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
_delay_ms(500);<br />
}<br />
}<br />
<br />
struct TacheInfo Taches[2]={<br />
{TacheA,0x0600,0},<br />
{TacheB,0x0700,0}<br />
};<br />
<br />
</pre> <br />
|}<br />
On s'occupe maintenant de l'ordonnanceur, ainsi que de l'ISR.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{ <br />
PORTD ^= 0x02;<br />
courant++;<br />
if (courant == NBR_TACHE) courant = 0;<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect,ISR_NAKED)<br />
{<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
SAVE_REGISTER();<br />
Taches[courant].SPointeur = SP;<br />
<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].SPointeur;<br />
RESTORE_REGISTER();<br />
asm volatile ( "reti" );<br />
}<br />
</pre><br />
|}<br />
Nous avons décider de faire clignoter une LED (PORTD ^= 0x02) à chaques utilisations de la fonction ordonnanceur() dans l'ISR.<br />
<br />
La variable courant indique la Tache qui est actuellement en cours.<br />
<br />
A chaque chaques changements de tache, l'ISR se déclenche enregistre la tache en cours (les registres ainsi que le Stack Pointer), appel l'ordonnanceur, puis change "charge" la tache suivante.<br />
<br />
On oublie pas maintenant de générer l'interruption toute les 20ms, pour cela on choisit un prescaler de 1024 et un nombre de ticks de 312.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define PRESCALER 1024<br />
#define NB_TICK 312<br />
#define CTC1 WGM12<br />
<br />
void init_timer(){<br />
TCCR1A = 0; // No output pin connected, no PWM mode enabled<br />
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match<br />
#if (PRESCALER==1024)<br />
TCCR1B |= (1<<CS12 | 1<<CS10);<br />
#endif<br />
OCR1A = NB_TICK;<br />
TCNT1 = 0;<br />
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt<br />
}<br />
</pre><br />
|}<br />
Ainsi que d'initialiser les Taches pour assurer le bon fonctionnement de notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void init_taches(int pid)<br />
{<br />
int save=SP;<br />
SP=Taches[pid].SPointeur;<br />
uint16_t adresse=(uint16_t)Taches[pid].depart;<br />
asm volatile ("push %0 \n\t" : : "r" (adresse & 0x00ff));<br />
asm volatile ("push %0 \n\t" : : "r" ((adresse & 0xff00) >> 8));<br />
SAVE_REGISTER();<br />
Taches[pid].SPointeur=SP;<br />
SP=save;<br />
}<br />
</pre><br />
|}<br />
On peut maintenant tester notre ordonnanceur.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Vidéo<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define NBR_TACHE 2<br />
int main(void){<br />
init_ports();<br />
init_timer();<br />
init_taches(1);<br />
sei();<br />
SP = Taches[courant].SPointeur;<br />
Taches[courant].depart();<br />
return 0;<br />
}<br />
</pre> <br />
| style="width:50%;" |<br />
<br />
|}<br />
Les 2 leds clignotent bien avec le bon timing, et la led témoin de l'ordonnanceur clignotent aussi, ce qui indique que l'ISR est bien actif.<br />
<br />
Nous pouvons donc maitenant passer à la gestion des "sleeps".<br />
<br />
En effet, l'utilisation de _delay_ms dans chaque tache n'est pas la manière la plus optimale de procéder. Et meme cela nous bloquera par la suite.<br />
<br />
Nous ajoute donc à la structure de nos Taches, une structure InfoEndormi, qui, comme son nom l'indique nous donne des informations si la tache est endormie. A savoir la raison mais aussi des donnees comme par exemple le temps que cette tache doit passer endormie.<br />
<br />
Puis afin de remplacer _delay_ms, nous créeons une fonction Attente qui endors une tache pour un temps donné.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
#define REVEILLE 0<br />
#define ENDORMI 1<br />
#define RAISON_DELAY 0<br />
<br />
struct InfoEndormi{<br />
int raison;<br />
uint16_t donnee;<br />
}sleep_t;<br />
<br />
<br />
struct TacheInfo{<br />
void (*depart)(void); <br />
uint16_t SPointeur;<br />
int etat;<br />
struct InfoEndormi endormi;<br />
};<br />
</pre> <br />
| style="width:50%;" |<pre><br />
void Attente(uint16_t temps_ms){<br />
cli();<br />
Taches[Tache_courante].etat = ENDORMI;<br />
Taches[Tache_courante].endormi.raison = RAISON_DELAY;<br />
Taches[Tache_courante].endormi.donnee = temps_ms;<br />
TCNT1 = 0;<br />
sei();<br />
}<br />
</pre><br />
<br />
|}<br />
Voila maitenant nos taches, il est important de créer une TacheZombie qui comme son nom l'indique est toujours révéillée.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void TacheZombie() //Tache toujours réveillé<br />
{<br />
while(1)<br />
{<br />
_delay_ms(1.5*PERIODE_INTERUPTION); //Delay légèrement supèrieur à la periode pour éviter tout soucis<br />
}<br />
}<br />
<br />
void TacheA()<br />
{<br />
while(1)<br />
{<br />
PORTC ^= 0x08;<br />
Attente(300);<br />
}<br />
}<br />
<br />
void TacheB()<br />
{<br />
while(1)<br />
{<br />
PORTD ^= 0x80;<br />
Attente(500);<br />
}<br />
}<br />
</pre><br />
|}<br />
Il est important maitenant de modifier notre ordonnanceur afin que celui-ci puisse recalculer le nouveau temps de sleep d'une tache et si ce temps devient inférieur ou ègale à 0 alors l'ordonnacnceur réveille la tache.<br />
{| class="wikitable" style="width:100%;"<br />
! scope="col" | Code<br />
|-<br />
| style="width:50%;" |<br />
<pre><br />
void ordonnanceur ()<br />
{<br />
PORTD ^= 0x02;<br />
for(int i = 0; i < NBR_TACHE; i++)<br />
{<br />
if(Taches[i].etat == ENDORMI && Taches[Tache_courante].endormi.raison == RAISON_DELAY)<br />
{<br />
uint16_t diff_temps = PERIODE_INTERUPTION;<br />
if(TCNT1 != 0)<br />
{<br />
//Calcul précis de la différence de temps (pas obligatoirement 20 ms)<br />
diff_temps = ((TCNT1*PERIODE_INTERUPTION*10)/OCR1A)/10;<br />
TCNT1 = 0;<br />
}<br />
Taches[i].endormi.donnee -= diff_temps;<br />
<br />
if(Taches[i].endormi.donnee <= 0)<br />
{<br />
Taches[i].etat = REVEILLE;<br />
}<br />
}<br />
}<br />
<br />
do<br />
{<br />
Tache_courante++;<br />
if (Tache_courante == NBR_TACHE) Tache_courante = 0;<br />
}<br />
while(Taches[Tache_courante].etat == ENDORMI);<br />
}<br />
<br />
</pre><br />
|}<br />
Maintenant que cela est fait, nous pouvons ajouter 2 nouvelles taches qui sont la lecture et l'ecriture sur le port série.<br />
<br />
= Carte FPGA =<br />
<br />
= Carte électronique numérique =<br />
Nous avons choisi la Carte Fille : Ecran LCD <br />
<br />
Pendant la 3ème séance nous avons finis le Schématic de la carte <br />
[[Fichier:SCH.png|centré|vignette|700x700px|<div style="text-align:center;">Schematic de la Carte Fille : Ecran LCD</div>]]<br />
Puis nous avons Routé la carte et envoyé à la Fabrication<br />
[[Fichier:PCB LCD.png|centré|vignette|550x550px|<div style="text-align:center;">Routage de la Carte Fille : Ecran LCD</div>]]<br />
<br />
{| class=wikitable style="width:100%;"<br />
! scope="col"| Carte non soudée<br />
! scope="col"| Carte soudé<br />
|-<br />
| style="width:50%;" |[[Fichier:Carte LCD non soudée.jpg|centré|vignette|300x300px|<div style="text-align:center;">Carte non soudée</div>]]<br />
| style="width:50%;" |[[Fichier:Carte LCD soudee.jpg|centré|vignette|400x400px|<div style="text-align:center;">Carte soudée</div>]]<br />
<br />
|}<br />
<br />
= Références utiles =<br />
Lien du git :<br />
<br />
https://archives.plil.fr/mchauvel/PICO_Taha_NEHARI_Martin_CHAUVELIERE.git<br />
<br />
https://github.com/Matiasus/HD44780<br />
<br />
NHD-C12832A1Z-FSW-FBW-3V3-ND<br />
<br />
http://cdzillidan.free.fr/electronique-numerique/modules/afficheurs-lcd/hd44780/fonctionnement-interne.html<br />
<br />
https://michlstechblog.info/blog/raspberry-pi-connecting-a-hd44780-display-with-i2c-bus/<br />
<br />
ReX : Merci d'utiliser le squelette de page présenté en séance.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=916SE3Binome2022-112023-05-28T20:26:07Z<p>Tnehari : Ajout Liens vidéo pour moteur et Leds</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
* Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:Switch.png|cadre]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]<br />
<br />
== En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET. ==<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Footprints et rootage ==<br />
[[Fichier:Rootage Debut.png|vignette]]<br />
07/04/23: Placement initial des composants sur la carte, Correction des dernières erreurs au niveau des pads des footprints que nous avons créé.<br />
<br />
02/05/23: Carte reçue.<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Soudure des composants ==<br />
ATMega8u2<br />
<br />
USB<br />
<br />
LEDs<br />
<br />
Résistances<br />
<br />
Capacités<br />
<br />
== Code voiture ==<br />
[[Fichier:TestLeds.png|vignette]]<br />
Une fois le test de clignotement des Leds effectué, on passe au code de contrôle de la voiture.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Moteur et Leds sur carte (Liens) ==<br />
[[Fichier:Moteur.mp4|gauche|vignette|2x2px|Mot]]<br />
<br />
<br />
[[Fichier:.Leds.mp4|centré|vignette|Leds]]</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:.Leds.mp4&diff=915Fichier:.Leds.mp42023-05-28T20:24:52Z<p>Tnehari : </p>
<hr />
<div>Leds</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Image_LEds.jpg&diff=914Fichier:Image LEds.jpg2023-05-28T20:24:33Z<p>Tnehari : </p>
<hr />
<div>Leds av ar</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Image_moteur.jpg&diff=913Fichier:Image moteur.jpg2023-05-28T20:12:45Z<p>Tnehari : </p>
<hr />
<div>Image moteur</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Moteur.mp4&diff=912Fichier:Moteur.mp42023-05-28T20:09:45Z<p>Tnehari : </p>
<hr />
<div>Propulsion</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=701SE3Binome2022-112023-05-16T08:58:20Z<p>Tnehari : Ajout des parties soudure et code, à compléter</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
* Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:Switch.png|cadre]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]<br />
<br />
== En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET. ==<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Footprints et rootage ==<br />
[[Fichier:Rootage Debut.png|vignette]]<br />
07/04/23: Placement initial des composants sur la carte, Correction des dernières erreurs au niveau des pads des footprints que nous avons créé.<br />
<br />
02/05/23: Carte reçue.<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Soudure des composants ==<br />
ATMega8u2<br />
<br />
USB<br />
<br />
LEDs<br />
<br />
Résistances<br />
<br />
Capacités<br />
<br />
== Code voiture ==<br />
[[Fichier:TestLeds.png|vignette]]<br />
Une fois le test de clignotement des Leds effectué, on passe au code de cntrôle de la voiture.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:TestLeds.png&diff=698Fichier:TestLeds.png2023-05-16T08:57:32Z<p>Tnehari : </p>
<hr />
<div>Clignotement des Leds</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3_PSE_Binome2022-10&diff=585SE3 PSE Binome2022-102023-04-12T14:19:49Z<p>Tnehari : Ajout vidéo</p>
<hr />
<div>Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git<br />
<br />
Voir vidéo LED clignotante.<br />
<br />
[[Fichier:SCHEMATIC.png|vignette|Schematic de notre carte|gauche]][[Fichier:VIEW 3D.png|vignette|gauche|Vue 3D de la carte]][[Fichier:PCB.png|vignette|gauche|Rootage de la carte]]<br />
[[Fichier:Clignotement des LEDs.png|gauche|vignette|Fonction pour faire clignoter les LEDs]]<gallery><br />
Fichier:Led clignotante.mp4|LED clignotante<br />
</gallery></div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Carte_PSE.jpg&diff=584Fichier:Carte PSE.jpg2023-04-12T14:17:20Z<p>Tnehari : </p>
<hr />
<div>LED</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Led_clignotante.mp4&diff=583Fichier:Led clignotante.mp42023-04-12T14:08:22Z<p>Tnehari : </p>
<hr />
<div>Une seule LED clignote, l'autre étant soudée à l'envers.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=542SE3Binome2022-112023-04-11T18:53:41Z<p>Tnehari : Ajout du lien du git dans lequel se trouve la carte quasiment complétée (il manque UNE connexion au moteur).</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
* Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:Switch.png|cadre]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]<br />
<br />
== En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET. ==<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Footprints et rootage ==<br />
[[Fichier:Rootage Debut.png|vignette]]<br />
07/04/23: Placement initial des composants sur la carte, Correction des dernières erreurs au niveau des pads des footprints que nous avons créé.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=430SE3Binome2022-112023-04-07T13:41:30Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:Switch.png|cadre]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]<br />
<br />
== En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET. ==<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Footprints et rootage ==<br />
[[Fichier:Rootage Debut.png|vignette]]<br />
07/04/23: Placement initial des composants sur la carte, Correction des dernières erreurs au niveau des pads des footprints que nous avons créé.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Rootage_Debut.png&diff=429Fichier:Rootage Debut.png2023-04-07T13:39:08Z<p>Tnehari : </p>
<hr />
<div>Placement initial des composants (sujet à changement évidemment)</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3_PSE_Binome2022-10&diff=387SE3 PSE Binome2022-102023-04-06T10:21:16Z<p>Tnehari : Page créée avec « Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git vignettevignette]] »</p>
<hr />
<div>Lien du git : https://archives.plil.fr/mchauvel/PSE_tnehari_mchauvel.git<br />
[[Fichier:SCHEMATIC.png|vignette|[[Fichier:VIEW 3D.png|vignette]][[Fichier:PCB.png|vignette]]]]</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PCB.png&diff=386Fichier:PCB.png2023-04-06T10:21:05Z<p>Tnehari : </p>
<hr />
<div>PCB</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:VIEW_3D.png&diff=385Fichier:VIEW 3D.png2023-04-06T10:20:32Z<p>Tnehari : </p>
<hr />
<div>VIEW3D</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:SCHEMATIC.png&diff=384Fichier:SCHEMATIC.png2023-04-06T10:19:35Z<p>Tnehari : </p>
<hr />
<div>SCHEMATIC</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=PSE_SE3_2022/2023&diff=380PSE SE3 2022/20232023-04-06T10:08:10Z<p>Tnehari : </p>
<hr />
<div>= Objectif =<br />
<br />
Pour l'année académique 2022/2023 il demandé de motoriser un modèle réduit de voiture au 1:87ème ou au 1:43ème avec contrôle par microcontrôleur.<br />
<br />
<gallery><br />
File:modele-voiture-1-87.jpg|Modéle réduit au 1:87<br />
File:modele-voiture-1-43.jpg|Modéle réduit au 1:43<br />
</gallery><br />
<br />
Votre objectif est de concevoir votre propre modèle à l'aide des éléments présentés dans cette page. Vous ne devez pas forcément fusionner l'ensemble<br />
des possibilités, d'ailleurs certaines sont incompatibles entre elles. Partir sur quelque chose de simple n'est pas infamant du moment qu'il est proprement exécuté et qu'il débouche sur un prototype fonctionnel.<br />
<br />
Certes si vous nous sortez une voiture au 1:87ème totalement fonctionnelle avec propulsion, roues avant directionnelles, chargeur de batterie intégré et contrôle radio nous serons enchantés et nous aurons assez peu de difficulté à vous noter. Maintenant si vous partez sur un simple chassis au 1:43ème avec propulsion utilisant de simples poulies, roue folle permettant des reculs avec virage (axe de roue non fixe) et contrôle par programmation, vous aurez rempli le contrat.<br />
<br />
= Mécanique =<br />
<br />
La partie mécanique n'est pas évaluée dans ce projet car elle est hors-sujet pour la filière. Par contre, une démonstration avec une voiture mobile est un excellent moyen de prouver que votre projet fonctionne.<br />
<br />
[[file:2022-chassis.png|thumb|400px|right|Image du chassis]]<br />
<br />
Pour vous aider nous avons modélisé un chassis avec roues avant directionnelles.<br />
<br />
<gallery><br />
file:2022-chassis-dessus.pdf|Chassis vu de dessus<br />
file:2022-chassis-dessous.pdf|Chassis vu de dessous<br />
file:2022-chassis-cote-1.pdf|Chassis vu de coté<br />
file:2022-chassis-cote-2.pdf|Chassis vu d'un autre coté<br />
</gallery><br />
<br />
Le fichier <code>freeCAD</code> du chassis [[file:chassis-2022.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
Seconde version de chassis.<br />
<br />
[[file:2022-chassis2.png|thumb|400px|right|Image du chassis]]<br />
<br />
Pour vous aider nous avons modélisé un chassis avec roues avant directionnelles.<br />
<br />
<gallery><br />
file:2022-chassis2-dessus.pdf|Chassis vu de dessus<br />
file:2022-chassis2-dessous.pdf|Chassis vu de dessous<br />
file:2022-chassis2-cote-1.pdf|Chassis vu de coté<br />
file:2022-chassis2-cote-2.pdf|Chassis vu d'un autre coté<br />
</gallery><br />
<br />
Le fichier <code>freeCAD</code> du chassis [[file:chassis2-2022.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
[[file:2022-roue_folle.png|thumb|200px|right|Image de la roue]]<br />
<br />
Vous avez aussi un modèle de principe pour une roue folle avec recul en virant.<br />
<br />
<gallery><br />
file:2022-roue-folle.pdf|Roue en 3D<br />
</gallery><br />
<br />
Le fichier <code>freeCAD</code> de la roue [[file:roue-folle-2022.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
Au niveau accessoires vous pouvez, ou pourrez, disposer des éléments suivants :<br />
* engrenages métal pour axe 0.7mm, disponibles et semblent s'adapter aux micro-moteurs simples ;<br />
* vis sans fin métal pour axe de 1mm (diamètre extérieur 3,8mm), disponibles, prévues pour l'axe des voitures 1:87 ;<br />
* vis sans fil plastique pour axe 2mm, disponibles mais s'adaptent mal aux axes des voitures 1:43 ;<br />
* vis sans fil plastique pour axe <2mm, disponibles, prévues pour l'axe des voitures 1:43 ;<br />
* engrenages plastiques pour axe de 3mm, disponibles, pour les moteurs continus.<br />
<br />
= Moteurs =<br />
<br />
La commande des moteurs n'est pas, elle, optionnelle.<br />
<br />
Plusieurs types de moteurs sont disponibles.<br />
<br />
<gallery><br />
File:micro-moteur-pas-a-pas-simple.jpg|Micro-moteur pas à pas propulsion<br />
File:micro-moteur-pas-a-pas-simple-dims.jpg|Dimensions du micro-moteur propulsion<br />
File:micro-glissiere-pas-a-pas.jpg|Micro-moteur glissière pas à pas<br />
File:micro-glissiere-pas-a-pas-dimensions.jpg|Dimensions du micro-moteur glissière<br />
File:micro-glissiere-pas-a-pas-connecteurs.jpg|Connecteurs du micro-moteur glissière<br />
File:mini-motoreducteur.jpg|Mini-moteur continu avec réducteur<br />
File:pilote-motoreducteur.jpg|Pilote pour le mini-moteur continu (DRV8210DRLR)<br />
</gallery><br />
<br />
[[file:2022-banc-essai-micro-moteurs.jpg|thumb|250px|right|Banc d'essai des micro-moteurs]]<br />
<br />
Ressources pour les moteurs :<br />
* les micro-moteurs peuvent éventuellement fonctionner sans pilote (alimentation directe par le microcontrôleur), il reste à vérifier que le couple obtenu suffit et que l'utilisation de plusieurs périphériques n'effondre pas le microcontrôleur ;<br />
* empreintes approximatives pour les microcontrôleurs (à peaufiner) : [[file:KiCAD-lib-micro-motors.tar]] ;<br />
* premier jet du PCB de coté pour le micro-moteur glissière : [[file:KiCAD-slider-side-2022.tar]] ;<br />
* programme C pour les micro-moteurs pas à pas sans pilote (vidéo de démonstration ci-dessous) : [[Média:Programme_moteur_pap.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
[[file:2022-demo-micro-moteur.mp4|500px|left|Vidéo pour le micro-moteur]]<br />
[[file:2022-demo-micro-slider.mp4|500px|right|Vidéo pour le micro-moteur glissière]]<br />
<br />
<div style="clear: both;" /><br />
<br />
= Cartes électroniques =<br />
<br />
Vous devez concevoir une carte électronique pour contrôler la voiture. La conception doit se faire en utilisant le logiciel KiCAD.<br />
<br />
Il est recommandé de reporter au maximum les fonctions mécaniques sur la carte. Le chassis peut ainsi être entièrement constitué de PCB, y compris les pièces mobiles.<br />
<br />
Nous vous donnons deux exemples de schémas électroniques.<br />
<br />
== Exemple de carte pour la voiture au 1:87 ==<br />
<br />
Le schéma électronique de la carte :<br />
[[file:2022-schema-voiture-rex.pdf|thumb|400px|center|Schéma pour une voiture 1:87]]<br />
Dans le schéma vous pouvez trouver les fonctionnalités suivantes :<br />
* une alimentation avec un régulateur pour passer du 5V USB à une tension de 3.3V mais aussi avec un dispositif pour sélectionner une alimentation par USB ou par batterie ;<br />
* le microcontrôleur avec son horloge mais aussi son connecteur de programmation ISP et le connecteur USB ;<br />
* un dispositif de recharge de la batterie LiPo avec une entrée pour tester la tension de la batterie (sur une entrée numérique donc avec peu de sensibilité) ;<br />
* deux moteurs pas à pas et un système d'éclairage ;<br />
* enfin un module de communication radio.<br />
<br />
Après le routage les cartes suivantes sont obtenues.<br />
[[file:2022-PCB-voiture-rex.pdf|thumb|400px|center|Cartes pour une voiture 1:87]]<br />
<br />
Un total de 8 cartes sont prévues :<br />
* principalement la carte chassis sur laquelle sont implantés les puces microcontrôleur, charge de LiPo et communication radio ;<br />
* le moteur-glissière nécessite une micro-carte de côté pour récupérer les phases ; <br />
* tous les composants ne tiennent pas sur le chassis 50x20mm, une carte fille est donc prévue pour porter l'éclairage, l'antenne radio et même des pistes supplémentaires ;<br />
* 3 petites cartes sont dédiées pour recevoir les roues : deux pour les roues directionnelles et une pour le train arrière, sur ces cartes doivent êtres soudés des morceaux de tube de cuivre recevant les axes ;<br />
* toujours sur le principe que la carte principale ne permet pas de recevoir tous les éléments, une carte fille permet de connecter l'ISP et une autre l'USB.<br />
<br />
Les cartes ont été commandées. En aucun cas il est prévu que ces cartes fonctionnent dans leur version initiale. C'est d'ailleurs la démarche "bureau d'études" que nous souhaitons que vous assimiliez. Ces cartes vont permettre d'avancer dans le projet pour éventuellement aboutir sur une seconde version des cartes. Ci-dessous sont listés les points que les premières cartes vont permettre d'éclaircir.<br />
* Le microcontrôleur devrait fonctionner mais le principe des cartes filles pour la programmation ISP et DFU/USB est à valider.<br />
* Il y a peu de chances pour que les empreintes pour les micro-moteurs pas à pas soient exactes mais ce devrait être une bonne base pour aboutir à une seconde version fonctionnelle.<br />
* L'aspect mécanique est aussi à tester et à corriger : les roues directionnelles fonctionnent-elles ? quels problèmes sont rencontrés pour la transmission de la propulsion via l'engrenage et la vis sans fin.<br />
* Le dispositif d'alimentation par USB ou par batterie est-il fonctionnel ? Le test de tension de la batterie donne-t-il quelque chose ? La recharge de la batterie par le MAX1811 marche-t-elle ?<br />
* La transmission radio est-elle fonctionnelle ? En particulier les libertés prises au niveau de l'antenne sur PCB dégradent-elles beaucoup cette transmission ?<br />
<br />
Les sources pour le logiciel KiCAD version 5.1 : [[Média:2022-voiture-kicad-rex.tgz|Fichiers KiCAD pour la voiture 1:87]].<br />
<br />
Uniquement les sources pour les empreintes des moteurs pas à pas (modifiées) : [[Média:Rex-motors.zip|Empreintes KiCAD pour les moteurs pas à pas]].<br />
<br />
== Exemple de carte pour la voiture au 1:43 ==<br />
<br />
[[file:2022-schema-voiture-boe.pdf|thumb|400px|right|Schéma pour une voiture 1:43]]<br />
<br />
<div style="clear: both;" /><br />
<br />
== Le microcontrôleur ==<br />
<br />
Vous utiliserez un microcontrôleur ATMega16u2 comme coeur de votre circuit imprimé. Prenez exemple sur la partie microcontrôleur des schémas fournis.<br />
<br />
La programmation du microcontrôleur se fera par DFU USB.<br />
<br />
== Energie ==<br />
<br />
La carte électronique de votre voiture est alimentée par une batterie LiPo. La batterie peut être chargée en utilisant une puce MAX1811. Voir les schémas fournis pour avoir une idée de commencer utiliser une puce MAX1811.<br />
<br />
<gallery><br />
File:puce_max1811.jpg|Puce de contrôle de charge<br />
File:batteries_LiPo.jpg|Batteries 100mAh et 300mAh, connecteur molex mâle<br />
File:batterie_LiPo_FQ777.jpg|Batterie 100mAh 15x20x5mm<br />
</gallery><br />
<br />
Les connecteurs adaptés aux batteries FQ777 ont aussi été commandés (micro JST 2 broches 1.25mm).<br />
<br />
== Eclairage ==<br />
<br />
Vous pouvez vous lâcher sur les LED pour simuler les dispositifs lumineux de votre voiture. Attention cependant votre micro-contrôleur n'a qu'un nombre limité de sorties.<br />
<br />
== Contrôle de la voiture ==<br />
<br />
=== Contrôle par programmation ===<br />
<br />
Il est recommandé d'utiliser la fonctionnalité USB pour pouvoir programmer le comportement de la voiture. A défaut une programmation par port série est acceptable. Le programme PC permettant d'envoyer la suite d'instructions que la voiture doit réaliser est aussi à votre charge.<br />
<br />
=== Radio-contrôle ===<br />
<br />
Vous avez deux possibilités pour la commande à distance de votre voiture, soit une communication radio classique, soit une communication BlueTooth.<br />
<br />
<gallery><br />
File:module_nrf24L01.jpg|Module de communication 2,4Ghz<br />
File:module_BLE.jpg|Module Bluetooth Low Energy<br />
</gallery><br />
<br />
Les modules RF 2,4Ghz utilisent une puce NRF24L01, ces modules étant un peu encombrants, quelques puces ont été commandées pour intégration directe sur le PCB (disponibilité fin février). Vous avez un exemple d'utilisation sur le premier schéma de carte fourni plus haut. Les puces NRF24L01 doivent être alimentées en 3,3V mais ses E/S sont compatibles 5V. Il n'est donc pas obligatoire de passer l'ATMega16u2 en 3,3V.<br />
<br />
= Réalisation des groupes =<br />
<br />
{| class="wikitable"<br />
! Numéro !! Elèves !! Page <br />
|-<br />
| Trinôme 1<br />
| Sarra BEZZINE & Heriniaina ANDRIANIRINTSOA & Imen MLIKA<br />
| [[SE3Binome2022-1|Trinôme 1 2022/2023]]<br />
|-<br />
| Trinôme 2<br />
| Younes BENMBAREK & Camille CARIAT & Abdel ZONGO<br />
| [[SE3Trinome2022-2|Trinôme 2 2022/2023]]<br />
|-<br />
| Binôme 3<br />
| Simon CRUCHET & Amaury BECQUET<br />
| [[SE3Binome2022-3|Binôme 3 2022/2023]]<br />
|-<br />
| Binôme 4<br />
| Romain DUHR & Louis DERYCKERE<br />
| [[SE3Binome2022-4|Binôme 4 2022/2023]]<br />
|-<br />
| Binôme 5<br />
| Youness EL QASTALANI & Chaymae Rhanim<br />
| [[SE3Binome2022-5|Binôme 5 2022/2023]]<br />
|-<br />
| Trinôme 6<br />
| Stephane KADER ISSACK & Marion NORMAND & Amaury DA PONTE<br />
| [[SE3Trinome2022-6|Trinôme 6 2022/2023]]<br />
|-<br />
| Binôme 7<br />
| Alexandre BRASSEUR & Louis WIJSMAN<br />
| [[SE3Binome2022-7|Binôme 7 2022/2023]]<br />
|-<br />
| Trinôme 8<br />
| Némo CAZIN & Antoine CEGARRA & Adrien PALIFERRO<br />
| [[SE3Trinome2022-8|Trinôme 8 2022/2023]]<br />
|-<br />
| Binôme 9<br />
| Thomas NAVE & Thibault DUYCK<br />
| [[SE3Binome2022-9|Binôme 9 2022/2023]]<br />
|-<br />
| Monôme 10<br />
| Adrien GONTIER<br />
| [[SE3Monome2022-10|Monôme 10 2022/2023]]<br />
|-<br />
| Binôme 11<br />
| Taha NEHARI & Martin CHAUVELIERE <br />
| [[SE3Binome2022-11|Binôme 11 2022/2023]]<br />
|-<br />
|}<br />
Absents :<br />
* Imen MLIKA<br />
* Ababacar sadikh NDOYE<br />
<br />
= Réalisation "programmateur AVR" =<br />
<br />
Utilisez ces pages pour :<br />
* indiquer l'URL HTTPS de votre archive GIT sur laquelle trouver le projet KiCAD et les programmes C (LUFA et libusb) ;<br />
* un schéma 3D de votre PCB ;<br />
* une photo de la carte soudée ;<br />
* une très courte vidéo de la carte avec les LED clignotantes ;<br />
* une copie écran montrant l'affichage de la communication entre votre programme libusb, votre carte et le microcontrôleur AVR.<br />
<br />
{| class="wikitable"<br />
! Numéro !! Elèves !! Page <br />
|-<br />
| Binôme 1<br />
| Simon CRUCHET & Amaury BECQUET <br />
| [[SE3_PSE_Binome2022-1|Binôme 1 2022/2023]]<br />
|-<br />
| Binôme 2<br />
| Romain DUHR & Louis DERYCKÈRE<br />
| [[SE3_PSE_Binome2022-2|Binôme 2 2022/2023]]<br />
|-<br />
| Binôme 3<br />
| Chaymae RHANIM & Heriniaina ANDRIANIRINTSOA<br />
| [[SE3_PSE_Binome2022-3|Binôme 3 2022/2023]]<br />
|-<br />
| Binôme 4<br />
| Stéphane Kader Issack & Marion Normand<br />
| [[SE3_PSE_Binome2022-4|Binôme 4 2022/2023]]<br />
|-<br />
| Binôme 5<br />
| Thomas NAVE & Thibault DUYCK<br />
| [[SE3_PSE_Binome2022-5|Binôme 5 2022/2023]]<br />
|-<br />
| Binôme 6<br />
| Amaury Da Ponte<br />
| [[SE3_PSE_Binome2022-6|Binôme 6 2022/2023]]<br />
|-<br />
| Binôme 7<br />
| Sarra Bezzine & Imen MLika<br />
| [[SE3_PSE_Binome2022-7|Binôme 7 2022/2023]]<br />
|-<br />
| Binôme 8<br />
| Némo CAZIN & Antoine CEGARRA<br />
| [[SE3_PSE_Binome2022-8|Binôme 8 2022/2023]]<br />
|-<br />
| Binôme 9<br />
| Alexandre BRASSEUR & Louis WIJSMAN<br />
| [[SE3_PSE_Binome2022-9|Binôme 9 2022/2023]]<br />
|-<br />
| Binôme 10<br />
| Taha NEHARI & Martin CHAUVELIERE<br />
| [[SE3_PSE_Binnome2022-10|Binôme 10 2022/2023]]<br />
|-<br />
| Binôme 11<br />
| Prénom Nom & Prénom Nom <br />
| [[SE3_PSE_Binome2022-11|Binôme 11 2022/2023]]<br />
|-<br />
|}</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=284SE3Binome2022-112023-03-14T14:39:07Z<p>Tnehari : /* Switch */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:Switch.png|cadre]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Switch.png&diff=281Fichier:Switch.png2023-03-14T14:37:35Z<p>Tnehari : </p>
<hr />
<div>Switch</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=280SE3Binome2022-112023-03-14T14:37:15Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB. Nous avons aussi ajouté un bouton au port RESET.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=277SE3Binome2022-112023-03-14T14:36:22Z<p>Tnehari : /* LEDs */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]En plus de cela nous avons adapter les labels en enlevant ceux qui n'étaient pas nécessaires et en modifiant ceux associés à un sous PCB.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=274SE3Binome2022-112023-03-14T14:34:33Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=273SE3Binome2022-112023-03-14T14:34:03Z<p>Tnehari : /* LEDs */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
[[Fichier:ComposantBM71.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.<br />
<br />
<br />
<br />
[[Fichier:LEDs.png|gauche|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Fichier:LEDs Controleur.png|centré|cadre]]</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=270SE3Binome2022-112023-03-14T14:30:57Z<p>Tnehari : /* LEDs */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
[[Fichier:LEDs Controleur.png|centré|vignette]]<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
Nous avons aussi connecté ces Leds au microcontrôleur.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=269SE3Binome2022-112023-03-14T14:30:14Z<p>Tnehari : /* LEDs */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
[[Fichier:LEDs.png|vignette]]<br />
Nous avons aussi connecté ces Leds au microcontrôleur.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LEDs_Controleur.png&diff=268Fichier:LEDs Controleur.png2023-03-14T14:29:16Z<p>Tnehari : </p>
<hr />
<div>LEDS CONTROLEUR</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=267SE3Binome2022-112023-03-14T14:26:51Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
[[Fichier:LEDs.png|vignette]]<br />
Nous avons aussi connecté ces Leds a</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=265SE3Binome2022-112023-03-14T14:26:02Z<p>Tnehari : /* LEDs */</p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
== LEDs ==<br />
Comme vu précedemment, nous avons fait le choix d'utiliser huit Leds, deux pour la marche avant, deux pour la marche arrière, deux pour le clignotant gauche et deux pour le clignotant droit.<br />
[[Fichier:LEDs.png|vignette]]<br />
Nous avons aussi connecté ces Leds a</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LEDs.png&diff=264Fichier:LEDs.png2023-03-14T14:21:19Z<p>Tnehari : </p>
<hr />
<div>LEDs</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=263SE3Binome2022-112023-03-14T14:20:10Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).<br />
<br />
== '''LEDs''' ==</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=242SE3Binome2022-112023-02-28T14:16:13Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne ([https://fr.farnell.com/pulse-electronics/ant3216ll00r2400a/antenne-helix-chip-ceram-433mhz/dp/4125786?st=ANT3216LL00R2400A ANT3216LL00R2400A]) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=241SE3Binome2022-112023-02-28T14:15:16Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
* Modèle réduit au 1.43<br />
* Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
** Joystick directionnel<br />
** Boutons pour les clignotants<br />
** Bonus : klaxon<br />
* Module Bluetooth Low Energy<br />
* Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
* Moteur glissière pas à pas (Direction)<br />
* 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
* 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
* 4 LEDs JAUNES pour les clignotants<br />
<br />
== '''Module Bluetooth Low Energy''' ==<br />
Après étude de la [https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/Bluetooth-Low-Energy-BLE-Module-DS60001372K.pdf datasheet] (page 15 figure 2-5) nous avons pu recréer le composant BM71BLE01FC2-0B04AA sur kicad. Nous nous sommes aussi rendus compte que l'antenne (ANT3216LL00R2400A) bluetooth était externe au module. Nous attendons alors la livraison.<br />
[[Fichier:ComposantBM71.png|vignette]]<br />
<br />
<br />
Le module sera alors ajouté au fichier kicad déja existant modifié (en fonction de ce que l'on compte utiliser).</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:ComposantBM71.png&diff=240Fichier:ComposantBM71.png2023-02-28T14:13:41Z<p>Tnehari : </p>
<hr />
<div>Le composant BM71BLE01FC2 sans l'antenne externe.</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=162SE3Binome2022-112023-02-14T14:23:24Z<p>Tnehari : </p>
<hr />
<div>== '''<big>Caractéristiques de notre système:</big>''' ==<br />
<br />
<br />
- Modèle réduit au 1.43<br />
<br />
- Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<blockquote>° Joystick directionnel<br />
<br />
° Boutons pour les clignotants<br />
<br />
° Bonus : klaxon</blockquote>- Module Bluetooth Low Energy<br />
<br />
- Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
<br />
- Moteur glissière pas à pas (Direction)<br />
<br />
- 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
<br />
- 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
<br />
- 4 LEDs JAUNES pour les clignotants</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=161SE3Binome2022-112023-02-14T14:23:04Z<p>Tnehari : </p>
<hr />
<div>== '''<u><big>Caractéristiques de notre système:</big></u>''' ==<br />
<br />
<br />
- Modèle réduit au 1.43<br />
<br />
- Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<blockquote>° Joystick directionnel<br />
<br />
° Boutons pour les clignotants<br />
<br />
° Bonus : klaxon</blockquote>- Module Bluetooth Low Energy<br />
<br />
- Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
<br />
- Moteur glissière pas à pas (Direction)<br />
<br />
- 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
<br />
- 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
<br />
- 4 LEDs JAUNES pour les clignotants</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2022-11&diff=160SE3Binome2022-112023-02-14T14:21:49Z<p>Tnehari : Page créée avec « Caractéristiques de notre système: - Modèle réduit au 1.43 - Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel: ° Joystick directionnel ° Boutons pour les clignotants ° Bonus : klaxon - Module Bluetooth Low Energy - Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion) - Moteur glissière pas à pas (Direction) - 2 LEDs avant BLANCHES lorsque le véhicule avance - 2 LEDs arrière ROUGES lorsque le véhicule... »</p>
<hr />
<div>Caractéristiques de notre système:<br />
<br />
<br />
- Modèle réduit au 1.43<br />
<br />
- Commande Bluetooth via application téléphone (MIT App Inventor) en temps réel:<br />
<br />
° Joystick directionnel<br />
<br />
° Boutons pour les clignotants<br />
<br />
° Bonus : klaxon<br />
<br />
- Module Bluetooth Low Energy<br />
<br />
- Moteur CC avec réductuer + Pilote (DRV8210DRLR) (Propulsion)<br />
<br />
- Moteur glissière pas à pas (Direction)<br />
<br />
- 2 LEDs avant BLANCHES lorsque le véhicule avance<br />
<br />
- 2 LEDs arrière ROUGES lorsque le véhicule recule<br />
<br />
- 4 LEDs JAUNES pour les clignotants</div>Tneharihttps://projets-se.plil.fr/mediawiki/index.php?title=PSE_SE3_2022/2023&diff=146PSE SE3 2022/20232023-02-14T14:06:34Z<p>Tnehari : /* Réalisation des groupes */</p>
<hr />
<div>= Objectif =<br />
<br />
Pour l'année académique 2022/2023 il demandé de motoriser un modèle réduit de voiture au 1:87ème ou au 1:43ème avec contrôle par microcontrôleur.<br />
<br />
<gallery><br />
File:modele-voiture-1-87.jpg|Modéle réduit au 1:87<br />
File:modele-voiture-1-43.jpg|Modéle réduit au 1:43<br />
</gallery><br />
<br />
Votre objectif est de concevoir votre propre modèle à l'aide des éléments présentés dans cette page. Vous ne devez pas forcément fusionner l'ensemble<br />
des possibilités, d'ailleurs certaines sont incompatibles entre elles. Partir sur quelque chose de simple n'est pas infamant du moment qu'il est proprement exécuté et qu'il débouche sur un prototype fonctionnel.<br />
<br />
Certes si vous nous sortez une voiture au 1:87ème totalement fonctionnelle avec propulsion, roues avant directionnelles, chargeur de batterie intégré et contrôle radio nous serons enchantés et nous aurons assez peu de difficulté à vous noter. Maintenant si vous partez sur un simple chassis au 1:43ème avec propulsion utilisant de simples poulies, roue folle permettant des reculs avec virage (axe de roue non fixe) et contrôle par programmation, vous aurez rempli le contrat.<br />
<br />
= Mécanique =<br />
<br />
La partie mécanique n'est pas évaluée dans ce projet car elle est hors-sujet pour la filière. Par contre, une démonstration avec une voiture mobile est un excellent moyen de prouver que votre projet fonctionne.<br />
<br />
[[file:2022-chassis.png|thumb|400px|right|Image du chassis]]<br />
<br />
Pour vous aider nous avons modélisé un chassis avec roues avant directionnelles.<br />
<br />
<gallery><br />
file:2022-chassis-dessus.pdf|Chassis vu de dessus<br />
file:2022-chassis-dessous.pdf|Chassis vu de dessous<br />
file:2022-chassis-cote-1.pdf|Chassis vu de coté<br />
file:2022-chassis-cote-2.pdf|Chassis vu d'un autre coté<br />
</gallery><br />
<br />
Le fichier <code>freeCAD</code> du chassis [[file:chassis-2022.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
[[file:2022-roue_folle.png|thumb|200px|right|Image de la roue]]<br />
<br />
Vous avez aussi un modèle de principe pour une roue folle avec recul en virant.<br />
<br />
<gallery><br />
file:2022-roue-folle.pdf|Roue en 3D<br />
</gallery><br />
<br />
Le fichier <code>freeCAD</code> de la roue [[file:roue-folle-2022.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
Au niveau accessoires vous pouvez, ou pourrez, disposer des éléments suivants :<br />
* engrenages métal pour axe 0.7mm, disponibles et semblent s'adapter aux micro-moteurs simples ;<br />
* vis sans fil plastique pour axe 2mm, disponibles mais s'adaptent mal aux axes des voitures 1:43 ;<br />
* vis sans fin 3,8mm pour axe de 1mm, "en cours de livraison", prévues pour l'axe des voitures 1:87 ;<br />
* divers engrenages plastiques pour les voitures 1:43, arrivés en france ;<br />
* engrenages plastique pour axe de 1mm (voitures 1:43), arrivés en france.<br />
<br />
= Moteurs =<br />
<br />
La commande des moteurs n'est pas, elle, optionnelle.<br />
<br />
Plusieurs types de moteurs sont disponibles.<br />
<br />
<gallery><br />
File:micro-moteur-pas-a-pas-simple.jpg|Micro-moteur pas à pas propulsion<br />
File:micro-moteur-pas-a-pas-simple-dims.jpg|Dimensions du micro-moteur propulsion<br />
File:micro-glissiere-pas-a-pas.jpg|Micro-moteur glissière pas à pas<br />
File:micro-glissiere-pas-a-pas-dimensions.jpg|Dimensions du micro-moteur glissière<br />
File:micro-glissiere-pas-a-pas-connecteurs.jpg|Connecteurs du micro-moteur glissière<br />
File:mini-motoreducteur.jpg|Mini-moteur continu avec réducteur<br />
File:pilote-motoreducteur.jpg|Pilote pour le mini-moteur continu (DRV8210DRLR)<br />
</gallery><br />
<br />
[[file:2022-banc-essai-micro-moteurs.jpg|thumb|250px|right|Banc d'essai des micro-moteurs]]<br />
<br />
Ressources pour les moteurs :<br />
* les micro-moteurs peuvent éventuellement fonctionner sans pilote (alimentation directe par le microcontrôleur), il reste à vérifier que le couple obtenu suffit et que l'utilisation de plusieurs périphériques n'effondre pas le microcontrôleur ;<br />
* empreintes approximatives pour les microcontrôleurs (à peaufiner) : [[file:KiCAD-lib-micro-motors.tar]] ;<br />
* premier jet du PCB de coté pour le micro-moteur glissière : [[file:KiCAD-slider-side-2022.tar]] ;<br />
* programme C pour les micro-moteurs pas à pas sans pilote (vidéo de démonstration ci-dessous) : [[Média:Programme_moteur_pap.tar]].<br />
<br />
<div style="clear: both;" /><br />
<br />
[[file:2022-demo-micro-moteur.mp4|500px|left|Vidéo pour le micro-moteur]]<br />
[[file:2022-demo-micro-slider.mp4|500px|right|Vidéo pour le micro-moteur glissière]]<br />
<br />
<div style="clear: both;" /><br />
<br />
= Carte électronique =<br />
<br />
Vous devez concevoir une carte électronique pour contrôler la voiture. La conception doit se faire en utilisant le logiciel KiCAD.<br />
<br />
Il est recommandé de reporter au maximum les fonctions mécaniques sur la carte. Le chassis peut ainsi être entièrement constitué de PCB, y compris les pièces mobiles.<br />
<br />
Nous vous donnons deux exemples de schémas électroniques :<br />
<br />
[[file:2022-schema-voiture-rex.pdf|thumb|400px|left|Schéma pour une voiture 1:87]]<br />
<br />
[[file:2022-schema-voiture-boe.pdf|thumb|400px|right|Schéma pour une voiture 1:43]]<br />
<br />
<div style="clear: both;" /><br />
<br />
== Le microcontrôleur ==<br />
<br />
Vous utiliserez un microcontrôleur ATMega16u2 comme coeur de votre circuit imprimé. Prenez exemple sur la partie microcontrôleur des schémas fournis.<br />
<br />
La programmation du microcontrôleur se fera par DFU USB.<br />
<br />
== Energie ==<br />
<br />
La carte électronique de votre voiture est alimentée par une batterie LiPo. La batterie peut être chargée en utilisant une puce MAX1811. Voir les schémas fournis pour avoir une idée de commencer utiliser une puce MAX1811.<br />
<br />
<gallery><br />
File:puce_max1811.jpg|Puce de contrôle de charge<br />
File:batteries_LiPo.jpg|Batteries 100mAh et 300mAh, connecteur molex mâle<br />
</gallery><br />
<br />
Des batteries FQ777-124 mAh un peu moins encombrantes ont été commandées (disponibilité fin mars ?). Les connecteurs adaptés ont aussi été commandés (micro JST 2 broches 1.25mm).<br />
<br />
== Eclairage ==<br />
<br />
Vous pouvez vous lâcher sur les LED pour simuler les dispositifs lumineux de votre voiture. Attention cependant votre micro-contrôleur n'a qu'un nombre limité de sorties.<br />
<br />
== Contrôle de la voiture ==<br />
<br />
=== Contrôle par programmation ===<br />
<br />
Il est recommandé d'utiliser la fonctionnalité USB pour pouvoir programmer le comportement de la voiture. A défaut une programmation par port série est acceptable. Le programme PC permettant d'envoyer la suite d'instructions que la voiture doit réaliser est aussi à votre charge.<br />
<br />
=== Radio-contrôle ===<br />
<br />
Vous avez deux possibilités pour la commande à distance de votre voiture, soit une communication radio classique, soit une communication BlueTooth.<br />
<br />
<gallery><br />
File:module_nrf24L01.jpg|Module de communication 2,4Ghz<br />
File:module_BLE.jpg|Module Bluetooth Low Energy<br />
</gallery><br />
<br />
Les modules RF 2,4Ghz utilisent une puce NRF24L01, ces modules étant un peu encombrants, quelques puces ont été commandées pour intégration directe sur le PCB (disponibilité fin février). Vous avez un exemple d'utilisation sur le premier schéma de carte fourni plus haut. Les puces NRF24L01 doivent être alimentées en 3,3V mais ses E/S sont compatibles 5V. Il n'est donc pas obligatoire de passer l'ATMega16u2 en 3,3V.<br />
<br />
= Réalisation des groupes =<br />
<br />
{| class="wikitable"<br />
! Numéro !! Elèves !! Page <br />
|-<br />
| Binôme 1<br />
| Sarra BEZZINE & Heriniaina ANDRIANIRINTSOA<br />
| [[SE3Binome2022-1|Binôme 1 2022/2023]]<br />
|-<br />
| Trinôme 2<br />
| Younes BENMBAREK & Camille CARIAT & Abdel ZONGO<br />
| [[SE3Trinome2022-2|Trinôme 2 2022/2023]]<br />
|-<br />
| Binôme 3<br />
| Simon CRUCHET & Amaury BECQUET<br />
| [[SE3Binome2022-3|Binôme 3 2022/2023]]<br />
|-<br />
| Binôme 4<br />
| Romain DUHR & Louis DERYCKERE<br />
| [[SE3Binome2022-4|Binôme 4 2022/2023]]<br />
|-<br />
| Binôme 5<br />
| Youness EL QASTALANI & Chaymae Rhanim<br />
| [[SE3Binome2022-5|Binôme 5 2022/2023]]<br />
|-<br />
| Trinôme 6<br />
| Stephane KADER ISSACK & Marion NORMAND & Amaury DA PONTE<br />
| [[SE3Trinome2022-6|Trinôme 6 2022/2023]]<br />
|-<br />
| Binôme 7<br />
| Alexandre BRASSEUR & Louis WIJSMAN<br />
| [[SE3Binome2022-7|Binôme 7 2022/2023]]<br />
|-<br />
| Trinôme 8<br />
| Némo CAZIN & Antoine CEGARRA & Adrien PALIFERRO<br />
| [[SE3Trinome2022-8|Trinôme 8 2022/2023]]<br />
|-<br />
| Binôme 9<br />
| Thomas NAVE & Thibault DUYCK<br />
| [[SE3Trinome2022-9|Trinôme 9 2022/2023]]<br />
|-<br />
| Monôme 10<br />
| Adrien GONTIER<br />
| [[SE3Monome2022-10|Monôme 10 2022/2023]]<br />
|-<br />
| Binôme 11<br />
| Taha NEHARI & Martin CHAUVELIERE <br />
| [[SE3Binome2022-11|Binôme 11 2022/2023]]<br />
|-<br />
|}</div>Tnehari