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

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

Présentation

Dans cet article, nous allons étudier le fonctionnement du debugger I2C de proteus, et nous ferons des essais sur un expender de ports 8 bits type PCF8574A ainsi qu’un essais sur une EEPROM 24C08B livrée sur la platine EasyPicV7.
Ces 2 composants fonctionne sous le protocole I2C, et nous pouvons dire aussi que d’une manière générale la lecture et l’écriture sur des EEPROMs est réalisé en I2C. Nous verrons comment on pilote ces 2 composants via leurs adresses, comment écrire dans leurs registres (adresse interne) pour stocker ces valeurs.
Une EEPPROM permet de stocker non pas des logiciels mais des données et il s’agit d’une mémoire non volatile, c’est-à-dire que cette mémoire s’efface électriquement (par logiciel ou reprogrammation) et non pas sur une coupure générale de l’alimentation et c’est bien tout son avantage , car elle garde en mémoire les données enregistrées. On l’utilise dans des appareils photos, dans des voitures, etc..etc…
Le faite de stocker des données, celle-ci sont accessibles via l’EPPROM.

Présentation debugger I2C Proteus (ISIS)

Nous allons étudier le fonctionnement du débugger I2C de Proteus afin de savoir comment l’utiliser pour simuler des montages électroniques.
Tout d’abord, il est représenté sous cette forme et comporte 3 pattes qui sont :

SDA = La broche SDA est une ligne de données bidirectionnelle pour le bus I2C.
SCL = La broche SCL est une broche bidirectionnelle qui est connectée à la ligne d’horloge du bus I2C.
TRIG = La broche TRIG est une entrée qui entraîne le placement des séquences mémorisées successives dans la file d’attente de sortie. (Nous nous attarderons pas sur cette broche dans l’explication).

Le bus I2C, utilise une transmission de données sur 11 bits qui comprend :

Au total nous avons bien nos 11 bits consécutifs.

Remarques : il est possible d’envoyer des données sur 10 bits plutôt que 7 bits et cela ne change rien aux principes de fonctionnement. (Nous verrons aussi ces différents cas un peu plus loin).

Le debugger I2C permet de faciliter grandement nos montages choses afin de pouvoir tester nos montages électronique via la liaison I2C en peu de temps !

ATTENTION !! Avant toute chose, il est fortement conseillé de configurer toutes les résistances  en mode « DIGITAL » et d’utiliser l’alimentation « POWER » cas contraire le montage en simulation ne fonctionnera pas comme attendu !

Le principe de fonctionnement I2C est le suivant ou nous avons :

1 bit de start
Le bit start lui permet de donner le départ en disant « attention à tous des données sont envoyées sur la trame I2C ». Il commence par la lettre « S ».

7 bits de données
Ensuite nous avons les 7 bits de données avec le bit de poids faible (bit 0) qui correspond soit à la lecture représenté par R = Read (état haut) ou en écriture représenté par W = Write (état bas). Ceci est très important car en fonction si nous sommes lecture ou en écriture nous allons écrire sur l’esclave ou bien lire les données de l’esclave (nous verrons tous ceci un peu plus loin).

1 bit d’acquittement (ACK)
Ce bit est généré automatiquement via l’appareil. ces  données sont séparé par la lettre « N » via le debugger I2C.

1 bit de stop
Ce dernier bit quant à lui précise qu’il s’agit la fin de transmission des données et il se termine par la lettre « P ».

Comment ça marche ?!

Avant toute chose il faut déjà avoir bien le protocole en tête et voir comment les données sont envoyées sur le bus I2C. Reprenons la figure ci-dessus, les 2 lignes correspondent aux 2 fils – SDA et SCL (L’horloge).

SCL est l’horloge représenté par des rectangles noirs, la fréquence peut varier en fonction des composants électroniques. En effet certains peuvent fonctionne sur 100Khz ou bien d’autre sur 400Khz. Le fonctionnement ne change pas c’est juste la vitesse de transmission qui va plus ou moins vite !

