Dernière mise à jour le 12/01/2021

Présentation

Dans cette rubrique nous allons voir comment programmer la cam OpenMV en maitre afin que celle-ci communique avec le PIC18F4550 (esclave) sur le bus I2C. J’ai été surpris!! En effet il y a un décalage de bits à réaliser vers la droite  au niveau de l’adressage (1er octet), soit pour la cam OpenMV soit pour le PIC18F4550 mais pas les 2 à la fois!!. D’ailleurs j’en profite pour vous dire que ce décalage est aussi présent niveau du 1er octet entre le PIC et un Arduino UNO, il doit aussi être réaliser et pour démonstration vous pouvez vous rendre sur ce lien Communication I2C – Mode Ecriture – Arduino(Maitre) -> PIC 18F4550 (Esclave)
Nous verrons comment voir un tel décalage, et pour cela, nous allons nous servir de la cam OpenMV M7 qui utilise un processeur STM32F765VI ARM Cortex a 216 MHz, mais la version plus récente qui est la cam OpenMV H7 quant à elle utilise un processeur ARM Cortex M7 fonctionnant a 400 MHz. La différence vous l’aurez compris plus rapide pour le traitement d’image par exemple. Mais en ce qui concerne la liaison I2C le principe reste le même il ne faut pas oublier de décaler ce fameux bit vers la droite pour communiquer entre  microcontrôleur camOpenMV (ou Arduino UNO).

Compatibilité python OpenMV vers PIC18F4550 – tests EasyPicV7 – recherche adresse

Décalage d’adresse pour compatibilité ?
oui! effectivement, il faut réaliser un décalage car sinon rien ne fonctionne pas!.

Un jour je me suis posé la question si il était possible de brancher directement mon PIC18F4550 via les broches RB0(SDA) et RB1(SCL) sur les broches de la cam OpenMV qui sont P4(SCL) et P5(SDA) – ou P7(SCL) et P8(SDA) avec des résitances de tirages à 1K ohm. Pour la cam OpenMV, j’ai choisi P4 et P5 pour la création du BUS 2, et apres quelque ligne de code j’ai exécuté le script Python et là c’est le drame !! rien ne fonctionnais et aucune réception niveau PIC. Hum ?! Pourquoi ?

Pour en avoir le cœur net, j’ai donc envoyé directement l’adresse cAdrr = 0x02 sur afin que le PORTD éclaire la led RD1, et à ce moment je me suis rendu compte que c’était RD2 d’allumé et non RD1 – 1bit de plus sur la droite donc décalage à gauche !.

En réfléchissant je me suis rendu compte qu’il y a décalage vers la gauche à cause de ce bit suplémentaire (bit de poids faible)!! bizarre ?!
J’ai donc décalé l’adresse cAdrr = 0x02 >> 1 (côté cam OpenMV) vers la droite pour retirer ce bit supplémentaire afin que ce ne ça soit pas la led RD2 mais bien RD1. Après plusieurs test que nous allons voir un peu plus bas tout fonctionne à merveille et la cam OpenMV est désormais compatible avec le PIC18F4550!!

D’une manière général, si par exemple:

– cAdrr = 0x02 >> 1 (côté cam OpenMV) alors cAdrr = 0x02 (côté PIC) pour compatibilité !

– cAdrr = 0x02 (côté cam OpenMV) alors cAdrr = 0x04 (côté PIC) pour compatibilité !

Toujours réaliser le décalage de 1 (>> 1 ) côté cam OpenMV ou Arduino UNO !

Cam OpenMV (Maître) – PIC18F4550 (Esclave)

MAÎTRE – Programmation Python – Cam OpenMV STM32F765VI ARM

from pyb import I2C
import utime

i2c = I2C(2) # creation du bus I2C
i2c.init(I2C.MASTER, baudrate=100000) # initialisation du maître sur 100Khz

# 0x02 >> 1 : +1 bit à droite (décalage vers la gauche de l'adresse donne 0x04 pour PIC)
cAdrr = 0x02 >> 1
# si cAdrr = 0x02 côté cam OpenMV alors mettre cAdrr = 0x04 côté PIC18F4550 pour compatibilité !

while(True):

    # Vérifie si l'esclave répond à cette adresse:
    # -> renvoi True si l'esclave répond
    # -> renvoi False si l'escalve ne répond pas
    validation = i2c.is_ready(cAdrr)

    if (validation == True):
        i2c.send('A', addr = cAdrr) # Ecriture caractère 'A' led RD0 et RD6 allumées
        utime.sleep_ms(500)

        i2c.send('B', addr = cAdrr) # Ecriture caractère 'B' led RD1 et RD6 allumées
        utime.sleep_ms(500)

        i2c.send(0x01, addr = cAdrr) # Ecriture hexa '0x01' led RD0 allumé
        utime.sleep_ms(500)

        i2c.send(0xF0, addr = cAdrr) # Ecriture hexa '0xF0' led RD4 à RD7 allumées
        utime.sleep_ms(500)

Fonctionnement programmation Python
Dans le programme python ci-dessus, j’ai fixé une adresse nommée “cAdrr” de valeur 0x02 en hex (soit 2 en decimal ou bien 00000010b en binaire) mais comme vous pouvez le constater j’ai réalisé via l’opérateur ‘>>’ un décalage de 1 bit vers la gauche je rajoute en définitive 1 bit vers la droite pour que l’adresse se décale entièrement vers la gauche et je me retrouve non plus à 0x02 comme adresse mais à 0x04!! (soit 4 en décimal ou bien 00000100b en binaire), c’est la ou réside la subtilité afin de pouvoir communiquer avec le PIC18F4550 qui lui pour le coup est configuré en esclave avec pour adresse cAdrr = 0x02 qu’il ne faudra pas changer!.
Pour la suite, une fois que l’adresse a été vérifiée et validé, la cam ne fais que d’envoyer des données au PIC18F4550 qui lui les affichera sur son PORTD.

– Lettre A donne un code binaire 01000001b soit 41h (h = hexa) soit led RD0 et RD6 allumées sur platine
– Lettre B donne un code binaire 01000010b soit 42h (h = hexa) soit led RD1 et RD6 allumées sur platine
– 0x01 donne un code binaire 00000001b soit led RD0 allumé sur platine
– 0xF0 donne un code binaire 11110000b soit led RD4 à RD7 allumées sur platine

Bien sûr rien ne vous empêche de faire l’inverse c’est à dire de mettre pour le PIC cAdrr = 0x04 et garder pour la cam OpenMV cAdrr = 0x02 car le décalage a été réalisé cette fois-ci côté PIC !!.

ESCLAVE – Programmation MikroC – PIC18F4550

const cAdrr = 0x02; // cAdrr = 0x02 correspond à l'adresse de l'esclave
// Si cAdrr = 0x04 côté PIC alors mettre cAddr = 0x02 côté cam OpemMV pour compatibilité !

void interrupt() // On contrôle chaque interruptions
{
  if (PIR1.SSPIF == 1)
  {
    // SSPSTAT.R_W  -> bit0 = 1: Lecture  ou  bit0 = 0: Ecriture
    if (SSPSTAT.R_W == 1)
    {
      // Lecture -> Esclave vers Maître
      SSPBUF = 0xF0;   // Données sont ajoutée dans le buffer pour la lecture
    }
    else if (SSPSTAT.R_W == 0)
    {
      // Ecriture -> Maître vers Esclave
      LATD = SSPBUF;   // Affichage des données envoyée par le maitre pour ecriture
    }

  }

    SSPCON1.CKP = 1; // On relache l'horloge pour lancer la suite
    PIR1.SSPIF = 0;  // On remet à zéro le drapeau d'interruption et on attent la prochaine !
}

void init()
{

  ADCON1 = 0xFF;      //  On configure toutes les broches en numérique (0 ou 1)

  ADCON0.ADON = 0;   // On désactive le module de convertisseur analogique numérique

  CMCON = 0x07;      // On désactive le mode comparateur

  TRISB = 0x03;      // config les broches du PORTB - RB0 et RB1 comme entrée (SDA/SCL)
  PORTB = 0x00;
  LATB = 0x00;

  TRISD = 0x00;      // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;

  INTCON.GIE = 1;    // On active les interruptions globales 
  INTCON.PEIE = 1;   // On active les interruptions périphériques 
 
  PIE1.SSPIE = 1;    // On active le MSSP ( Module port série synch principal I2C ou SPI) 
  PIR1.SSPIF = 0;    // On met le drapeau d'interrutpion à zéro pour commencer 
 
  SSPCON1.SSPEN = 1; // On active les broches RB0 et RB1 en mode SDA et SCL
 
  // On active le mode 7 bits (0 à 7 = 8 bits) avec interruptions sur bit Start et Bit Stop 
  SSPCON1.SSPM0 = 0;
  SSPCON1.SSPM1 = 1;
  SSPCON1.SSPM2 = 1;
  SSPCON1.SSPM3 = 1;

  SSPADD = cAdrr;    // Configuration de l'adresse de l'esclave du PIC 18F4550

  SSPSTAT.SMP = 1;   //  vitesse de communication 100 Khz (standard)

  SSPCON2.SEN = 1;   // On active l'étirement de l'horloge

  Delay_ms(100);     // On attend un peu la fin de l'initialisation
}

void main()
{
  init(); // Initialisation du PIC18F4550

  while (1)
  {
    // On ne fait rien ...
  }
}

Fonctionnement programmation MikroC
Rien de particulier à dire, le PIC18F4550 est configuré en mode esclave pour plus de détails vous rendre sur ce lien PIC18F4550 – mode esclave (slave)


Conclusion
Ces deux programmation (Python et MikroC) permet uniquement via la cam OpenMV programmer en tant que maître d’envoyer des données sur l’esclave qui est le PIC18F4550 à l’adresse correspondante. Une fois les données reçues, le PIC18F4550 va gérer ces données par l’intermédiaire des interruptions afin de renvoyer les valeurs lues qui émane du maître et de les afficher sur son PORTD (allumées les différentes led du PORTD). Le but recherché dans ce chapitre était uniquement d’arriver à faire dialoguer la cam et le PIC18F4550 ensemble.

Test sur platine EasyPIC V7

L’envoi des données via la cam OpenMV sont récupéré par les interruptions du PIC18F4550 afin qu’il affiches sur le PORTD ces données. On remarque bien toutes les 500ms un changement d’état ce qui permet d’afficher les leds de la platine EasyPIC V7.

Le cablâge est réalisés sur le PORTC broche RC3(SCL) vers RB1(SCL du PIC18F4550) et RC4(SDA) vers RB0(SDA du PIC18F4550). En effet ce pont entre le PORTC permet de ramener les résistances de 4k7 sur le PORTB où sont reliés les broches SDA et SCL du PIC18F4550 situé sur la platine EasyPicV7. Ne pas oublier de placer les switchs (SW4) RC3 et RC4 en postion “ON” afin de mettre en circulation les résistances PULL-UP de 1K ohm de la platine EasyPicV7.
    
  (‘A’ donne 01000001b)          (‘B’ donne 01000010b)

      
 (0x01 donne 00000001b)        (0xF0 donne 11110000b)

Historiques

12/01/2021
– Ajout commentaire sur cAdrr = 0x02 (cam OpenMV) et cAdrr = 0x04 (PIC18F4550)

10/01/2021
-1er mise à disposition

Dernière mise à jour le 09/01/2021

Présentation

Comment utiliser un microcontrôleur en mode esclave (slave en anglais) en utilisant uniquement les interruptions? comment utiliser le “Clock stretching ” ou en français ce qui se traduit par “étirement de l’horloge”? comment les données arrivent dans le buffer et comment le microcontrôleur peut renvoyer des données en mode lecture lorsque le 8ème bit envoyé par le maitre est à l’état haut (“1” logique) – c’est ce que vous voulez connaître? et bien vous vous trouvez au bon endroit.

Soft_I2C Logiciel (Software) ou I2C Matériel (Hardware) ?

Bonne question? mais qu’est ce que cela veux bien dire ?
Pour faire simple:

I2C Logiciel (Software) : Lorsque nous parlons de I2C Logiciel c’est que votre microcontrôleur ne possède pas les broches SDA et SDL alors il faut trouver une parade afin de créer ces 2 broches pour la communication par la méthode logiciel (Software) en programmant quelques lignes de code supplémentaires. (On utilise la routine Soft_I2C de MikroC).

