SE4Binome2024-6

De projets-se.plil.fr
Aller à la navigation Aller à la recherche

GIT

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

Objectif

Nous avons pour objectif avec les 3 autres binômes de notre groupe de construire un pico-ordinateur qui intégrera plusieurs éléments essentiels. Voici les composants que nous allons inclure :

  • Un processeur de type microcontrôleur : Cela constituera le cœur de notre pico-ordinateur, permettant de gérer toutes les opérations.
  • Un clavier : Pour l'entrée de données, il nous permettra d'interagir facilement avec notre dispositif.
  • Un dispositif d'affichage : Cela nous permettra de visualiser les informations et les résultats des opérations effectuées par notre pico-ordinateur.
  • Un système d'exploitation : Celui-ci sera stocké dans la mémoire flash du microcontrôleur, garantissant un fonctionnement fluide de notre appareil.
  • Une mémoire de masse : Nous prévoyons d'ajouter une mémoire qui ira au-delà de la mémoire flash, pour stocker davantage de données.
  • Un dispositif de communication externe : Cela nous permettra d'interagir avec d'autres dispositifs ou réseaux.

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

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

Shield

Realisation

Nous nous sommes aidés des indications du professeur en première séance pour réaliser le schéma de notre shield, nous y avons rajouté une puce mémoire AT45DB161D, la datasheet nous a permis de savoir comment intégrer notre puce memoire dans notre schéma:

schematique du Bouclier

Ci dessous vous pouvez voir la version finale du routage concernant le PCB du Bouclier;

PCB routé

Après reception de notre PCB nous avons entamé la phase de soudure de nos composants. le Bouclier après soudure se présente comme suit :

Carte après soudure



Suite à une erreur d'orientation de nos broches; connecter l'arduino et notre Bouclier devenait une tâche beaucoup plus "compliquée" que prévu, mais grâce à une idée ingénieuse proposée par nos encadrants (Mr BOE et Mr REDON) nous y sommes parvenus. Le bouclier se connecte donc à l'arduino de la façon suivante:

connexion Bouclier-Arduino
connexion Bouclier-Arduino



Tests

LEDs

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

Voici le code c (GIT : pico_yahiani_zongo/Software/clignotement) qui nous permettra de faire clignoter les leds. 

#define BROCHE_LED_BLEU 4
#define BROCHE_LED_ORANGE 7
#define BROCHE_LED_ROUGE 14
#define BROCHE_LED_JAUNE 17
#define BROCHE_D3 0

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

void loop()
{
  digitalWrite(BROCHE_D3, HIGH);
  digitalWrite(BROCHE_LED_ORANGE, HIGH);
  delay (1000);
  digitalWrite(BROCHE_LED_ROUGE, HIGH);
  delay(1000);
  digitalWrite (BROCHE_LED_BLEU, HIGH);
  delay (1000);
  digitalWrite(BROCHE_LED_JAUNE, HIGH);
  delay (1000) ;
  digitalWrite(BROCHE_LED_ROUGE, LOW);
  digitalWrite(BROCHE_LED_BLEU, LOW);
  digitalWrite(BROCHE_LED_JAUNE, LOW);
  digitalWrite(BROCHE_LED_ORANGE, LOW);
  delay(1000);
}


fonctionnement effectif du bouclier (LED allumées)
fonctionnement effectif du bouclier (LED allumées)
clignotement des LEDs

Puce mémoire

Apres avoir tester les LEDs, nous cherchons à tester notre puce mémoire pour assurer son bon fonctionnement, cependant nous avons rencontré un petit problème.

Problème

En effet, lors du test de notre puce mémoire nous avons introduit une carte SD pour vérifier via le logiciel Arduino si notre puce mémoire détecte la carte SD, cependant, ce fut sans succès.

Nous avons donc vérifier l'horloge de notre Arduino Uno sur un oscilloscope en y injectant ce code (GIT : pico_yahiani_zongo/Software/test_clk_arduino): 

#include <SPI.h>

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

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

void loop()
{
  
  digitalWrite(slaveSelectPin, LOW);
  SPI.transfer(0xaa);
  Serial.write("ok");
  delay(100);
}


