Bilan de 2017

Bonjour à toutes et à tous !

Nous sommes déjà au mois de février et par conséquent bien trop tard pour vous souhaiter la bonne année. Une année qui a commencé relativement bien et que j’espère plus stable que l’année précédente.

Sans en dire trop, il y a un an j’étais embauché dans une autre entreprise après une expérience assez traumatisante (dont je parlerai peut-être un jour ici). Un nouveau boulot donc, dans une nouvelle entreprise, loin d’être parfaite mais légèrement mieux que ce que j’ai pu vivre avant. J’y suis resté 8 mois, une période que je voyais comme étant de transition mais où j’ai pu apprendre beaucoup et m’épanouir en tant que développeur.

Fin septembre, j’ai dû déménager et quitter mon boulot pour suivre ma compagne dans une autre région. Finie la région parisienne, même si j’avais déjà réussi à m’extraire de la routine oppressante des transports parisiens ! Et par chance, j’ai pu décrocher un nouvel emploi assez rapidement (j’ai passé des entretiens pendant le mois de septembre, pour être finalement embauché début octobre). Je dois dire que c’est un cadre qui me plaît : une entreprise suffisamment grande pour être mâture mais assez modeste pour ne pas s’y sentir oppressé par un côté « grand groupe ». L’entente avec mes collègues est très bonne, j’y trouve pas mal de geeks, pour mon plus grand bonheur. Le travail que l’on me donne est intéressant et tout est bien organisé. Que demander de plus ? J’espère bien pouvoir y rester le plus longtemps possible, quitte à faire des choix difficiles pour parvenir à cette fin.

Mais arrêtons de parler de ma vie pour nous focaliser sur l’essentiel ici : ce blog. Je suis assez content du travail que j’ai pu fournir durant l’année 2017, même si j’aurais aimé pouvoir écrire davantage. Le projet de programmateur de PIC est bien avancé, malgré le problème d’écriture qui me résiste. Concernant ce dernier point, tant qu’il n’est pas résolu, je ne peux écrire davantage sur ce projet. Toutefois, histoire de ne pas laisser le blog en reste, je projette d’aborder à la place d’autres projets en cours, dont au moins un à base de Raspberry Pi ou d’autres cartes collectées ça et là.

Sur ce, je vous laisse et je vous dis à bientôt.

Nicolas SAN AGUSTIN

Programmateur de PIC – Lecture

Bonjour à toutes et à tous !

Cela fait quelques mois que j’essaye d’écrire un nouvel article mais quelques difficultés n’ont pas joué en ma faveur. Notamment le fait que j’ai longtemps bataillé avec mon programmateur de PIC pour obtenir des résultats présentables. Malgré tout, je suis content de pouvoir enfin présenter la suite du projet, même s’il ne s’agit pas des fonctionnalités que j’espérais.

En effet, j’ai désespérément tenté d’écrire un programme sur le PIC depuis mon Arduino, toujours sans succès (pour l’instant). Je me suis donc orienté plutôt vers la lecture, une décision en grande partie motivée par la lassitude de devoir sans cesse brancher et débrancher l’Arduino ou mon programmateur me permettant de lire la mémoire du PIC (parce que ce serait trop simple de pouvoir avoir tout branché en même temps !).

Principe

La méthode de lecture de la mémoire est la même pour tous les blocs mémoire, excepté pour la mémoire EEPROM, et s’avère assez simple. Elle consiste simplement à affecter l’adresse de l’octet que l’on souhaite lire et à envoyer une commande du type « Table Read » pour démarrer la lecture. Contrairement aux commandes que l’on envoyait pour l’effacement, il faut procéder ainsi :

  1. Envoyer une instruction sur 4 bits (par exemple « 1001 » pour « Table Read, Post-Increment » pour ne pas avoir à réaffecter l’adresse pour lire l’octet suivant) ;
  2. Placer la broche de données (PGD) à l’état bas et envoyer 8 oscillations d’horloge (PGC), ce qui équivaut à l’envoi d’un octet avec une valeur nulle (0) ;
  3. Changer l’orientation de la broche de données : PGD est maintenant une entrée ;
  4. Générer un cycle d’horloge pour la lecture de chaque bit de données ;
  5. Une fois l’octet lu, reconfigurer la broche de données en tant que sortie.