I2C Matériel (Hardware) : Lorsque nous parlons de I2C Matériel, c’est que votre microcontrôleur possède les broches SDA et SDL. (On utilise la routine I2C1 de MikroC)

Voilà la différence entre les deux !! pas compliquer non? avec ou sans broches SDA et SDL il est tout à fait possible de communiquer par la liaison I2C mais je vous conseille si vous devez réaliser un programme un peu plus complexe en utilisant des interruptions, vérifier le Buffer, ou autres de vous garantir que le PIC que vous utilisez soit bien équipé des broches SDA/SDL.

Réglages du PIC18F4550

Avant de se lancer dans la programmation du PIC18F4550, il faut avant toutes choses commencer à savoir ce que l’on désire réaliser en I2C pour que notre PIC puisse jouer le rôle d’esclave. Le PIC18F4550 comporte sur ces broches RB0(SDA) et RB1(SCL) la possibilité de réaliser une liaison I2C, et c’est donc ces 2 broches que nous allons utiliser afin de pouvoir communiquer avec le monde exterieur. En consultant Dans le datasheet (ou doc technique) du PIC18F4550, il faut se rendre au chapitre nommé “Master Synchronoux Serial Port” (MSSP) ou on y trouve 3 autres rubriques qui sont:
– Controle Registres
– SPI Mode
– I2C Mode (Ah? interressant! , c’est donc ce mode que nous là que nous allons utiliser).
Le module MSSP en mode I2C peut être utilisé soit en mode 7 bits soit en mode 10 bits. Pour ma part je vais utiliser en mode 7 bits que nous utilisons en grande majorité.
En ce qui concerne les broches RB0 pour l’horloge série (SCL) et RB1 pour les données série (SDA), nous devons configurer ces broches comme des entrées en définissant les bits TRISB (là encore ceci est très bien spécifié au niveau du datasheet. Vous verrez un peu plus bas au niveau de la programmation que chaque lignes sont détaillées pour explication.
Ce qui va nous intéresser particulièrement ce sont les interruptions ou nous passerons du temps pour bien comprendre la mécanique interne alors commençons sans plus tarder!

(Schéma qui va nous servir pour la réalisation des transmissions de données)

Interruptions
Les données qui émanes du maitre arrives dans un ordres bien précis qui sont en 1er un octet correspondant à l’adressage qui pour moisera 0xA8 (j’ouvre une parenthèse mais si vous utiliser plusieurs PIC sur la même liaison I2C il faut que le maitre distribues les données au microcontrôleurs correspondant – prenez exemple sur un facteur lorsqu’il distribue le courrier il faut une adresse précise pour chaque personne afin que le facteur puisse retrouver à qui il doit déposer le courrier dans la boite au lettres  et bien c’est la même chose pour l’adresse du PIC,  et c’est ce 1er octet qui le détermine je ferme la parenthèse et reprenons). En ce qui concerne le 2ème octet, je vais l’utiliser à ce que l’esclave puisse envoyer l’information au maitre ou bien à ce qu’il puisse afficher l’information sur le PORTD (des leds seront ou pas allumées en fonction de chaque bits afin de voir ce qui a été envoyé par le maitre). Vous savez quoi ??! on fera les 2 un envoi pour le maitre et un affichage au niveau des leds sur le PORTD.

Comment ça fonctionne niveau interruption? c’est là que nous allons voir ça de plus prêt.  Le fonctionnement est le suivant, lorsque le maitre envoie un 1er octet (8bits) qui correspond à l’adressage, le bit de poids faible en l’occurrence le bit 0 permet de savoir si nous somme en lecture ou en écriture. “1” pour la lecture et “0” pour l’écriture tout simplement. Ensuite les octets du bit 1 au bit 7 quant à eux sont l’adresse (oui car le 1er octet envoyé bit0 à bit7 est l’adresse il ne faut surtout pas l’oublier !). On peut représenter l’envoi des données comme ceci:

Diagramme en bloc

Les bits vont arrivés de la part du maitre 1 à 1 sur la broche RB1 (SDA) qui vont se réfugier tranquillement dans le registre SSPSR. Lorsque SSPSR sera rempli des 8bits, il y aura une comparaison avec le registre SSPADD qui correspond à l’adresse de mon PIC que j’ai déja renseigné par la valeur 0xA8 ce qui donne en binaire “10101000b” si SSPSR est égale à SSPADD alors une interruption survient et aussitôt les 8bits sont déplacé dans le buffer nommé SSPBUF qui va pouvoir être lu pas compliqué non? On vérifie si SSPSR correspond à l’adresse SSPADD et si c’est ok alors on peut lire,  sinon cas contraire rien ne se passe.

Quelle adresse choisir?
Voilà une bonne question. Une adresse ne ce choisi pas au hasard, car il faut respecter le protocole I2C qui énonce que le bit de poids faible (bit0) celui-ci sert à 2 états soit logique “1” pour lecture soit logique “0” pour écriture. En fonction du bit de poids faible bit0, l’esclave réagira ou non avec un bit d’acquittement nommé ACK.

Ainsi l’adresse 0xA8 = 10101000b donne ceci en écriture et l’adresse 0xA9 = 10101001b donne ceci en lecture et vous remarquerez que le bit0 change d’état si nous somme en lecture ou en écriture. vous aimerez utiliser une autre adresse comme par exemple l’adresse 0x02 = 00000010b (écriture) donne 0x03 = 00000011b (lecture). Un dernier pour la route ? 0x78 = 01111000b (écriture) donne 0x79 = 01111001b (lecture) pas compliqué non ? pour ma part j’utilise toujours l’adresse en tant qu’écriture.

Exemple 1 – Reconnaissance adresse cAdrr = 0x02 de l’esclave…

Seule l’adresse 0x02 est reçue par le PIC18F4550 et non les autres ainsi la broche RD1 est à l’état logique “1” de couleur rouge

const cAdrr = 0x02; // correspond à l'adresse de l'esclave

void interrupt() // On contrôle chaque interruptions
{
  if (PIR1.SSPIF == 1) // si SSPSTAT = SSPDR alors SSPIF = 1
  {
    LATD = SSPBUF;     // On affiche l'adresse

    SSPCON1.CKP = 1;   // On relâche l'horloge pour lancer la suite

    PIR1.SSPIF = 0;    // On remet à zéro le drapeau d'interruption et on attend la prochaine !
  }
}

void init()
{

  ADCON1 = 0xFF;     //  On configure toutes les broches en numérique (0 ou 1)

  ADCON0.ADON = 0;   // On désactive le module de convertisseur analogique numérique

  CMCON = 0x07;      // On désactive le mode comparateur

  TRISB = 0x03;      // config les broches du PORTB - RB0 et RB1 comme entréed (SDA/SCL)e
  PORTB = 0x00;
  LATB = 0x00;

  TRISD = 0x00;      // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;

  INTCON.GIE = 1;    // On active les interruptions globales 
  INTCON.PEIE = 1;   // On active les interruptions périphériques 
 
  PIE1.SSPIE = 1;    // On active le MSSP ( Module port série synch principal I2C ou SPI) 
  PIR1.SSPIF = 0;    // On met le drapeau d'interrutpion à zéro pour commencer 
 
  SSPCON1.SSPEN = 1; // On active les broches RB0 et RB1 en mode SDA et SCL
 
  // On active le mode 7 bits (0 à 7 = 8 bits) avec interruptions sur bit Start et Bit Stop 
  SSPCON1.SSPM0 = 0;
  SSPCON1.SSPM1 = 1;
  SSPCON1.SSPM2 = 1;
  SSPCON1.SSPM3 = 1;

  SSPADD = cAdrr;    // Configuration de l'adresse de l'esclave du PIC 18F4550

  SSPSTAT.SMP = 1;   //  vitesse de communication 100 Khz (standard)

  SSPCON2.SEN = 1;   // On active l'étirement de l'horloge

  Delay_ms(100);     // On attend un peu la fin de l'initialisation
}

void main()
{
  init(); // Initialisation du PIC18F4550

  while (1)
  {
    // On ne fait rien ...
  }
}

Debugger I2C – Test Proteus
Pour les tests et le principe de fonctionnement je vous laisse vous rendre sur ce lien d’explication Debugger I2C

Ci-dessous le code a copier pour test sous proteus

Conclusion
Le code ci-dessus en MikroC + le code du Debugger I2C de proteus montre uniquement que le PIC18F4550 en mode esclave réagira uniquement sur l’adresse 0x02 et non sur les adresse 0xA8 ou 0xA9. Une fois l’adresse correspondante reçue, il affichera celle-ci sur le PORTD c’est d’ailleurs ce que vous voyer au niveau du schéma electronique la broche RD1 est à l’état logique haut (+5V) car c’est bien l’adresse qui correspond à celle que nous avons renseigné dans le SSPADD.

On va maintenant s’interesser sur le principe de comment envoyer (si le maître demande de lire les données de l’esclave) et afficher des données (si le maître demande d’écrire des données sur l’esclave).

Exemple 2 – Ecriture/lecture adresse cAdrr = 0x02 réponse esclave…

Ecriture

Regardons déjà un 1er exemple sur l’écriture, le maitre va envoyer le 1er octet qui correspond à l’adresse (S 02 A = S 0x02 A = S 00000010b A) et tout de suite après il va enchainer avec le 2ème octets qui correspond aux données que nous allons vouloir écrire (0x05 = 00000101b). Ainsi le PORTD met à l’état logique haut RD0 et RD2.

– 1er octet validé à mis à l’état logique haut RD1.
– 2ème octet tout de suite dans la foulée a mis à l’état logique haut RD0 et RD2 (c’est pour cette raison que nous avons pas eu le temps de voir RD1 à l’état logique haut car l’interruption pour le 1er octet a été levée rapidement).

Lecture

Regardons maintenant ce que cela donne en mode lecture. Nous avons cette fois-ci toujours la même adresse sauf que le bit0 est à l’état logique “1” cela donne 0x03 = 00000011b(lecture). Dans cette configuration, c’est l’esclave qui va renvoyer ses données au maître car c’est le maitre qui réclame la lecture – la couleur bleu représente l’esclave et en rose le maître. L’esclave a envoyé comme données 0xF0 = 11110000b, et à la fin de l’envoie des données, le maîtres génère un bit d’acquittement  “Nak”en signalant qu’il à bien reçu ses données.

Ces lignes de code ci-dessous qui peuvent être copiés collés (c’est fait pour d’ailleurs ;-)) vont vous permettre de configurer votre PIC18F4550 en mode esclave. Je vous laisse le soin de modifier la variable ‘cAdrr’ pour modifier l’adresse de votre esclave.

const cAdrr = 0x02; // correspond à l'adresse de l'esclave

void interrupt() // On contrôle chaque interruptions
{
  if (PIR1.SSPIF == 1)
  {
    // SSPSTAT.R_W  -> bit0 = 1: Lecture  ou  bit0 = 0: Ecriture
    if (SSPSTAT.R_W == 1)
    {
      // Lecture -> Esclave vers Maître
      SSPBUF = 0xF0;   // Données sont ajoutée dans le buffer pour la lecture
    }
    else if (SSPSTAT.R_W == 0)
    {
      // Ecriture -> Maître vers Esclave
      LATD = SSPBUF;   // Affichage des données envoyée par le maitre pour ecriture
    }

  }

    SSPCON1.CKP = 1; // On relache l'horloge pour lancer la suite
    PIR1.SSPIF = 0;  // On remet à zéro le drapeau d'interruption et on attent la prochaine !
}