SDA ce sont les données qui seront transmisses sur le BUS I2C sur chaque coups d’horloges. C’est l’horloge qui va cadencer les fronts montant pour l’envoie des données I2C.

Bit de start (en bleu)
La couleur bleu correspond au bit de start, à ce moment l’horloge retombe à l’état logique bas « 0 » pour commencer à cadencé les données

Adresse
Le protocole I2C, a une particularité, car les 9 premiers bits correspondent à l’adresse, et ensuite va suivre les données. Le premier « paquet » correspond à l’adresse physique du composants avec lequel nous désirons communiquer / dialoguer soit en écriture soit en lecture.

Sur les 7 bits (bit 0 à bit 7), si nous désirons écrire sur ce composant, dans ce cas le bit représenté de couleur verte qui correspond au bit de poids le plus faible (bit 0) sera à l’état logique bas « 0 », et en mode lecture il sera à l’état logique haut « 1 ».

Ensuite (bit 1 à bit 7) nous écrivons l’adresse du composants sur lequel nous désirons réaliser quelque chose (Lecture/Ecriture). Et pour finir, derrière s’enchaîne un bit d’acquittement (couleur orange) qui lui est généré automatiquement. Ce bit d’acquittement peut ou ne peut être généré la encore une fois tout dépend du matériel utilisé (on le verra dans l’exemple 1 qui va suivre).

Données
Nous écrivons les données

Bit de stop
Fin de l’envoie de la trame I2C sur le composant.Bon arrêtons les explications et passons à la pratique !!!

Exemple 1 – PCF8574A – Mode Ecriture

Dans cet exemple nous allons utiliser le PCF8574A qui est un expender de port 8 bits.Le principe est le suivant, nous allons lui envoyer des trames I2C sur ses broches SDA et SCL afin de pouvoir allumer les 8 leds qui refléteront les données envoyées sur le BUS I2C. Nous verrons en détails le principe.

1 – Analyse du composant PCF8574A + réglage fréquence debugger I2C
Le PCF8574A peut être alimenté entre 2.5V et 6V maxi, et nous l’alimenterons en 5V. La fréquence d’utilisation pour le PCF8574A est de 100Khz maxi.
Ainsi nous pouvons désormais commencer à configurer le debugger I2C sur 100Khz soit 100000 Hz comme ceci :

2 – Réglage adresse du composant PCF8574A
Comme nous l’avons vu précédemment, pour pouvoir communiquer avec le PCF8574A, il faut connaître son adresse. C’est comme dans la réalité lorsque le facteur veut vous envoyer du courrier il lui faut votre adresse.

La fiche technique du PCF8574A indique ceci :

J’ai décidé de choisir la 1er ligne, ou le constructeur stipule qui les broches A0/A1/A2 doivent être reliées à la masse. Dans cette configuration, j’ai décidé de régler arbitrairement l’adresse sur 0111000 ce qui donne 38h en hexadécimal, c’est cette adresse que nous recherchons du PCF8574A (comme vous pouvez le constater on retrouve en hexadécimal 38h à l’extrémité du tableau ci-dessus.)
– En mode lecture l’envoi sera de 01110001 ce qui donne 71h en hexadécimal;
– En mode écriture l’envoi sera de 01110000 ce qui donne 70h en hexadécimal;
(Même chose ces valeurs sont aussi situées dans le tableau du constructeur du PCF8574A)

Avant d’aller plus loin commençons par réaliser le schéma électronique :