Il suffit de procéder ainsi pour chaque octet que l’on souhaite lire. Pour rappel, l’adressage mémoire pour le PIC18F2550 est :

  • Code exécutable : 0x00000 à 0x007FFF ;
  • ID locations : 0x200000 à 0x200007 ;
  • Registres de configuration : 0x300000 à 0x30000D ;
  • Identifiant du périphérique (Device ID) : 0x3FFFFE et 0x3FFFFF.

Mise en pratique

En terme de code, cela donne à peu près ça :

/*
 * Send a command to the chip on 8 bits (plus 8 bits to receive)
 */
char receive(char command)
{
    int i;
    char read = 0x00;
    boolean bit;

    /* Command */
    for (i = 0; i < 4; i++)
    {
        if ((command & 1) == 1)
        {
            digitalWrite(PGD, HIGH);
        }
        else
        {
            digitalWrite(PGD, LOW);
        }
        digitalWrite(PGC, HIGH);
        digitalWrite(PGC, LOW);
        command = command >> 1;
    }

    /* None Byte */
    digitalWrite(PGD, LOW);
    for (i = 0; i < 8; i++)
    {
        digitalWrite(PGC, HIGH);
        digitalWrite(PGC, LOW);
    }

    pinMode(PGD, INPUT);

    /* Byte to receive */
    for (i = 0; i < 8; i++)
    {
        digitalWrite(PGC, HIGH);
        bit = LOW;
        bit = digitalRead(PGD);
        if (bit == HIGH)
        {
            read |= (1 << i);
        }
        else
        {
            read &= ~(1 << i);
        }
        digitalWrite(PGC, LOW);
    }

    pinMode(PGD, OUTPUT);
    digitalWrite(PGC, LOW);

    return read;
}

/*
 * Read a byte in the memory
 */
char read_byte(unsigned long address)
{
    /* MOVLW <Addr[21:16]> */
    send(CORE_INSTRUCTION, (char) ((address >> 16) & 0x000000FF), 0x0E);
    /* MOVWF TBLPTRU */
    send(CORE_INSTRUCTION, 0xF8, 0x6E);
    /* MOVLW <Addr[15:8]> */
    send(CORE_INSTRUCTION, (char) ((address >> 8) & 0x000000FF), 0x0E);
    /* MOVWF TBLPTRH */
    send(CORE_INSTRUCTION, 0xF7, 0x6E);
    /* MOVLW <Addr[7:0]> */
    send(CORE_INSTRUCTION, (char) (address & 0x000000FF), 0x0E);
    /* MOVWF TBLPTRL */
    send(CORE_INSTRUCTION, 0xF6, 0x6E);

    return receive(TABLE_READ_POST_INC);
}

Note : la procédure send qui est appelée est en fait send_command, que nous avons abordé dans l’article sur l’effacement. Je trouve plus propre d’avoir des fonctions se nommant simplement send et receive.

Conclusion

Je sais, c’est assez court comme article après quatre mois d’absence. Il faut dire que cette fonctionnalité est assez simple à mettre en œuvre et que les précédents articles étaient longs essentiellement à cause de tous les détails qu’il fallait aborder en guise d’introduction. Une fois ces principes élémentaires assimilés, le reste devient plus simple.

Je regrette de ne pas avoir encore pu obtenir d’écriture fonctionnelle. Je persévère quand même et j’espère parvenir assez vite à des résultats encourageants. Pour ne pas laisser le site en plan trop longtemps, je prévois d’écrire des articles sur d’autres sujets (sur le Raspberry Pi, notamment), et je ne doute pas qu’ils pourront vous intéresser.

Sur ce je vous laisse et vous dis à bientôt.

Nicolas SAN AGUSTIN

Copyright Nicolas SAN AGUSTIN 2020
Tech Nerd theme designed by Siteturner