void init()
{

  ADCON1 = 0xFF;      //  On configure toutes les broches en numérique (0 ou 1)

  ADCON0.ADON = 0;   // On désactive le module de convertisseur analogique numérique

  CMCON = 0x07;      // On désactive le mode comparateur

  TRISB = 0x03;      // config les broches du PORTB - RB0 et RB1 comme entrée (SDA/SCL)
  PORTB = 0x00;
  LATB = 0x00;

  TRISD = 0x00;      // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;

  INTCON.GIE = 1;    // On active les interruptions globales 
  INTCON.PEIE = 1;   // On active les interruptions périphériques 
 
  PIE1.SSPIE = 1;    // On active le MSSP ( Module port série synch principal I2C ou SPI) 
  PIR1.SSPIF = 0;    // On met le drapeau d'interrutpion à zéro pour commencer 
 
  SSPCON1.SSPEN = 1; // On active les broches RB0 et RB1 en mode SDA et SCL
 
  // On active le mode 7 bits (0 à 7 = 8 bits) avec interruptions sur bit Start et Bit Stop 
  SSPCON1.SSPM0 = 0;
  SSPCON1.SSPM1 = 1;
  SSPCON1.SSPM2 = 1;
  SSPCON1.SSPM3 = 1;

  SSPADD = cAdrr;    // Configuration de l'adresse de l'esclave du PIC 18F4550

  SSPSTAT.SMP = 1;   //  vitesse de communication 100 Khz (standard)

  SSPCON2.SEN = 1;   // On active l'étirement de l'horloge

  Delay_ms(100);     // On attend un peu la fin de l'initialisation
}

void main()
{
  init(); // Initialisation du PIC18F4550

  while (1)
  {
    // On ne fait rien ...
  }
}

Debugger I2C – Test Proteus
Pour les tests et le principe de fonctionnement je vous laisse vous rendre sur ce lien d’explication Debugger I2C

Ci-dessous le code a copier pour test sous proteus

Conclusion
Niveau programmation “un peu” de changement .
– Ecriture : 0x02 = 00000010b donne bien une ecriture et le 2ème octet (0x05) va lui aussi être envoyé pour être écrit.
– Lecture : 0x03 = 00000011b donne bien une lecture, c’est en mode lecture que l’esclave va renvoyer ses données afin que le maître puisse les lires.
En faite que faisons nous exactement? (remonter un peu plus haut pour voir le “Diagramme bloc”).
On envoi sur la broche SDA, le 2ème octet 0x05 = 00000101b. Cet octet va donc aller se réfugier tranquillement dans le registre SSPSR. Une interruption survient et va remplir le registre SSPBUF (rien d’anormal niveau fonctionnement interne), Si vous regardez attentivement le Diagramme bloc vous avez “Read” et “Write” Read pour la lecture sur le BUS interne et Write pour l’ecriture sur le BUS interne c’est en fonction des états de “SSPSTAT.R_W”(ce bit agit seul et c’est lui qui vérifie les différents état du bit0 (bit de poid faible)) soit 1 pour la lecture dans ce cas il faut préparer le SSPBUF pour que celui-ci soit lu par le maître ou “SSPSTAT.R_W” qui va être à l’état 0 pour l’ecriture et dans ce cas nous affichons les données sur le PORTD envoyées par le maître . Je vous laisse lire à tête reposer le programme MikroC afin que vous compreniez bien le fonction en mode esclave.

Ce qu’il faut comprendre en I2C, c’est le bit de poids faible bit0 qui mène la danse. Ensuite l’adressage de PIC ne dois pas se terminer avec un bit0 = 1 mais un bit0 = 0. Ainsi, seul le maître décidera d’attribuer un “1” ou “0” logique pour faire les transmissions soit en lecture soit en écriture.

Test sur platine EasyPicV7

Non pas cette fois-ci…

Historiques

09/01/2021
-1er mise à disposition

Dernière mise à jour le 06/01/2021

Présentation

Cette interface UsbHid permet de lire des données émanant d’un PIC (ou autres) et qui comporte sur ses broches la possibilité de réaliser une liaison USB (on retrouve sur ses broches D+ et D-). J’utilise souvent dans mes programme comme couche PID = 1234 et VID = 0001, mais rien ne vous empêche de mettre autre chose à une condition que vous n’ayez pas du materiels connecté avec ces 2 “paramètres” identique!. Ce logiciel sans prétention permet de recevoir des données numérique comprise entre 0 et 255 et ses entrées son limitées à 5 (un total de 5 Buffers pour être précis) .

Logiciel (.exe)

Attention ! Merci de bien indiquer le VID et PID afin que votre PC détecte votre PIC(cas contraire un message d’erreur apparaitra). en ce qui concerne VID et PID je vous laisse vous rendre à cette page Configuration port USB – VID/PID

Logiciel: Interface_UsbHid_Voltmetre_Numerique

Historiques

06/01/2021
– Première mise à disposition.

Dernière mise à jour le 06/01/2021

Présentation

Ce montage électronique ne fais que de lire des tension analogiques. Ces tension peuvent seront lus via ce logiciel sans prétention développé par mes soins disponible à cette adresse de mon site Interface UsbHid – voltmetre numerique.

Schéma

Programmation materiel – MikroC

Niveau réglages de l’horloge, ce rendre dans la barre des taches de MikroC faire “Project” ensuite “Edit Project” et régler l’horloge interne avant d’exécuter le code qui va suivre pour le bon fonctionnement de l’ecrture de la carte SD. Ne pas oublier de désactiver la broche MCLR 😉 (voir capture ci-dessous). et pour finir je vous laisse vous rendre sur ce lien Configuration port USB – VID/PID pour le VID PID (pour ma part je ne change pas j’utilise toujours PID = 1234 et VID = 0001)

  USB_Interrupt_Proc(); // La maintenance USB est effectuée à l'intérieur de l'interruption
  }

  CMCON = 0x07; // On désactive les comparateurs

  ADON_bit = 1; // On active le convertisseur A/N

  ADCON0 = 0xFF; //  renvoie une mesure d'entrée flottante

  ADCON1 = 0x0A;  // On config broches RA0 à RA5 en analog le reste en sortie

  ADFM_bit = 0;

  // VCFGx -> à 0 = tension de référence à désactiver
  VCFG0_bit = 0; // Place la référence de tension sur VSS = 0V
  VCFG1_bit = 0; // Place la référence de tension sur VDD = +xV

  // régler sur 12TAD mais doit être > 12TAD -> Lié avec ADC_Init()
  ACQT0_bit = 1;
  ACQT1_bit = 0;
  ACQT2_bit = 1;

  // Fosc/2
  ADCS0_bit = 0;
  ADCS1_bit = 0;
  ADCS2_bit = 0;

  TRISA = 0xFF;  // Toutes les broches du PORTA sont configurées comme entrées
  PORTA= 0x00;
  LATA = 0x00;

  ADC_Init(); // Initialisation de la lecture analogique 12TAD MINI

  HID_Enable(&readbuff,&writebuff); // Initalisation USB

  Delay_ms(200);  // attendre un peu la fin de l'intialisation
}

// Programme principal
void main()
{
  unsigned char adc_value0, adc_value1, adc_value2;
  unsigned char adc_value3, adc_value4;

  init(); // Initialisation du PIC 18F4550

  while (1)
  {
     adc_value0 =  ADC_Get_Sample(0) >> 2; // decalage de 2 vers la droite (255)
     writebuff[0] =  adc_value0 ; // Ecriture writebuff[0]

     adc_value1 =  ADC_Get_Sample(1) >> 2; // decalage de 2 vers la droite (255)
     writebuff[1] =  adc_value1 ; // Ecriture writebuff[1]

     adc_value2 =  ADC_Get_Sample(2) >> 2; // decalage de 2 vers la droite (255)
     writebuff[2] =  adc_value2 ; // Ecriture writebuff[2]

     adc_value3 =  ADC_Get_Sample(3) >> 2; // decalage de 2 vers la droite (255)
     writebuff[3] =  adc_value3 ; // Ecriture writebuff[3]

     adc_value4 = ADC_Get_Sample(4) >> 2; // decalage de 2 vers la droite (255)
     writebuff[4] =  adc_value4 ; // Ecriture writebuff[4]

     // Envoies des données sur BUS USB
     HID_Write(&writebuff,64);

  }

Fonctionnement général
Que dire? ce programme permet de lire les tensions comprises entre 0V et 5V sur les potentiomètres RV1 à RV5. Ces tensions vont venir attaquer les entrées du PIC18F4550 qui se chargera des les convertir en tension numériques (0 à 255) afin de les envoyer sur le bus USB. J’en profite au passage de vous envoyer vers ce lien afin de télécharger le logiciel Interface UsbHid – voltmetre numerique et de pouvoir tester l’affichage des tensions.
Je n’est pas essayé ce montage avec un quartz de 20Mhz, mais j’ai trouvé une différence entre le PORTA et le PORTB niveau tension. En effet sur le PORTA la visualisation des tensions sont très sensibles.

Test sur platine EasyPicV7

Oui et logiciel en action.

Historiques

06/01/2021
-1er mise à disposition

Dernière mise à jour le 05/01/2021

Présentation

Dans cette rubrique nous allons nous intéresser sur la lecture d’une carte SD (fichier .txt uniquement) et d’envoyer ces données sur le port USB.
j’ai refait un copié collé de ce qui avait été dis précédemment sur la carte MMC/SD ce copié collé n’est là uniquement que pour rappel. Si vous voulez sauter cette étape allez directement voir le schéma.

Besoin de plus de mémoire supplémentaire que l’EEPROM? La carte MMC / SD dispose d’un emplacement pour carte MMC / SD pour les cartes MMC ou SD. Nous allons nous intéresser, sur comment faire pour écrire sur une carte SD via le MMC/SD Board de MikroElectronika que vous voyez ci-dessus. Cette carte permet de connecter une carte SD type MMC (ou SD) (voir ci-dessous).

Vous pouvez bien sûr mettre une mini SD à condition d’avoir l’adaptateur qui lui est souvent livré lors de l’achat de la mini SD (encore ci-dessous).

Nous allons voir comment réaliser un tel montage electronique via la platine EasyPic V7 en utilisant un PIC 18F4550, puis nous ferrons quelques branchement via des fils de liaison afin d’interconnecté la carte MMC/SD sur les broches du PIC.

Raccordement du MMC/SD sur la platine EasyPIC V7

(Clique pour agrandir)

La carte dispose d’une nappe qui comporte un connecteur (CN11 tout à gauche en haut) 10 broches puis un switch (SW1 tout à gauche en bas) avec 8 postions possibles. Ces postions qui vont nous concerner sont les positions 1/4/6 – (P1/P5/P3)  et ces petits interrupteurs doivent se retrouver en position haut dirigées vers le “ON” pour l’utilisation de PICs . Les autres interrupteurs ne nous concerne pas car la carte MMC/SD peut être utilisée pour d’autres microcontrôleurs type AWR8081 ou bien des dsPIC.

Une fois nos 3 petits switchs (1/4/6) en position “ON” regardons de plus prêt le connecteur CN11 qui je le dis au passage sera raccordé sur le PORTD de la platine EasyPic V7.

ATTENTION – CN11 !!

Il faut faire attention lors du branchement afin de ne pas inverser le toron et de vous retrouver avec le +VCC relié à la masse ! pour éviter cet incident, le branchement doit se faire à ce que votre platine EasyPicV7 soit en face de vous, et que la carte MMC/SD soit mis dans une position à ce que le cavalier (+5V/3,3V) soit positionné vers le  bas comme le montre la photo ci-dessous:

(Clique pour agrandir)

Branchement des fils de liaisons – MMC/SD vers PIC18F4550

Les fils de couleurs ci-dessus, ne correspondent pas à la photos ci-dessous, j’aurais dû faire une effort pour que le fils entre RD3 et RB1 soit (noir), que le fil entre RD5 et RC7 soit (rouge), entre RD4 et RB0 soit (bleu) et pour finir RD0 et RC0 soit (vert). Nous allons maintenant aborder la partie connexion entre le PIC 18F4550 et notre carte MMC/SD. Nous avons uniquement branché le connecteur CN11 sur le PORTD de notre platine (pour ceux qui auraient sauté une étape je le rappel au passage ;-)), mais il reste maintenant à relier vers les broches du PIC.  Pour cela il faut vous munir de 4 fils femelles avec ce type de connexion ci-dessous:

• Relier broches RD0 à RC0
• Relier broches RD4 à RB0
• Relier broches RD3 à RB1
• Relier broches RD5 à RC7

Pour connecter le connecteur CN11 sur la platine, j’ai été dans l’obligation de réaliser (en fils volant) l’alimentation des différents PORTS de ma platine afin d’effectuer les connexions sur les différents broches du PIC 18F4550.

  (Clique pour agrandir)       (Clique pour agrandir)

FAT 12/16 ou FAT32 ? qu’est-ce que c’est?