l'horloge de notre Arduino est fonctionnelle:

signal horloge










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

Carte SD reconnue








Connecteurs HE610

A l'aide d'un afficheur 7-segments nous verifions le bon fonctionnement des connecteurs HE610 en affichant "GrP6" pour Groupe6.

connecteur HE610 fonctionnel






Accomplissement des taches

Ordonnanceur

La principale tache a accomplir est de faire cligonter deux LED a des prefquences differentes. Pour cela nous passerons par plusieurs etapes. La première tâche à realiser est de programmer le minuteur 1 de l'ATMega328p de sorte à ce qu'il génère une interruption toutes les 20ms. Pour cela nous nous sommes inspirés du code donné par l'un de nos encadrants (Mr REDON) et avons le minuteur 1 programmé comme ceci:

programmation minuteur 1



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












La seconde étape consistait à faire clignoter la LED broche Arduino 13(PB5) en utilisant une ISR non nue avec notre timer. Le code suivant nous a permis de réaliser cette tâche. 

#include <avr/io.h>
#include <avr/interrupt.h>  

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


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

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

int main(void)
{
  DDRB |= (1<<PB5);
  init_timer();
  sei();
  while(1);
}
LED PB5 clignote


Pour passer d'une ISR non nue à une ISR naked il faut écrire les macros de sauvegardes et de restaurations des registres. Nous les avons écrites comme ceci : 

#define SAVE_REGISTERS() \
asm volatile ( \
"push r0 \n\t" \
"in r0, __SREG__ \n\t" \
"cli \n\t" \
"push r0 \n\t" \
"push r1 \n\t" \
"clr r1 \n\t" \
"push r2 \n\t" \
"push r3 \n\t" \
"push r4 \n\t" \
"push r5 \n\t" \
"push r6 \n\t" \
"push r7 \n\t" \
"push r8 \n\t" \
"push r9 \n\t" \
"push r10 \n\t" \
"push r11 \n\t" \
"push r12 \n\t" \
"push r13 \n\t" \
"push r14 \n\t" \
"push r15 \n\t" \
"push r16 \n\t" \
"push r17 \n\t" \
"push r18  \n\t" \
"push r19 \n\t" \
"push r20 \n\t" \
"push r21 \n\t" \
"push r22 \n\t" \
"push r23 \n\t" \
"push r24 \n\t" \
"push r25 \n\t" \
"push r26 \n\t" \
"push r27 \n\t" \
"push r28 \n\t" \
"push r29 \n\t" \
"push r30 \n\t" \
"push r31 \n\t" \
);

#define RESTORE_REGISTERS() \
asm volatile ( \
"pop r31 \n\t" \
"pop r30 \n\t" \
"pop r29 \n\t" \
"pop r28 \n\t" \
"pop r27 \n\t" \
"pop r26 \n\t" \
"pop r25 \n\t" \
"pop r24 \n\t" \
"pop r23 \n\t" \
"pop r22 \n\t" \
"pop r21 \n\t" \
"pop r20 \n\t" \
"pop r19 \n\t" \
"pop r18 \n\t" \
"pop r17 \n\t" \
"pop r16 \n\t" \
"pop r15 \n\t" \
"pop r14 \n\t" \
"pop r13 \n\t" \
"pop r12 \n\t" \
"pop r11 \n\t" \
"pop r10 \n\t" \
"pop r9 \n\t" \
"pop r8 \n\t" \
"pop r7 \n\t" \
"pop r6 \n\t" \
"pop r5 \n\t" \
"pop r4 \n\t" \
"pop r3 \n\t" \
"pop r2 \n\t" \
"pop r1 \n\t" \
"pop r0 \n\t" \
"out __SREG__, r0 \n\t" \
"pop r0 \n\t" \
);


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

typedef struct {
  void (*tache)(void);	
  int pile;
  int temps;
  int etat;//wake ou sleepy (processus actif ou en attente)
}tache; 
tache taches[TACHE_MAX];





Leds clignotant à des fréquences différentes
Récupérée de « http:///mediawiki/index.php?title=SE4Binome2024-6&oldid=6407 »