En ce qui concerne l’alimentation du bargraph, chaque leds consomme environ 10mA pour une tension directe de 1,8V la résistance à ajouter en série sera donc de R = (5 – 1,8)/0.010 = 320 Ohms. Soit 8 résistances de 330 Ohms ferons bien l’affaire !
Les résistances R1 et R2 sont obligatoires car celle-ci sont ici pour faire ce qu’on appelle le PULL-UP (résistances de tirages) sur le bus I2C. Encore une fois ces résistances peuvent varier en fonction de la fréquence utilisé (100Khz ou 400Hz ou …) et en fonction aussi de la longueur de la liaison I2C (en règle général la communication I2C se fait sur des petites longueurs, je ne rentrerais pas dans les détails sur l’explication car ce n’est pas le but de cet article).

Revenons à nos moutons ! Nous avons à présent réalisé :

1/ La configuration du debugger I2C à 100Khz.

2/ Câblé A0/A1/A2 à la masse pour obtenir l’adresse 0111000 ce qui donne 38h en hexadécimal.

3/ Calculer les valeurs des résistances R3 à R10 pour la protection des leds du baragraph.

Il ne reste plus qu’à passer sur la transmissions des données I2C et de voir ensemble en détails le bit de start , bit d’acquittement etc.. etc..

3 – Communication I2C – Maître/Esclave
Le maître correspond dans notre montage au débugger I2C c’est lui qui va être le chef d’orchestre et qui va décider si nous désirons réaliser une lecture ou une écriture. L’esclave, quant à lui concerne le PCD8574A c’est lui qui va se soumettre à ce que demande le maitre et d’exécuter les consignes du maître.

En mode écriture vous trouvez ci-dessous le protocole I2C du fonctionnement du PCF8574A.
Dans le 1er « paquet » on y retrouve l’adresse de l’esclave « slave adresse » qui celle-ci a été configurée précédemment (38h) puis le bit de poids le plus faible (bit 0 = R/W) à l’état logique bas « 0 » donc en écriture !
Lorsque l’adresse va être reconnu par l’esclave, celui-ci va générer un bit d’acquittement afin d’informer le maître comme quoi l’adresse reçu correspond à l’esclave et qu’il est prêt à exécuter les consignes que le maitre va lui donner.
Une fois le bit d’acquittement généré par l’esclave, le maître va donc écrire afin de transmettre à l’esclave les :
data1 = données 1 concerne la 2ème « paquet »,
data2 = données 2 concerne la 3ème « paquet ».
data3 = etc.. etc..

Côté debugger ISIS regardons ça de plus prêt
La syntaxe pour écrire ce genre de protocole n’est pas du tout compliquée il suffit de respecter le principe ainsi que majuscule comme ceci :

{SEQUENCE000=S 0x70 N 0x38 N P} en HEXA

Peut s’écrire aussi:
{SEQUENCE000=S 01110000b N 00111000b N P} en BINAIRE

Il est vrai que la 2ème écriture en mode binaire permet de mieux voir les bits

Côté débugger cela donne :

Nous avons ici écrit notre première trame I2C, ne reste plus qu’à lancer proteus pour voir le comportement.

Si vous regardez bien les leds qui sont allumées correspondent aux données (Data1 figure un peu plus haute) que nous avons envoyé sous la forme 00111000b.

Nouvelle séquence avec – 01010101b
Je vais modifier l’envoi tout en gardant la même adresse avec le bit0 en écriture ce qui donne côté adresse (inchangé) 01110000b + Data1 = 01010101b et nous devrions voir une leds sur 2 allumées.

Côté debugger ISIS cela nous donne une 2ème séquences soit:

{SEQUENCE001=S 01110000b N 01010101b N P}.

Essayons ça pour voir!

Exemple 2 – PCF8574A – Mode Lecture

Nous avons vu précédemment comment écrire sur le PCF8574A, regardons maintenant comment lire les données. (revenir au paragraphe 2 – Réglage adresse du composant PCF8574A pour relire la fiche technique du constructeur pour ceux qui se retrouve directement ici)

1 – Communication I2C – Maître/Esclave