En anglais FAT (File Allocation Table – table d’allocation de fichiers).La table d’allocation de fichiers est en fait un index qui liste le contenu du disque, afin d’enregistrer l’emplacement des fichiers sur celui-ci. Etant donné que les blocs qui constituent un fichier ne sont pas toujours stockés de manière contiguë sur le disque (c’est ce que l’on appelle la fragmentation), la table d’allocation permet de conserver la structure du fichier en créant des liens vers les blocs constitutifs du fichier. Le système FAT est un système 16 bits permettant de décrire un fichier par un nom d’une longueur de 8 caractères et une extension qui en comporte 3. On appelle ainsi ce système FAT16.
Pour améliorer ce point, la version originale de Windows 95 (employant le système FAT16) a été dotée d’une prise en charge améliorée de la FAT, il s’agit du système VFAT (Virtual FAT). La VFAT est un système 32 bits permettant d’enregistrer un fichier avec un nom de 255 caractères de long. Les programmeurs ont toutefois dû veiller à la compatibilité ascendante, de telle façon a pouvoir accéder à ces fichiers à partir d’environnements 16 bits (DOS). La solution a donc été d’affecter un nom pour chaque système. C’est la raison pour laquelle il est possible d’utiliser des noms longs sous Windows 95, tout en pouvant y accéder sous DOS.

Le système de fichiers FAT est un système 16 bits, cela signifie qu’il ne peut pas adresser les clusters sur plus de 16 bits. Le nombre maximum de clusters repérables avec le système FAT est ainsi de 216, soit 65536 clusters. Or, étant donné qu’un cluster est constitué d’un nombre fixé (4,8,16,32, …) de secteurs de 512 octets contigüs, la taille maximale d’une partition FAT se trouve en multipliant le nombre de clusters par la taille d’un cluster. Avec des clusters d’une taille 32Ko, la taille maximale d’une partition FAT est donc de 2Go.

D’autre part, un fichier ne peut occuper qu’un nombre entier de clusters, c’est-à-dire que si un fichier occupe plusieurs clusters, le dernier sera occupé en partie, et la place inoccupée restante est autant de place perdue. Par conséquent plus la taille d’un cluster est réduite, moins il y a de gaspillage de place. On estime qu’un fichier gaspille en moyenne la moitié d’un cluster, cela signifie que sur une partition de 2Go 16Ko seront perdus par fichier… Le formatage des cartes mémoire est recommandé par presque tous les experts en technologie du monde entier.

Les cartes SD sont principalement utilisées dans les appareils photo numériques et les téléphones cellulaires. Les fabricants d’appareils photo numériques recommandent le formatage à l’intérieur de l’appareil photo lui-même. C’est un moyen d’initialiser la carte SD.

Faisons simple !
Si la carte est de 2 Go ou inférieure à 2 Go, vous pouvez la formater en FAT 12/16 ou FAT(tout court) mais si la carte est supérieure à 2 Go, vous devez la formater (bien sûr il faut que votre ordinateur soit équipé d’un lecteur de carte SD !) en FAT 32. Il suffit de faire un clique droit sur votre carte SD et de selectionner “Formater” (windows 10 vous rendre dans “CE PC” et normalement vous derviez voir voir carte SD connectée, il suffit de faire un clique droit sur cette dernière et de selectionner “formater” )

Schéma

(Clique pour agrandir)

On remarque sur ce schéma qu’il y’a en entrée la carte MMC/SD de Mikroelectronika (à gauche), au milieu le coeur du montage cadencé par un quartz de 8Mhz afin de faire tourner le PIC1

Le logiciel disponible sur ce lien Interface UsbHid Affichage texte qui je tiens à signalé à été amélioré, vous permettrons de voir les données que le port USB va envoyer sur le bus USB.

Il s’agit ici d’un exemple, car la lecture du fichier (.txt) est réalisée uniquement si et seulement si le fichier se nomme “Carte_SD_TXT”. Oui, puisque c’est bien celui-ci qui est appelé dans le programme.

Programmation materiel – MikroC

Niveau réglages de l’horloge, ce rendre dans la barre des taches de MikroC faire “Project” ensuite “Edit Project” et régler l’horloge interne avant d’exécuter le code qui va suivre pour le bon fonctionnement de l’ecrture de la carte SD. Ne pas oublier de désactiver la broche MCLR 😉 (voir capture ci-dessous). et pour finir je vous laisse vous rendre sur ce lien Configuration port USB – VID/PID pour le VID PID (pour ma part je ne change pas j’utilise toujours PID = 1234 et VID = 0001)

void interrupt()
{
  USB_Interrupt_Proc(); // La maintenance USB est effectuée à l'intérieur de l'interruptio
}


void init()
{
  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  CMCON = 0x07; // On désactive les comparateurs

  ADON_bit = 0; // On désactive le module de convertion analogique/numérique

  TRISA = 0xC2; // RA2 config comme entrée pour ecrire sur la carte + RA6/RA7
  PORTA = 0x00;
  LATA = 0x00;

  HID_Enable(&readbuff,&writebuff); // Initalisation USB

  Delay_ms(100); // On attend un peu la fin de l'initialisation de l'activation USB

  // Initialisation du module SPI1;
  SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64,
                     _SPI_DATA_SAMPLE_MIDDLE,
                     _SPI_CLK_IDLE_LOW,
                     _SPI_LOW_2_HIGH);

  Lecture = FALSE; // Ecriture non réalisée

  Delay_ms(100); // Attendre l'initialisation de la liaison SPI (pour carte SD)
}


// Fonction pour l'écriture caractère par caractère sur le port USBHID
void Ecriture_Char(unsigned char* buffer_USBHID)
{

  // On boucle sur un seul éléments du tableau (buffer_USBHID)
  for(i = 0 ; i < 1  ; ++i)
  {
    writebuff[i] = buffer_USBHID[i]; // On copie dans le buffer USBHID
  }

  HID_Write(&writebuff,64); // Ecriture sur le port USB
}


// Fonction pour la lecture carte SD
void Lecture_SD()
{
  unsigned char i;
  unsigned long size; // Correspond à la taille du fichier (.txt)
  unsigned char character;
  unsigned char buffer_USBHID[1] = {0}; // Buffer pour 1 seul élement

  // On initialise la carte SD lors de la connection
  if (!Mmc_Fat_Init())
  {
    Mmc_Fat_Assign("Card_SD.TXT",0x01); //Card_SD.TXT -> doit être de 11 caractères MAXI
    Mmc_Fat_Reset(&size); // On récupère la taille du fichier (.txt)

    for (i = 0; i < size ; i++)
    {
      Mmc_Fat_Read(&character); // Lecture de la carte SD (par pointeur !)

      buffer_USBHID[0] = character;

      Delay_ms(20); // attendre minimum 20ms pour chargement caractère dans Buffer

      Ecriture_Char(buffer_USBHID); // Ecriture

      buffer_USBHID[0] = 0; // On remet à zéro le buffer
    }
  }
}


// Programme principal
void main()
{
  init();

  while (1)
  {
     if ((PORTA.RA1 == 1) && (Lecture == FALSE))
     {
       Lecture = TRUE;
       Lecture_SD(); // Lecture carte SD
     }
     else if ((PORTA.RA1  == 0) && (Lecture == TRUE))
     {
       Lecture = FALSE;
     }
   }
}

Fonctionnement général
Le principe de fonctionnement est le suivant. Chaque fois que vous pressez le bouton RA1 du PORTA, la lecture et l’écriture est réalisée, et vous pouvez d’ailleurs observer l’affichage des données via ce logiciel téléchargeable directement en cliquant ici.

Fonctionnement détaillé
Côté programmation en C nous allons regarder ça de plus prêt:

Programme principal (void Main)
Dans cette fonction nous y trouvons tout d’abord la fonction init() qui dans un 1er temps va initialiser le PIC18F4550 c’est la 1er fonction qui sera exécutée à la mise sous tension de microcontrôleur (PORT/SPI/USB)
Ensuite, nous allons rentrer dans la boucle while(1) qui celle-ci tournera en permanence avant l’arrêt complet du PIC (mis hors tension).
Lorsque nous allons appuyer sur le bouton RA1 de la platine EasyPICV7, nous allons passer la variable « Lecture » à TRUE en indiquant qu’une lecture sera sur le point d’être lancée ce qui empêchera à la boucle while (qui tourne très vite) de retourner là ou nous nous situons en ce moment (la variable Lecture qui était à FALSE est maintenant à TRUE).
Ensuite viens l’appel de la fonction « Lecture_SD » qui comme vous l’aurez compris va faire le travail sur la partie lecture de la carte SD (voir détails plus bas).
Lorsque vous relâcher le bouton – avant/pendant ou après la lecture, vous allez repasser la variable “Lecture” à l’état FALSE cette fois-ci (cela concerne la ligne précédente du code).
Il faudra donc appuyer une 2ème fois pour relancer la lecture si et seulement si la lecture de la carte SD est terminée. Bien entendu cette lecture peut durer quelque minutes avant de pouvoir la relancer de nouveau.

Fonction Lecture (void Lecture_SD)
Dans cette fonction, nous y retrouvons ;

Mmc_Fat_Assign(“Card_SD.TXT”,0x01) qui est une fonction pour assigner ou plutôt dirais-je de récupérer le fichier existant sur la carte SD en l’occurrence (“Card_SD.TXT”) avec 0x01 pour dire que nous faisons simplement une lecture seule du fichier sans le modifier (ouverture du fichier en lecture seule).

Mmc_Fat_Reset(&size) permet de récupérer la taille du fichier plus précisément cela donne le nombre de caractère présent dans le fichier (*.txt) il peut y en avoir très peut comme il peut en avoir beaucoup ce qui fera gonfler la taille du fichier (.txt)

Mmc_Fat_Read(&character) Lit un octet du fichier actuellement attribué ouvert en lecture (via Mmc_Fat_Assign) . Lors de l’exécution de la fonction, les pointeurs (&) du fichier seront positionnés sur le caractère. Ainsi lors de l’exécution de cette fonction, l’octet de lecture est renvoyé via ce paramètre nommé character (son nom peut bien sûr être modifié).

buffer_USBHID[0] = character on va gentiment recopier ce caractère qui concerne le 1er octet de 8 bits dans le buffer à l’emplacement[0]

Delay_ms(20)  on ralentit de 20 ms entre la réception du caractère récupérer dans le fichier et l’écriture sur le port USB. Pour ne pas compliquer je ne suis pas passé par les interruptions et préféré faire ainsi ! la diminution de cette tamporisation de 20ms risque de faire dérailler l’ecriture et provoquer des caractèred un peu bizarre… je vous laisse essayer…

Ecriture_Char(buffer_USBHID[0]) On envoi le buffer dans la fonction et on fait appel à celle-ci.

Fonction Lecture (Ecriture_Char(unsigned char* buffer_USBHID))
La dernière étape qui est une boucle sur 1 seul élément du tableau, oui forcément buffer_USBHID = buffer_USBHID[0] soit 1 élement du tableau recopier dans le buffer du port USB.

writebuff[i] = buffer_USBHID[i] de nouveau on place le caractère de 1 octet (8bits) dans le buffer du port USB.

HID_Write(&writebuff,64) et pour finir on envoi notre caractère sur le port USB qui comporte quant à lui 64 élements … Laissons maintenant faire le logiciel « Interface UsbHid Affichage texte » qui fera le travail derrière

Test sur platine EasyPicV7

Oui testé bien entendu!!, et testé aussi avec un fichier (.txt) à condition qu’il se nomme “Carte_SD.TXT” (bien entendu vous pouvez changer de nom à condition que la totalité des caractères soient de 11 et pas un de plus!), j’ai visualisé l’affichage mais étant données que le traitement des données sont de 20ms ça peut devenir long si vous lisez un gros fichier. Ne pas diminuer cette petite temporisation car la sychronisation entre MMC/SD et l’ecriture sur le port USB ne sera plus synchronisé et vous allez aperçevoir de drôles de symboles…

Historiques

05/01/2021
-1er mise à disposition

Dernière mise à jour le 05/01/2021

Présentation

Cette interface UsbHid permet de lire des données émanant d’un PIC (ou autres) et qui comporte sur ses broches la possibilité de réaliser une liaison USB (on retrouve sur ses broches D+ et D-). J’utilise souvent dans mes programme comme couche PID = 1234 et VID = 0001, mais rien ne vous empêche de mettre autre chose à une condition que vous n’ayez pas du materiels connecté avec ces 2 “paramètres” identique!

Il n’y a rien à faire ce logiciel ne fait que de lire les données qui émanes des broches D+ et D- du PIC qui possède cette spécificité d’ailleurs un exemple sur ce lien PIC18F4550 – mode affichage texte 2 Vous pouvez changer soit en mode lecture carte SD, soit en mode lecture texte (type variables).

Il comporte 2 modes qui sont:

– Lecture carte SD: Ce mode permet de lire caractère par caractère qui émane d’une carte SD ou bien d’un clavier alphanumérique sur un BUS USB.

– Lecture texte: Ce mode permet de lire des grandes lignes de texte par exemple si vous affecté dans une variable type:

permettra de lire en un seul bloc les 64 bits situés sur le bus USB.(exemple dans ce programme PIC18F4550 – mode affichage texte)

Logiciel (.exe)

Attention ! Merci de bien indiquer le VID et PID afin que votre PC détecte votre PIC(cas contraire un message d’erreur apparaitra). en ce qui concerne VID et PID je vous laisse vous rendre à cette page Configuration port USB – VID/PID

Logiciel: Interface_UsbHid_Lecture_De_Texte

Historiques

05/01/2021
– Ajout de 2 boutons radio “Lecture carte SD” ou “Lecture texte”.

04/01/2021
– Première mise à disposition.

Dernière mise à jour le 04/01/2021

Présentation

Ne prenez surtout pas peur lorsque vous allez voir les lignes de programmation un peut plus bas ce n’est surtout pas le but alors resté un peu :-).
Nous allons voir ensemble comment envoyer des données en utilisant le port USB du PIC18F4550 (oui encore une fois ce µC….), et nous allons voir aussi qu’il est tout à fait possible de réaliser un genre de clavier alphanumérique par cette même liaison USB cela vous tente de rester encore un peu?
Niveau clavier j’ai juste fais l’essai avec les lettres de type A/B/C/Z, puis même chose avec le chiffre 5 – après tous si ça marche pour 5 ça fonctionne pour “0,1,2,3,4,6,7,8,9”. Ah oui!! j’ai même essayé les caractères spéciaux comme “%“ ou “/“…
Bien entendu je vous laisse imaginer ce qu’il est possible de réaliser avec le programme qui va suivre. Le but n’est pas de réaliser un clavier d’ordinateur qui peut être raccordé via un port USB mais de vous donner quelle que ligne de code pour que vous puissiez lire un fichier TXT et l’afficher puis écrire à la suite des caractères et d’afficher ces résultats via ce petit logiciel que j’ai développé sans prétention et accessible depuis mon site à ce lien Logiciel: Interface UsbHid – Affichage texte

Schéma

(Clique pour agrandir)

Niveau schéma rien de bien compliqué. Notre quartz de 8Mhz, quelque boutons poussoir qui vont permettent d’envoyer les données sur le logiciel Interface_UsbHid_Lecture_De_Texte avec le PORTB qui donne:

RB0_bit : Lecture du texte
RB1_bit : Ecrire caractère ‘A’
RB2_bit : Ecrire caractère ‘B’
RB3_bit : Ecrire caractère ‘C’
RB4_bit : Ecrire caractère ‘Z’
RB5_bit : Ecrire caractère ‘5’
RB6_bit : Ecrire caractère ‘%’
RB7_bit : Ecrire caractère ‘/’

Je vous laisse tester …

Programmation assez longues …. MikroC

Bon nous y voilà !! retroussons nos manches et avant de lire essayons de prendre du recule sur ce code. Tout d’abord, je vous laisse vous rendre sur cette page Configuration port USB – VID/PID “Pour la familles des PIC 18F Réglages dans Edit Project” afin de bien régler l’horloge de votre PIC18F4550 et l’alimentation du VUSB. Suivez bien les captures d’écran.
Le code est découpé en 5 fonctions différentes qui sont:

  USB_Interrupt_Proc(); // La maintenance USB est effectuée à l'intérieur de l'interruption
}

void init()
{
  // Initialisation du PIC18F4550
}



// Fonction pour l'écriture sur le port USB
void Ecriture(unsigned char* sText)
{
  // C'est dans cette boucle que nous allons envoyer les données
}



// Fonction pour l'écriture caractère par caractère sur le port USB
void Ecriture_Char(unsigned char sText)
{
  // Envoyer des caractères tour à tour (pour clavier par exemple...)
}



// Programme principal
void main()
{

  init(); // Initialisation du PIC 18F4550

  while(1)
  {
    // Ecrtiure caractère ".."
    // C'est dans le programme plus précisement la boucle while ou nous allons réaliser la gestion des touches
    else if ((PORTB.B0 == 1) && (Ecriture_Char_0 == FALSE))
    {
      Ecriture_Char_1 = TRUE;
      sText_4_Char = '%';
      Ecriture_Char(sText_1_Char);
    }
    else if ((PORTB.B1 == 0) && (Ecriture_Char_1 == TRUE))
    {
      Ecriture_Char_1 = FALSE;
    }
  }
}

Et ci-dessous le code que vous pouvez désormais copier et coller.
Attention: Lorsque vous allez coller le code dans MikroC, et le compiler vous allez avoir un message d’erreur ! En effet, les guillemets sont mal interprétés et il faudra les corriger en début et fin de chaine de caractère voir capture ci-dessous:

En ce qui concerne la configuration de l’horloge faire ceci:

  USB_Interrupt_Proc(); // La maintenance USB est effectuée à l'intérieur de l'interruption
}

void init()
{
  CMCON = 0x07; // On désctive les comparateurs
  ADON_bit = 0; // On désactive le convertisseur A/N
  ADCON1 = 0xFFFF; // On configure toutes les broches en Digital

  TRISA = 0x01; // Broche RA1 config comme entrée et le reste en sortie
  PORTA = 0x00;
  LATA = 0x00;

  TRISB = 0xFF;  // Toutes les broches du PORTB sont configurées comme entrées
  PORTB = 0x00;
  LATB = 0x00;

  HID_Enable(&readbuff,&writebuff); // Initialisation USB

  delay_ms(100); // On attend un peu la fin de l'initialisation
}



// Fonction pour l'écriture sur le port USB
void Ecriture(unsigned char* sText)
{
  while ( iCountChar != strlen(sText))  // On compte le nbr de caractères
  {
    // On vide le Buffer avant l'écriture
    for(i = 0 ; i < 64  ; ++i)
    {
      writebuff[i] = 0;
    }

    // On ajoute les caractère pour la nouvelle écriture
    for(i = 0 ; i < 64  ; ++i)
    {
      writebuff[i] = sText[iCountChar];
      if (iCountChar == strlen(sText))
      {
        Stop_Ecriture_HID = TRUE;
        HID_Write(&writebuff,64);
        break;
      }

      ++iCountChar;
    }

    if (Stop_Ecriture_HID == TRUE)
    {
      iCountChar = 0;
      break;
    }
    else
    {
      HID_Write(&writebuff,64);
    }
  }
}



// Fonction pour l'écriture caractère par caractère sur le port USB
void Ecriture_Char(unsigned char sText)
{
  // On vide le Buffer avant l'écriture
  for(i = 0 ; i < 64  ; ++i)
  {
    writebuff[i] = 0;
  }

  // On ajoute le caractère pour la nouvelle écriture
  writebuff[0] = sText;
  HID_Write(&writebuff,64);
}



// Programme principal
void main()
{

  init(); // Initialisation du PIC 18F4550

  while(1)
  {
    // Ecriture -> texte
    if ((PORTB.B0 == 1) && (Ecriture_HID == FALSE) && (Stop_Ecriture_HID == FALSE))
    {
      Ecriture_HID = TRUE;
      Ecriture(sText_3); // -> changer sText_3 par: sText_1 ou sText_2 ou sText_3
    }
    else if ((PORTB.B0 == 0) && (Ecriture_HID == TRUE) && (Stop_Ecriture_HID == TRUE))
    {
      Ecriture_HID = FALSE;
      Stop_Ecriture_HID = FALSE;
    }


    // Ecrtiure caractère  -> lettre A
    else if ((PORTB.B1 == 1) && (Ecriture_Char_1 == FALSE))
    {
      Ecriture_Char_1 = TRUE;
      sText_4_Char = 'A';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B1 == 0) && (Ecriture_Char_1 == TRUE))
    {
      Ecriture_Char_1 = FALSE;
    }


    // Ecrtiure caractère  -> lettre B
    else if ((PORTB.B2 == 1) && (Ecriture_Char_2 == FALSE))
    {
      Ecriture_Char_2 = TRUE;
      sText_4_Char = 'B';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B2 == 0) && (Ecriture_Char_2 == TRUE))
    {
      Ecriture_Char_2 = FALSE;
    }


    // Ecrtiure caractère  -> lettre C
    else if ((PORTB.B3 == 1) && (Ecriture_Char_3 == FALSE))
    {
      Ecriture_Char_3 = TRUE;
      sText_4_Char = 'C';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B3 == 0) && (Ecriture_Char_3 == TRUE))
    {
      Ecriture_Char_3 = FALSE;
    }


    // Ecrtiure caractère  -> lettre Z
    else if ((PORTB.B4 == 1) && (Ecriture_Char_4 == FALSE))
    {
      Ecriture_Char_4 = TRUE;
      sText_4_Char = 'Z';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B4 == 0) && (Ecriture_Char_4 == TRUE))
    {
      Ecriture_Char_4 = FALSE;
    }


    // Ecrtiure caractère  -> chiffre 5
    else if ((PORTB.B5 == 1) && (Ecriture_Char_5 == FALSE))
    {
      Ecriture_Char_5 = TRUE;
      sText_4_Char = '5';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B5 == 0) && (Ecriture_Char_5 == TRUE))
    {
      Ecriture_Char_5 = FALSE;
    }


    // Ecrtiure caractère  -> caractere speciale "%"
    else if ((PORTB.B6 == 1) && (Ecriture_Char_6 == FALSE))
    {
      Ecriture_Char_6 = TRUE;
      sText_4_Char = '%';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B6 == 0) && (Ecriture_Char_6 == TRUE))
    {
      Ecriture_Char_6 = FALSE;
    }


    // Ecrtiure caractère  -> caractere speciale "/"
    else if ((PORTB.B7 == 1) && (Ecriture_Char_7 == FALSE))
    {
      Ecriture_Char_7 = TRUE;
      sText_4_Char = '/';
      Ecriture_Char(sText_4_Char);
    }
    else if ((PORTB.B7 == 0) && (Ecriture_Char_7 == TRUE))
    {
      Ecriture_Char_7 = FALSE;
    }
  }
}

Je vous laisse réflechir …

Historiques

04/01/2021
-1er mise à disposition

Dernière mise à jour le 02/01/2021

Présentation

Besoin de plus de mémoire supplémentaire que l’EEPROM? La carte MMC / SD dispose d’un emplacement pour carte MMC / SD pour les cartes MMC ou SD. Nous allons nous intéresser, sur comment faire pour écrire sur une carte SD via le MMC/SD Board de MikroElectronika que vous voyez ci-dessus. Cette carte permet de connecter une carte SD type MMC (ou SD) (voir ci-dessous).

Vous pouvez bien sûr mettre une mini SD à condition d’avoir l’adaptateur qui lui est souvent livré lors de l’achat de la mini SD (encore ci-dessous).

Nous allons voir comment réaliser un tel montage electronique via la platine EasyPic V7 en utilisant un PIC 18F4550, puis nous ferrons quelques branchement via des fils de liaison afin d’interconnecté la carte MMC/SD sur les broches du PIC.

Raccordement du MMC/SD sur la platine EasyPIC V7

(Clique pour agrandir)

La carte dispose d’une nappe qui comporte un connecteur (CN11 tout à gauche en haut) 10 broches puis un switch (SW1 tout à gauche en bas) avec 8 postions possibles. Ces postions qui vont nous concerner sont les positions 1/4/6 – (P1/P5/P3)  et ces petits interrupteurs doivent se retrouver en position haut dirigées vers le “ON” pour l’utilisation de PICs . Les autres interrupteurs ne nous concerne pas car la carte MMC/SD peut être utilisée pour d’autres microcontrôleurs type AWR8081 ou bien des dsPIC.