Le maître correspond dans notre montage toujours au débugger I2C ,et cette fois-ci le chef d’orchestre va interroger l’esclave en passant le bit0 à l’état logique 1 (Lecture). L’esclave, quant à lui concerne le PCD8574A c’est lui qui va donc envoyer ses données au maître.

En mode lecture vous trouvez ci-dessous le protocole I2C du fonctionnement du PCF8574A.

Dans le 1er « paquet » on y retrouve l’adresse de l’esclave « slave adresse » qui celle-ci a été configurée précédemment (38h) puis le bit de poids le plus faible (bit 0 = R/W) à l’état logique haut « 1 » donc en lecture !

Lorsque l’adresse va être reconnu par l’esclave, celui-ci va générer un bit d’acquittement afin d’informer le maître comme quoi l’adresse reçu correspond à l’esclave et qu’il est prêt à exécuter les consignes que le maitre va lui donner.

Une fois le bit d’acquittement généré par l’esclave, ce dernier va transmettre au maître ses données:

Lecture 0x05 – 0000101b

Le montage electronique consiste à mettre sur l’esclave des siwtchs qui seront manipulé afin de modifier les données. nous allons mettre les siwtchs de sorte à obtenir le chiffre 5 en hexadecimal soit 0x05 donne 00000101b (en binaire) le schéma electronique devient donc ceci:

Côté debugger, il faut donc lire les données de l’esclave PCF8574A pour cela il suffit de faire appel à son adresse et en mode lecture comme ceci, (sans oublier le bit0 à l’état logique haut “1” – {SEQUENCE002=S 01110001b N P} ainsi nous obtenons:

regardons maintenant côté simulation ce que cela nous donne

Lecture 0x07 – 0000111b
Observer bien je vais changer les switchs en les passant à 0x07 en hexa soit 0000111b

EEPROM – 24C08B (sur platine EasyPic V7) – Mode Ecriture

Sur ma platine EasyPicV7, j’ai une EEPROM type 24C08 livrée avec, et qui a la particulartié d’avoir 8K bytes de mémoire non volatile. L’alimentation du 24C08 se fait aussi sous une tension de 5V et la fréquence du BUS I2C est sous 100Khz.

Pour rappel 1 byte = 1 octet = 8 bits ce qui donne 255 en décimal de possibilité.

Pour être puriste, en définitive ce n’est pas 8K bytes exact, mais plutôt 8192 bytes car 1Kilobyte correspond à 1024 bytes ce qui donne 20 6661 120 en décimal de possibilité! (simple règle de 3 à appliquer via le petit rappel juste au dessus ;-).

Le fonctionnement est différent du PCF8574A mais le principe reste identique. En effet, le 24C08 a toujours une adresse « slave adresse » comme représenté sur la figure ci-dessous:

mais la particularité, c’est que vous pouvez écrire sur ses pages… Mais qu’est ce que cela veux bien dire ??!!
Ce qu’il faut comprendre c’est que l’EEPROM, est organisée en 4 ou 8 blocs de 256 octets soit:
(4 x 256 x 8) ou (8 x 256 x 8) c’est à dire, un octet de contrôle est le premier octet reçu après la condition de démarrage du périphérique maître. L’octet de commande consiste en un code de commande à 4 bits, pour le 24C08B, il est défini comme binaire 1010 pour les opérations de lecture et d’écriture. Les trois bits suivants de l’octet de commande sont les bits de sélection de bloc (B2, B1, B0). Ils sont utilisés par le dispositif maître pour sélectionner lequel des huit blocs de mémoire de 256 mots doit être accédé. Ces bits sont en fait les trois bits les plus significatifs de l’adresse de mot. Le dernier bit de l’octet de contrôle définit l’opération à effectuer. Lorsqu’il est réglé sur un, une opération de lecture est sélectionnée, lorsqu’il est réglé sur zéro, une opération d’écriture est sélectionnée. Suite à la condition de démarrage, le 24C08B surveille le bus SDA en vérifiant l’identifiant du type d’appareil transmis, sur un code 1010, l’appareil esclave émet un signal d’acquittement sur le Ligne SDA. En fonction de l’état du bit R / W, le 24C08B sélectionnera une opération de lecture ou d’écriture.

(Copier et coller ce code dans le debugger I2C)

Le code ci-dessous permet d’écrire sur 4 adresse différentes qui sont:
Add N°8   – 0x08 (00001000b) – Valeur = 0x01 (00000001b)
Add N°9   – 0x09 (00001001b) – Valeur = 0x02 (00000010b)
Add N°10 – 0x0A (00001010b) – Valeur = 0x03 (00000011b)
Add N°11 – 0x0B (00001011b) – Valeur = 0x04 (00000100b)

Nous avons toujours, adresse de l’esclave, adresse sur la page que nous désirons écrire, et la valeur que nous allons ajouter dans l’adresse correspondante avec le dernier bit (bit0 en rouge) à l’état logique bas ce qui nous permet d’écrire

{SEQUENCE000=S 10100000b N 00001000b N 00000001b N P}
{SEQUENCE001=S 10100000b N 00001001b N 00000010b N P}
{SEQUENCE002=S 10100000b N 00001010b N 00000011b N P}
{SEQUENCE003=S 10100000b N 00001011b N 00000100b N P}

Si on se refaire à la doc technique du constructeur et si on fait une analogie avec ce qui est indiqué ci-dessus la correspondance est identique et on remarque bien que le bit avant “ACK” (acquittement) est à l’état logique bas “0”.

Ici nous faisons rien de plus que d’écrire dans les adresses correspondantes !

EEPROM – 24C08B (sur platine EasyPic V7) – Mode Lecture

En ce qui concerne le montage électronique rien n’a changé.

cependant la seule chose qui va changée c’est la partie code du debugger I2C, et ici nous faisons que de lire les données situées dans l’EPPROM 24C08B.

Code debugger I2C complet + test
Il suffit de copier ce code dans le debugger comme ceci:

Afin de remplacer le code d’un manière “plus compact” en l’occurence celui-ci:

deviendra comme ci-dessous, ajout de “Sr” qui permet de faire un “restart” on relance tout de suite derrière par des nouvelles données

Historiques

28/12/2020
-1er mise à disposition

Dernière mise à jour le 26/12/20

Présentation

Le montage électronique qui est présent dans cet article est un générateur PWM à 26 sorties qui sont toutes indépendantes. Vous allez me demander pourquoi mettre 27 sorties ?
En effet vous avez raison, en réalité il y en a bien 26, et j’ai fait l’erreur de connecter la broche RA4 comme sortie du PORTA qui celle-ci ne fonctionne pas dans cette configuration.
Ce montage est accompagné du logiciel Interface UsbHid PWM qui celui-ci ne fonctionne que pour ce montage présenté ici via le PIC 18F4550.
Testé sur ma platine EasyPic V7, le montage fonctionne comme attendu. Son alimentation se fera via le connecteur USB disponible sur la platine EasyPic V7, ou bien je vous laisse le schéma afin que vous puissiez réaliser avec quelques composants et des pointes de soudures votre propre connecteur USB.

Schéma

Le schéma électronique cadencé via le quartz de 8Mhz et ses 26 sorties PWM.

Schéma du connecteur USB pour ceux qui désires le réaliser

Fonctionnement

Le fonctionnement est réalisé en faisant varier la tension en sorties des broches du PIC 18F4550 afin d’obtenir ce genre de tension que tous le monde connait 😉

Graph (testé sur 4 sorties)

Logiciel du PIC

Programmation uniquement en C (MikroC de MikroElectronika) Vous retrouver aussi le fichier (.hex) qui pourra être envoyé directement dans le PIC18F4550) .Ce montage a été testé entièrement sur la platine EasyPic V7): MikroC UsbHid PWM

Historiques

26/12/20
– Première mise à disposition.