Une fois nos 3 petits switchs (1/4/6) en position “ON” regardons de plus prêt le connecteur CN11 qui je le dis au passage sera raccordé sur le PORTD de la platine EasyPic V7.

ATTENTION – CN11 !!

Il faut faire attention lors du branchement afin de ne pas inverser le toron et de vous retrouver avec le +VCC relié à la masse ! pour éviter cet incident, le branchement doit se faire à ce que votre platine EasyPicV7 soit en face de vous, et que la carte MMC/SD soit mis dans une position à ce que le cavalier (+5V/3,3V) soit positionné vers le  bas comme le montre la photo ci-dessous:

(Clique pour agrandir)

Branchement des fils de liaisons – MMC/SD vers PIC18F4550

Attention ! Les fils de couleurs sur la capture ci-dessus, ne correspondent pas à la photos ci-dessous, j’aurais dû faire une effort pour que le fils entre RD3 et RB1 soit (noir), que le fil entre RD5 et RC7 soit (rouge), entre RD4 et RB0 soit (bleu) et pour finir RD0 et RC0 soit (vert). Un nouveau fil de liaison apparait celui de Tx qui sera connecté entre RE1 et RC6 soit (jaune)Nous allons maintenant aborder la partie connexion entre le PIC 18F4550 et notre carte MMC/SD. Nous avons uniquement branché le connecteur CN11 sur le PORTD de notre platine (pour ceux qui auraient sauté une étape je le rappel au passage ;-)), mais il reste maintenant à relier vers les broches du PIC.  Pour cela il faut vous munir de 4 fils femelles avec ce type de connexion ci-dessous:

• Relier broches RD0 à RC0
• Relier broches RD4 à RB0
• Relier broches RD3 à RB1
• Relier broches RD5 à RC7
• Relier broches RE1 à RC6 : broche Tx

Pour connecter le connecteur CN11 sur la platine, j’ai été dans l’obligation de réaliser (en fils volant) l’alimentation des différents PORTS de ma platine afin d’effectuer les connexions sur les différents broches du PIC 18F4550. Vous remarquerez le fils jaune qui permet de renvoyer la broche RE1 vers RC6 pour la communication série via le port USB de la platine EasyPicV7.

  (Clique pour agrandir)          (Clique pour agrandir)              (Clique pour agrandir)

FAT 12/16 ou FAT32 ? qu’est-ce que c’est?

En anglais FAT (File Allocation Table – table d’allocation de fichiers).La table d’allocation de fichiers est en fait un index qui liste le contenu du disque, afin d’enregistrer l’emplacement des fichiers sur celui-ci. Etant donné que les blocs qui constituent un fichier ne sont pas toujours stockés de manière contiguë sur le disque (c’est ce que l’on appelle la fragmentation), la table d’allocation permet de conserver la structure du fichier en créant des liens vers les blocs constitutifs du fichier. Le système FAT est un système 16 bits permettant de décrire un fichier par un nom d’une longueur de 8 caractères et une extension qui en comporte 3. On appelle ainsi ce système FAT16.
Pour améliorer ce point, la version originale de Windows 95 (employant le système FAT16) a été dotée d’une prise en charge améliorée de la FAT, il s’agit du système VFAT (Virtual FAT). La VFAT est un système 32 bits permettant d’enregistrer un fichier avec un nom de 255 caractères de long. Les programmeurs ont toutefois dû veiller à la compatibilité ascendante, de telle façon a pouvoir accéder à ces fichiers à partir d’environnements 16 bits (DOS). La solution a donc été d’affecter un nom pour chaque système. C’est la raison pour laquelle il est possible d’utiliser des noms longs sous Windows 95, tout en pouvant y accéder sous DOS.

Le système de fichiers FAT est un système 16 bits, cela signifie qu’il ne peut pas adresser les clusters sur plus de 16 bits. Le nombre maximum de clusters repérables avec le système FAT est ainsi de 216, soit 65536 clusters. Or, étant donné qu’un cluster est constitué d’un nombre fixé (4,8,16,32, …) de secteurs de 512 octets contigüs, la taille maximale d’une partition FAT se trouve en multipliant le nombre de clusters par la taille d’un cluster. Avec des clusters d’une taille 32Ko, la taille maximale d’une partition FAT est donc de 2Go.

D’autre part, un fichier ne peut occuper qu’un nombre entier de clusters, c’est-à-dire que si un fichier occupe plusieurs clusters, le dernier sera occupé en partie, et la place inoccupée restante est autant de place perdue. Par conséquent plus la taille d’un cluster est réduite, moins il y a de gaspillage de place. On estime qu’un fichier gaspille en moyenne la moitié d’un cluster, cela signifie que sur une partition de 2Go 16Ko seront perdus par fichier… Le formatage des cartes mémoire est recommandé par presque tous les experts en technologie du monde entier.

Les cartes SD sont principalement utilisées dans les appareils photo numériques et les téléphones cellulaires. Les fabricants d’appareils photo numériques recommandent le formatage à l’intérieur de l’appareil photo lui-même. C’est un moyen d’initialiser la carte SD.

Faisons simple !
Si la carte est de 2 Go ou inférieure à 2 Go, vous pouvez la formater en FAT 12/16 ou FAT(tout court) mais si la carte est supérieure à 2 Go, vous devez la formater (bien sûr il faut que votre ordinateur soit équipé d’un lecteur de carte SD !) en FAT 32. Il suffit de faire un clique droit sur votre carte SD et de sélectionner “Formater” (windows 10 vous rendre dans “CE PC” et normalement vous devriez voir voir carte SD connectée, il suffit de faire un clique droit sur cette dernière et de sélectionner “formater” )

Schéma

(Clique pour agrandir)

Bon !! oui cette fois-ci j’ai fais un effort sur la représentation des fils de connexion, on ne voit pas très bien le fil jaune mais c’est l’interconnexion entre RE1 et RC6. C’est la broche Tx qui va nous servir d’envoyer les données lu sur la carte SD afin de l’afficher sur ce petit logiciel que vous pouvez télécharger en cliquant sur ce lien: PortSerie (ou SerialPort) Niveau montage celui-ci est composé de son quartz de 8Mhz, de la carte MMC/SD, et via l’aide d’un boutton poussoir qui celui-ci nous permettra d’écrire sur la carte SD. Le but de ce montage très simple et de voir comment il est possible d’écrire sur une carte SD.

Soft_UART Logiciel (Software) ou UART Matériel (Hardware) ?

Bonne question? mais qu’est ce que cela veux bien dire ? Dans ce montage, nous voulons lire les données qui sont présente sur la carte et par la même occasion les afficher en utilisant le port série (Logiciel développé par mes propre soin que vous pouvez télécharger via le lien évoqué un peu plus haut ou ici).

Si vous regarder attentivement le schéma, nous voyons très bien que la broche RC7 est déjà utilisée sur SD-DI, et donc il en résulte que la broches RC7 qui elle aussi permet d’envoyer des informations via la liaison série Tx est condamnée, et donc impossible de l’utiliser !! Humm … ?? comment faire ?? je change de PIC ?  j’en achète un autre afin d’avoir TX et RX à part comme c’est le cas du PIC18F4520 qui lui dispose de SDA/SDO pour les broches (RC4 et RC5) et de Tx/Rx pour les broches (RC6 et RC7)? Bien sûr que non, et je vais vous faire économiser votre argent ! Pour bien faire c’est ce que nous allons voir de suite la programmation logiciel mais en ce qui conerne une définition simple en voici une:

UART Logiciel (Software) : Lorsque nous parlons d’une configuration Logiciel c’est que votre microcontrôleur ne possède pas les broches nécessaire (en l’occurence Tx déja occupé) alors il faut trouver une parade afin de créer cette broches pour la communication par la méthode logiciel (Software) en programmant quelques lignes de code supplémentaires. (On utilise la routine Soft_UART de MikroC).

UART Matériel (Hardware) : Lorsque nous parlons de UART Matériel, c’est que votre microcontrôleur à déja les broches comme par exemple le PIC18F4520 ou comme vue précédemment sont à part. Ainsi, on utilise la routine UART de MikroC et le tour est joué !

Vous voulez en avoir la preuve? alors essayer de copier ces lignes de codes, mais avant toute chose, allez dans la barre des taches de MikroC faire “Project” ensuite “Edit Project” et régler l’horloge interne comme ceci avant d’exécuter le code qui va suivre et d’ailleurs on gardera pour de bon cette configuration ! Ah oui!! n’oublié pas aussi de désactiver la broche MCLR ;-).

  char error;

  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  CMCON = 0x07; // On désactive les comparateurs

  ADON_bit = 0; // On désactive le module de convertion analogique/numérique

  TRISA = 0xC2; // RA1 config comme entrée pour ecrire sur la carte + RA6/RA7
  PORTA = 0x00;
  LATA = 0x00;

  TRISD = 0x00; // Toutes les broches du PORTD sont configurées comme sortie
  PORTD = 0x00;
  LATD = 0x00;

  // Configuration logiciel -> Soft
  // Soft_UART_Init(*PORT, Rx, Tx, Baud, Inversseur);
  error = Soft_UART_Init(&PORTE, 0, 1, 9600, 0);

  LATD = error; // On vérifie si toutes les leds sont éteintes

  bTx = FALSE;

  Delay_ms(100); // On attend un peu la fin de l'initialisation
}

// Programme principal
void main()
{
  init();
  while (1)
  {
     if ((PORTA.RA1 == 1) && (bTx == FALSE))
     {
       Soft_UART_Write('T'); // Ecriture
       Soft_UART_Write('E'); // Ecriture
       Soft_UART_Write('S'); // Ecriture
       Soft_UART_Write('T'); // Ecriture

       bTx = TRUE;
     }
     else if ((PORTA.RA1  == 0) && (bTx == TRUE))
     {
       bTx = FALSE;
     }
   }
}

A l’exécution et si vous appuyez sur le bouton RA1 de la platine puis en utilisant le logiciel évoqué plus haut, vous devriez obtenir “TEST” comme ceci:

Programmation materiel et logiciel – MikroC

  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;
  
  CMCON = 0x07; // On désactive les comparateurs
  
  ADON_bit = 0; // On désactive le module de convertion analogique/numérique
  
  TRISA = 0xC2; // RA1 config comme entrée pour ecrire sur la carte + RA6/RA7
  PORTA = 0x00;
  LATA = 0x00;
 
  TRISE = 0x00; // Toutes les broches du PORTE sont configurées comme sorties
  PORTE = 0x00;
  LATE = 0x00;
  
  // Configuration logiciel -> Soft
  // Soft_UART_Init(*PORT, Rx, Tx, Baud, Inversseur);
  Soft_UART_Init(&PORTE, 0, 1, 9600, 0);

  Delay_ms(100); // On attend un peu la fin de l'initialisation
  
  // Initialisation du module SPI1;
  SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64,
                     _SPI_DATA_SAMPLE_MIDDLE,
                     _SPI_CLK_IDLE_LOW,
                     _SPI_LOW_2_HIGH);

  Lecture = FALSE;

  Delay_ms(100); // On attend un peu la fin de l'initialisation
}

void Lecture_SD()
{
  unsigned char i;
  unsigned long size;
  unsigned char character;

  // On initialise la carte SD lors de la connection
  if (!Mmc_Fat_Init())
  {
    Mmc_Fat_Assign("Card_SD.TXT",0x01); //Card_SD.TXT -> doit être de 11 caractères MAXI 

    Mmc_Fat_Reset(&size);

    for (i = 1; i <= size; i++)
    {
      Mmc_Fat_Read(&character); // Lecture de la carte SD

      Soft_UART_Write(character); // Ecriture sur le port Tx
    }

    LATA2_bit = 1;
  }
}

// Programme principal
void main()
{
  init();

  while (1)
  {
     if ((PORTA.RA1 == 1) && (Lecture == FALSE))
     {
       Lecture_SD(); // Lecture carte SD
       Lecture = TRUE;
     }
     else if ((PORTA.RA1  == 0) && (Lecture == TRUE))
     {
       Lecture = FALSE;
     }
   }
}

Fonctionnement
Si vous avez respecté à la lettre tous ce qui a été indiqué, juste en appuyant sur le PORTA RA1 vous devrier obtenir ceci:

J’ai dans un 1er temps écrit sur la carte SD via ce montage accessible à ce lien: PIC18F4550 – mode ecriture card MMC/SD puis en appuyant sur la bouton RA1 j’obtient en boucle à chaque appuis “Des lignes en dessous Des lignes en dessous Des …….”

Historiques

02/01/2021
-1er mise à disposition

Dernière mise à jour le 05/01/2021

Présentation

Besoin de plus de mémoire supplémentaire que l’EEPROM? La carte MMC / SD dispose d’un emplacement pour carte MMC / SD pour les cartes MMC ou SD. Nous allons nous intéresser, sur comment faire pour écrire sur une carte SD via le MMC/SD Board de MikroElectronika que vous voyez ci-dessus. Cette carte permet de connecter une carte SD type MMC (ou SD) (voir ci-dessous).

Vous pouvez bien sûr mettre une mini SD à condition d’avoir l’adaptateur qui lui est souvent livré lors de l’achat de la mini SD (encore ci-dessous).

Nous allons voir comment réaliser un tel montage electronique via la platine EasyPic V7 en utilisant un PIC 18F4550, puis nous ferrons quelques branchement via des fils de liaison afin d’interconnecté la carte MMC/SD sur les broches du PIC.

Raccordement du MMC/SD sur la platine EasyPIC V7

(Clique pour agrandir)

La carte dispose d’une nappe qui comporte un connecteur (CN11 tout à gauche en haut) 10 broches puis un switch (SW1 tout à gauche en bas) avec 8 postions possibles. Ces postions qui vont nous concerner sont les positions 1/4/6 – (P1/P5/P3)  et ces petits interrupteurs doivent se retrouver en position haut dirigées vers le “ON” pour l’utilisation de PICs . Les autres interrupteurs ne nous concerne pas car la carte MMC/SD peut être utilisée pour d’autres microcontrôleurs type AWR8081 ou bien des dsPIC.

Une fois nos 3 petits switchs (1/4/6) en position “ON” regardons de plus prêt le connecteur CN11 qui je le dis au passage sera raccordé sur le PORTD de la platine EasyPic V7.

ATTENTION – CN11 !!

Il faut faire attention lors du branchement afin de ne pas inverser le toron et de vous retrouver avec le +VCC relié à la masse ! pour éviter cet incident, le branchement doit se faire à ce que votre platine EasyPicV7 soit en face de vous, et que la carte MMC/SD soit mis dans une position à ce que le cavalier (+5V/3,3V) soit positionné vers le  bas comme le montre la photo ci-dessous:

(Clique pour agrandir)

Branchement des fils de liaisons – MMC/SD vers PIC18F4550

Les fils de couleurs ci-dessus, ne correspondent pas à la photos ci-dessous, j’aurais dû faire une effort pour que le fils entre RD3 et RB1 soit (noir), que le fil entre RD5 et RC7 soit (rouge), entre RD4 et RB0 soit (bleu) et pour finir RD0 et RC0 soit (vert). Nous allons maintenant aborder la partie connexion entre le PIC 18F4550 et notre carte MMC/SD. Nous avons uniquement branché le connecteur CN11 sur le PORTD de notre platine (pour ceux qui auraient sauté une étape je le rappel au passage ;-)), mais il reste maintenant à relier vers les broches du PIC.  Pour cela il faut vous munir de 4 fils femelles avec ce type de connexion ci-dessous:

• Relier broches RD0 à RC0
• Relier broches RD4 à RB0
• Relier broches RD3 à RB1
• Relier broches RD5 à RC7

Pour connecter le connecteur CN11 sur la platine, j’ai été dans l’obligation de réaliser (en fils volant) l’alimentation des différents PORTS de ma platine afin d’effectuer les connexions sur les différents broches du PIC 18F4550.

  (Clique pour agrandir)       (Clique pour agrandir)

FAT 12/16 ou FAT32 ? qu’est-ce que c’est?

En anglais FAT (File Allocation Table – table d’allocation de fichiers).La table d’allocation de fichiers est en fait un index qui liste le contenu du disque, afin d’enregistrer l’emplacement des fichiers sur celui-ci. Etant donné que les blocs qui constituent un fichier ne sont pas toujours stockés de manière contiguë sur le disque (c’est ce que l’on appelle la fragmentation), la table d’allocation permet de conserver la structure du fichier en créant des liens vers les blocs constitutifs du fichier. Le système FAT est un système 16 bits permettant de décrire un fichier par un nom d’une longueur de 8 caractères et une extension qui en comporte 3. On appelle ainsi ce système FAT16.
Pour améliorer ce point, la version originale de Windows 95 (employant le système FAT16) a été dotée d’une prise en charge améliorée de la FAT, il s’agit du système VFAT (Virtual FAT). La VFAT est un système 32 bits permettant d’enregistrer un fichier avec un nom de 255 caractères de long. Les programmeurs ont toutefois dû veiller à la compatibilité ascendante, de telle façon a pouvoir accéder à ces fichiers à partir d’environnements 16 bits (DOS). La solution a donc été d’affecter un nom pour chaque système. C’est la raison pour laquelle il est possible d’utiliser des noms longs sous Windows 95, tout en pouvant y accéder sous DOS.

Le système de fichiers FAT est un système 16 bits, cela signifie qu’il ne peut pas adresser les clusters sur plus de 16 bits. Le nombre maximum de clusters repérables avec le système FAT est ainsi de 216, soit 65536 clusters. Or, étant donné qu’un cluster est constitué d’un nombre fixé (4,8,16,32, …) de secteurs de 512 octets contigüs, la taille maximale d’une partition FAT se trouve en multipliant le nombre de clusters par la taille d’un cluster. Avec des clusters d’une taille 32Ko, la taille maximale d’une partition FAT est donc de 2Go.

D’autre part, un fichier ne peut occuper qu’un nombre entier de clusters, c’est-à-dire que si un fichier occupe plusieurs clusters, le dernier sera occupé en partie, et la place inoccupée restante est autant de place perdue. Par conséquent plus la taille d’un cluster est réduite, moins il y a de gaspillage de place. On estime qu’un fichier gaspille en moyenne la moitié d’un cluster, cela signifie que sur une partition de 2Go 16Ko seront perdus par fichier… Le formatage des cartes mémoire est recommandé par presque tous les experts en technologie du monde entier.

Les cartes SD sont principalement utilisées dans les appareils photo numériques et les téléphones cellulaires. Les fabricants d’appareils photo numériques recommandent le formatage à l’intérieur de l’appareil photo lui-même. C’est un moyen d’initialiser la carte SD.

Faisons simple !
Si la carte est de 2 Go ou inférieure à 2 Go, vous pouvez la formater en FAT 12/16 ou FAT(tout court) mais si la carte est supérieure à 2 Go, vous devez la formater (bien sûr il faut que votre ordinateur soit équipé d’un lecteur de carte SD !) en FAT 32. Il suffit de faire un clique droit sur votre carte SD et de selectionner “Formater” (windows 10 vous rendre dans “CE PC” et normalement vous derviez voir voir carte SD connectée, il suffit de faire un clique droit sur cette dernière et de selectionner “formater” )

Schéma

(Clique pour agrandir)

Le montage est composé de son quartz de 8Mhz, de la carte MMC/SD, et via l’aide d’un boutton poussoir qui celui-ci nous permettra d’écrire sur la carte SD. Le but de cemontage très simple et de voir comment il est possible d’écrire sur une carte SD.

Programmation materiel – MikroC

Dans la barre des taches de MikroC faire “Project” ensuite “Edit Project” et régler l’horloge interne comme ceci avant d’exécuter le code qui va suivre pour le bon fonctionnement de l’ecrture de la carte SD. Ne pas oublier de désactiver la broche MCLR ;-).

  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  CMCON = 0x07; // On désactive les comparateurs

  ADON_bit = 0; // On désactive le module de convertion analogique/numérique
  
  TRISA = 0xC2; // RA2 config comme entrée pour ecrire sur la carte + RA6/RA7
  PORTA = 0x00;
  LATA = 0x00;

  TRISB = 0x00; // config le PORTB comme sortie
  PORTB = 0x00;
  LATB = 0x00;

  TRISC = 0x00; // config le PORTC comme sortie
  PORTC = 0x00;
  LATC = 0x00;

  // Initialisation du module SPI1;
  SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64,
                     _SPI_DATA_SAMPLE_MIDDLE,
                     _SPI_CLK_IDLE_LOW,
                     _SPI_LOW_2_HIGH);

  Ecriture = FALSE; // Ecrtiure non réalisée

  Delay_ms(100); // On attent un peu la fin de l'initialisation
}

void Fin_Ecriture()
{
  char iCount;

  for (iCount = 0 ; iCount < 4 ; ++iCount)
  {
    Led_Ecriture =~ Led_Ecriture;
    Delay_ms(200);
  }
}

void Ecriture_SD()
{
  unsigned char iCount;
  unsigned char iNbrChar = 0;

  // On verifie si nous avons réalisé toute la lecture du tableau
  if (bFinBoucle == TRUE)
  {
    Tab_Element = 0;
    bFinBoucle = FALSE;
    Led_FinBoucle = 0;
  }

  // On allume la led du PORTA.RA3 si lecture complete
  if (Tab_Element == 3)
  {
    Led_FinBoucle = 1;
    bFinBoucle = TRUE;
  }

  // Vérification carte MCC/SD + ecriture
  else if ((!Mmc_Fat_Init()) && (bFinBoucle == FALSE))
  {
    Mmc_Fat_Assign("Card_SD.TXT",0xA0); // Card_SD.TXT -> doit être de 11 caractères MAXI

    Mmc_Fat_Append(); // Permet d'ajouter des nouvelles ligne dans le (.txt)

    for(iCount = 1 ; iCount <= strlen(Array[Tab_Element]) ; ++iCount)
    {
      ++iNbrChar;
    }

    Mmc_Fat_Write(Array[Tab_Element],iNbrChar); // Ecriture sur la carte

    ++Tab_Element;

    Fin_Ecriture();
  }
}

// Programme principal
void main()
{
  init();

  while (1)
  {
     if ((PORTA.RA1 == 1) && (Ecriture == FALSE))
     {
       Ecriture_SD(); // Ecriture
       Ecriture = TRUE;
     }
     else if ((PORTA.RA1  == 0) && (Ecriture == TRUE))
     {
       Ecriture = FALSE;
     }
   }
}

Fonctionnement
Le principe de fonctionnement est le suivant. Chaque fois que vous pressez le bouton RA1 du PORTA, l’écriture est réalisé et à la fin de l’écriture la led RA2 se met à clignoter 2 fois. Vous avez donc écrit sur le premier appuis “Des lignes” dans la carte SD. Lorsque vous pressez de nouveau RA1 la led clignote 2 fois et vous avez écrit dans la carte SD “ecrites”. Lorsque vous appuyer une 3ème fois de nouveau vous écrivez “en dessous” et la led RA2 se met à clignoter 2 fois. Un 4 ème appuis allumera la led RA3 qui vous informe que vous avez terminé la lecture du tableau “Array”, afin de recommencer le cycle il suffit de presser une 5ème fois le bouton RA1 pour recommencer le cycle. Lorsque vous pressez 4 fois le bouton RA1 la led RA3 s’allumera.

Historiques

05/01/2021
– Modification ligne de programmation PORTA et PORTB surpprimer dans initialisation du PIC (bug) + modification chariot.

02/01/2021
-1er mise à disposition

Dernière mise à jour le 30/12/2020

Présentation

Dans ce présent article, nous allons aborder la programmation d’un PIC18F4550 afin de pouvoir communiquer en I2C pour lire ou écrire sur une EEPROM 24C08 (cette d’ailleurs celle qui est livrée sur la platine EasyPic V7).
EEPROM est l’abréviation de Mémoire morte programmable effaçable électriquement. Il s’agit généralement d’une mémoire de stockage secondaire dans les appareils contenant des données qui sont conservées même si l’appareil perd son alimentation. En raison de la capacité de modifier des octets de données uniques, les dispositifs EEPROM sont utilisés pour stocker les préférences personnelles et les données de configuration dans un large éventail d’applications grand public, automobiles, de télécommunications, médicales, industrielles et PC. L’EEPROM série qui utilise l’interface de communication I2C dispose de 1024 octets de mémoire disponible. L’EEPROM prend en charge les opérations d’écriture et de lecture sur un octet ou sur 16 octets (page). Le débit de données est de 400 kHz pour les alimentations 3,3 V et 5 V.

Comme évoqué j’utilise le PIC18F4550 or, J’ai bien peur que vous me posiez la question du genre:

– “Pourquoi le faire un PIC18F4550 sachant que nous avons le 18F45K22 qui lui est aussi livré avec la platine ?“

je vous répondrais :

– “Oui vous avez raison!“

Or à ce jour j’ai oublié de le récupérer et je me suis retrouvé avec le PIC18F4550 au lieu du PIC18F45K22 de connecté sur ma platine …

Soft_I2C Logiciel (Software) ou I2C Matériel (Hardware) ?

Bonne question? mais qu’est ce que cela veux bien dire ?
Pour faire simple:

I2C Logiciel (Software) : Lorsque nous parlons de I2C Logiciel c’est que votre microcontrôleur ne possède pas les broches SDA et SDL alors il faut trouver une parade afin de créer ces 2 broches pour la communication par la méthode logiciel (Software) en programmant quelques lignes de code supplémentaires. (On utilise la routine Soft_I2C de MikroC).

I2C Matériel (Hardware) : Lorsque nous parlons de I2C Matériel, c’est que votre microcontrôleur possède les broches SDA et SDL. (On utilise la routine I2C1 de MikroC)

Voilà la différence entre les deux !! pas compliquer non? avec ou sans broches SDA et SDL il est tout à fait possible de communiquer par la liaison I2C mais je vous conseille si vous devez réaliser un programme un peu plus complexe en utilisant des interruptions, vérifier le Buffer, ou autres de vous garantir que le PIC que vous utilisez soit bien équipé des broches SDA/SDL.
Bon avec tous ces grands discours essayons de regarder ça de plus prêt en commençant par des choses simples on verra ensuite le compliquer.

Schéma – 001 (Ecriture sur Add 0x00)

Sur le schéma électronique, on y retrouve notre PIC18F4550 ainsi que notre EPPROM 24C08, ces deux composants sont reliés au +5V de l’alimentation à travers des résistances PULL-UP de 1K, et les broches SDA/SCL côté microcontrôleur sont reliées vers le 24C08 afin d’assurer la liaison I2C. Comme vous pouvez le constater, nul besoin d’utiliser la façon Logiciel (Software) car le 18F4550 a bien une liaison I2C matériel (Hardware) – voir plus haut la différence entre les 2 pour ceux qui auraient manqués

Programmation materiel – MikroC

const c24C08B_Write = 0xA0; // correspond à l'adresse EEPROM pour ecriture
const c24C08B_Read = 0xA1;  // correspond à l'adresse EEPROM pour lecture

void Ecriture_EEPROM()
{
  I2C1_Start();           // Bit de start I2C
  I2C1_Wr(c24C08B_Write); // adresse EEPROM pour ecriture;
  I2C1_Wr(0x00);          // Ecriture sur le registre (adresse = 0x00)
  I2C1_Wr(0x01);          // Ecriture de la valeur 0x01
  I2C1_Stop();            // Bit de stop I2C
}

void Lecture_EEPROM()
{

  I2C1_Start();            // Bit de start I2C
  I2C1_Wr(c24C08B_Write);  // adresse EEPROM pour ecriture
  I2C1_Wr(0x00);           // Ecriture du registre à l'adresse 0x00
  I2C1_Repeated_Start();   // On répète le bit de start pour lancer la lecture
  I2C1_Wr(c24C08B_Read);   // adresse EEPROM pour lecture
  PORTD = I2C1_Rd(0);      // Lecture de l'adresse
  I2C1_Stop();             // Bit de stop I2C
}

void init()
{
  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  ADON_bit = 0;        // On désactive le module de convertion analogique/numérique

  TRISD = 0x00;        // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;
  
  I2C1_Init(100000);   // Initialisation à 100Khz
  
  Delay_ms(500);       // On attend un peu la fin de l'initialisation
}

void main()
{
  init();

  while (1)
  {
    Ecriture_EEPROM(); // Ecriture dans l'EEPROM
    Delay_ms(1000);
    Lecture_EEPROM();  // Lecture de l'EEPROM
    Delay_ms(1000);
    PORTD = 0x00;      // On efface la lecture

  }
}

Ce code peut être copié et collé dans votre IDE. Pour ma part j’utilise MikroC de MikroElectronika, étant donné que je développe en C++ je me suis mis aussi à developpé en C afin de faire le duo C/C++ mais bien enttendu vous pouvez faire de même en MikroPascal.

Fonctionnement
Avant toute choses, assurez vous que sur le PIC18F4550 vous avez bien dans l’onglet “Project” – “Edit Project”, sélectionné dans “96Mhz PLL Prescaler” Divide by 2 (8Mhz input) car sur la platine EasyPic V7 un quartz de 8Mhz est en entrée, puis ne pas oublier de mettre le cavalier J19 sur MCLR ou bien laisser le cavalier J19 MCLR en position I/O mais par contre désactiver toujours dans “Edit – Project” vous rendre dans “Master Clear Enable” en selectionnant MCLR Disabled,RE3 Enabled.

j’ouvre une parenthèse, (vous aviez raison de me dire d’utiliser le PIC18F45K22 car j’étais dans l’obligation de créer des ponts avec des fils connecteurs entre RB0 et RC4 puis RB1 et RC3…) bon je la referme :-).

Si maintenant vous décidez de compiler le programme et de l’injecter dans le PIC18F4550 vous verrez que ce montage ne fais que de faire clignoter la led RD0.

Pour le programme je vous laisse le lire afin que vous puissiez bien comprendre comment celui-ci fonctionne (voir détails de chaque lignes)

Schéma – 002 (Ecriture sur Add 0x00 + Add 0x01 du registre)

Nous gardons toujours le même schéma, cependant nous allons cette fois-ci voir comment écrire sur 2 adresses différentes (Add 0x00 et Add 0x01). Regardons ensemble le programme ci-dessous:

Programmation materiel – MikroC

  I2C1_Start();            // Bit de start I2C
  I2C1_Wr(c24C08B_Write);  // adresse EEPROM pour ecriture
  I2C1_Wr(0x01);           // Ecriture du registre (adresse 0x01)
  I2C1_Repeated_Start();   // On répète le bit start pour la lecture
  I2C1_Wr(c24C08B_Read);   // adresse EEPROM pour lecture
  PORTD = I2C1_Rd(0);      // Lecture de l'adresse
  I2C1_Stop();             // Bit de stop I2C
}

void init()
{
  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  ADON_bit = 0; // On désactive le module de convertion analogique/numérique

  TRISD = 0x00;      // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;
  
  I2C1_Init(100000); // Initialisation à 100Khz
  
  Delay_ms(500);     // On attend un peu la fin de l'initialisation
}

void main()
{
  init();

  while (1)
  {
    Ecriture_Add_0_EEPROM();  // Ecriture sur Add 0x00
    Delay_ms(100);            // On attend un peu la fin d'écriture
    Ecriture_Add_1_EEPROM();  // Ecriture sur Add 0x01
    Delay_ms(100);            // On attend un peu la fin d'écriture
    Lecture_Add_0_EEPROM();   // Lecture Add 0x00 -> Valeur 0x0F
    Delay_ms(1000);
    Lecture_Add_1_EEPROM();   // Lecture Add 0x01 -> Valeur 0xF0;
    Delay_ms(1000);
    PORTD = 0x00;             // On efface la lecture

  }
}

Ce code quant à lui fait clignoter 4 leds un coup RD0 à RD3 et un coup RD4 à RD7 tout simplement.

Test sur platine EasyPicV7

Différentes photos ou vous verrez le fameux pont sur les broches RB0 et RC4 puis RB1 et RC3, le principale c’est que le montage fonctionne on verra la finition plus tard !

Programmation logiciel – MikroC

Nous avons vue précédemment une programmation lorsque SDA/SCL est présent sur le microcontrôleur. Et vous savez quoi? même si le PIC18F4550 est doté côté materiel de broches SDA/SCL je vais quand même vous faire une démonstration version logiciel (Software) en utilisant la routine “Soft_I2C” afin que si un jour le PIC que vous utilisé ne comporte pas les broches SDA/SCL, que vous puissiez réaliser une liaison I2C. Tiens d’ailleur vous allez me demander si on peut doubler la liaison I2C? la réponse ? je pense que oui mais je n’ai jamais essayé à vrai dire… peut-être .. un jour…

Ce que je vous propose, c’est de regarder la programmation qui va suivre, alors allons voir ça de plus prêt!

Schéma – 001 (Ecriture sur Add 0x00) – Modification pour programmation Logiciel

Nous allons changer les broches de communication et nous allons prendre … Heu.. allez prenons RA1 et RA2 pour réaliser SCL/SDA. niveau montage cela donne ceci:


Jusqu’à ici rien de bien compliqué nous avons juste changé le câblage en faisant la connexion sur RA1 et RA2 (sans oublier bien sur de faire ce fameux pont de RA1 à RC3 puis RA2 à RC4 sur votre platine EasyPic V7 comme montré précédemment en photo….. et oui! il ne faut pas l’oublier 😉 Regardons côté logiciel ce qu’il change.

Programmation logiciel – MikroC

}

Le fonctionnement est identique au Schéma – 001 (Ecriture sur Add 0x00) – je vous laisse relire ce paragraphe pour plus d’explication

Schéma – 002 (Ecriture sur Add 0x00 + Add 0x01 du registre) – Modification pour programmation Logiciel

Programmation logiciel – MikroC

Pour finir sur le 2ème exemple côté logiciel, le fonctionnement est identique je vous laisse voir le détails au niveau du Schéma – 002 (Ecriture sur Add 0x00 + Add 0x01 du registre). Par contre regardons les changements niveau programmation côté Logiciel (Software)

  Soft_I2C_Start();              // Bit de start I2C
  Soft_I2C_Write(c24C08B_Write); // adresse EEPROM pour ecriture
  Soft_I2C_Write(0x01);          // Ecriture du registre (adresse 0x01)
  Soft_I2C_Start();              // On répète le bit start pour la lecture
  Soft_I2C_Write(c24C08B_Read);  // adresse EEPROM pour lecture
  PORTD = Soft_I2C_Read(0);      // Lecture de l'adresse
  Soft_I2C_Stop();               // Bit de stop I2C
}

void init()
{
  // On configure de toutes les broches en digital (numérique 0 ou 1)
  PCFG0_bit = 1;
  PCFG1_bit = 1;
  PCFG2_bit = 1;
  PCFG3_bit = 1;

  ADON_bit = 0;       // On désactive le module de convertion analogique/numérique

  TRISD = 0x00;       // Configuration PORTD en sortie pour la lecture
  PORTD = 0x00;
  LATD = 0x00;
  
  Soft_I2C_Init();   // Initialisation
  
  Delay_ms(500);     // On attend un peu la fin de l'initialisation
}

void main()
{
  init();

  while (1)
  {
    Ecriture_Add_0_EEPROM();  // Ecriture sur Add 0x00
    Delay_ms(100);            // On attend un peu la fin d'écriture
    Ecriture_Add_1_EEPROM();  // Ecriture sur Add 0x01
    Delay_ms(100);            // On attend un peu la fin d'écriture
    Lecture_Add_0_EEPROM();   // Lecture Add 0x00 -> Valeur 0x0F
    Delay_ms(1000);
    Lecture_Add_1_EEPROM();   // Lecture Add 0x01 -> Valeur 0xF0;
    Delay_ms(1000);
    PORTD = 0x00;             // On efface la lecture

  }
}

Si vous copié collé ce code vous derviez aussi voir les 4 leds clignoter un coup RD0 à RD3 et un coup RD4 à RD7 comme le code précédemment.

Test sur platine EasyPicV7

Est-ce bien la peine de reprendre les mêmes photos ? le fonctionnement est identique, par contre les connexions quant à elles sont différents bien faire le pont de RA1 à RC3 puis RA2 à RC4

Historiques

30/12/2020
-1er mise à disposition