Raspberry PI PICO EEPROM

 Essai d'une EEPROM, en fait c'est une partie de la mémoire flash, qui sert de mémoire.

Voici le programme :

#include "fct_str.h"

#include <EEPROM.h>

char buffer[100];

char valeur0;

char valeur1;

void setup() {

  Serial.begin(9600);

  pinMode(LED_BUILTIN, OUTPUT);

  EEPROM.begin(512);

}

void setup1() {

}

void loop() {

  if (Serial.available() > 0) {

    int rlen = Serial.readBytesUntil('\n', buffer, 99);

    if(strcmp_auto_detection ( buffer, "e")==0){//efface

      Serial.println("EFFACE");

      for (int i = 0; i < 512; i++) {

        EEPROM.write(i, 0);

      }

      EEPROM.commit();

    }

    if(strcmp_auto_detection ( buffer, "w0")==0){//ecrit

      Serial.println("ECRIT 11 22");

      EEPROM.write(0, 11);

      EEPROM.write(1, 22);

      EEPROM.commit();

    }

    if(strcmp_auto_detection ( buffer, "w1")==0){//ecrit

      Serial.println("ECRIT 33 44");

      EEPROM.write(0, 33);

      EEPROM.write(1, 44);

      EEPROM.commit();

    }

    if(strcmp_auto_detection ( buffer, "r")==0){//lit

      Serial.println("LIT");

      valeur0 = EEPROM.read(0);

      valeur1 = EEPROM.read(1);

      sprintf(buffer, "%d;%d", valeur0,valeur1);

      Serial.println(buffer);

    }

  }

}

void loop1() {

  delay(100);

  digitalWrite(LED_BUILTIN, HIGH);

  delay(100);

  digitalWrite(LED_BUILTIN, LOW);

}

Du coup, 4 commandes :
-"e" pour effacer la zone.
-"w0" pour écrire 11 et 22.
-"w1" pour écrire 33 et 44.

-"r" pour lire.

J'ai fait le test, cela me semble normal, j'ai une sauvegarde même si on coupe le courant.

Raspberry PI PICO I2C avec TMP275 et SAA1064

 Le SAA1064 est le premier circuit que j'ai utilisé, dans la fin des années 90, à la SACEP, on a eu un retour de matériel déjà utilisé, de cartes contenant une grande quantité de ce circuit, qui était utilisé pour de l'affichage sur LED.
A l'époque j'utilisai des composant du type SX18, SX28 et SX52 de chez Scenix/Ubicom.
Ceux-là n'avaient pas la sortie I2C, elle était émulée en assembleur.
A l'époque c'était déjà une grande évolution d'avoir des développements directs. La norme était avec émulateur, puis écriture sur une UVPROM.
Le circuit utilisé est un reste de cette époque.

Le défaut de cette carte, est qu'il est compatible 5V, et non pas au 3.3V, cela ne semble pas empêché son fonctionnent, ici il est branché sur le 5V mais les résistances de pull up sont au 3.3V.

Voici le code utilisé, il permet de retranscrire la température sur le SAA1064.

Il ne permet que l'affichage de la température entre -9.99°C et 99.99°C, ce n'est qu'un exemple.

#include <Wire.h>//équivalent I2C

int data1;

int data2;

char buffer[100];

float temperature;

static const char ASII_digit[10]{

  0b11110101,//0

  0b00000101,//1

  0b10110011,//2

  0b10010111,//3

  0b01000111,//4

  0b11010110,//5

  0b11110110,//6

  0b10000101,//7

  0b11110111,//8

  0b11010111,//9

};

void setup() {

  Serial.begin(9600);

  pinMode(LED_BUILTIN, OUTPUT);

  Wire.begin();

  //test TMP275

  //configuration 12 bits au lieux de 9 bits

  Wire.beginTransmission(0x4F);

  Wire.write(0b00000001);

  Wire.write(0b01100000);    

  Wire.endTransmission();

  //mise sur la liste de lecture

  Wire.beginTransmission(0x4F);

  Wire.write(0b00000000);    

  Wire.endTransmission();

}

void setup1(){}

void loop() {

  //test TMP275

  Wire.requestFrom(0x4F, 2);

  data1 = Wire.read();

  data2 = Wire.read();

  temperature = ((data1 << 4) + (data2 >> 4)) * 0.0625;

  sprintf(buffer, "data1=%02X data2=%02X valeur=%03X temperature=%f°C",data1,data2,(data1 << 4) + (data2 >> 4) , temperature);

  Serial.println(buffer);

  //test SAA1064

  sprintf(buffer, "%02.2f", temperature);

  Wire.beginTransmission(0x38);

  Wire.write(0b00000000);

  Wire.write(0b01110111);

  Wire.write(ASII_digit[buffer[4]-'0']);//1

  Wire.write(ASII_digit[buffer[3]-'0']);//2

  Wire.write((ASII_digit[buffer[1]-'0']) | (0b00001000));//3

  Wire.write(ASII_digit[buffer[0]-'0']);//4

  Wire.endTransmission();

  delay(400);  

}

void loop1() {

  digitalWrite(LED_BUILTIN, HIGH);

  delay(100);

  digitalWrite(LED_BUILTIN, LOW);

  delay(100);

}

Le tableau "ASII_digit", permet de faire la conversion ASCII vers les LEDS piloté par le SAA1064.

Le texte en imprimé avec la directive "%02.2f" cela oblige 2 chiffres devant et derrière la virgule.
La commande "Wire.write((ASII_digit[buffer[1]-'0']) | (0b00001000));//3", fait mettre une virgule.

Raspberry PI PICO I2C

Voici l'essai de la communication en I2C.

Pour cela j'utilise une sonde de température TMP275, que j'utilise déjà pour ma domotique.

Montage électrique :

Programme :

Essai avec les doigts dessus la sonde.

Pas de problèmes.

Raspberry PI PICO test analogique entrée

 Test des entrées analogiques.

Montage :

Le programme :

On a un changement quand on passe de 0V à 3.3V.

La mesure est à un delta de 21 unités pour une mesure à mis course, à l’environ de 500, avec un condensateur de 10µF.

Pas de problèmes, c'est juste évidant.

Raspberry PI PICO test FT800 et écran

 Cette fois, test avec un FT800(coprocesseur graphique) et un écran de 5 pouces.

Le FT800, c'est un processeur vidéo et tactile de chez FTDI, il permet de convertir des images avec des zoom, application d'angles etc.

Le codes l'origine a été fait à partir des codes donnés par FTDI, par contre ils n'étaient pas réellement compatibles.

Par exemple, sur le PIC18, en langage C, les "int" doivent être sur 32 bits, or ils ne sont que de 16+ bits aux lieus des "int" j'ai dû utiliser des "long" qui sont en 32 bits.

Ensuite j'ai passé le code sur FPGA, le processeur avait bien de "int" en 32 bits, cependant j'ai laissé le code identique et ajouté des fonctions avec des "int".

Il m'a fallu un temps de plusieurs jours pour remettre en forme toutes les fonctions et séparer les essais du code fonctionnel.

Montage :

Le programme :

Résultat :

Raspberry PI PICO W test WIFI

 J'ai acheté un Raspberry PI PICO W, le module qui fait le WIFI.

Voilà le programme en fonctionnement.

Un programme qui permet de faire une liaison UDP (User Datagram Protocol).

Envoi de données vers le module à l'aide de YAT et réponse par "acknowledged" par le module.

Il me semble qu'il n'y a aucun problème.

Raspberry PI PICO test SDC

 Test connexion SDC, pour ce test j'ai des adaptateurs pour du 5V, le Raspberry est compatible 3.3V, je préfère valider les adaptateurs sur un module compatible, un Aduino Leonardo.

Module sans modifications.

Après une multitude d'essais, je me suis rendu compte que le branchement n'était pas sur les pins marqué 11, 12 et 13.

Du moins, sur le connecteur "ICSP", que le marquage est trompeur.

Programme, semble fonctionnel d'après le monitoring.

On passe au test sur Raspberry PI PICO

Platine de test.

J'ai dû faire la modification des adaptations de niveau, donc suppression du régulateur et du circuit intégré, et court-circuit pour laisser les tensions passées.

Module modifier.

Programme, semble fonctionnel d'après le monitoring.

Raspberry PI PICO test serial

 Petit test des ports séries, on a 3 ports séries. Un pour le monitoring (USB) et 2 autres pour sur les broches.

Ici, j'ai utilisé les 2 cœurs, c'est les fonctions "void loop()" et "void loop1()"

"void loop()" contient la gestion du port série :

  - "AAA" qui allume une LED, celle en D14 et éteins l'autre en D15.

  - "BBB" qui qui fait l'inverse.

  - "outled" qui inverse l'état des LED.

"void loop1()" contient le fonctionnement de la LED de dessus du Raspberry PI PICO, avec un temps de 2s entre chaque état. 

J'ai mis une convertisseur USB vers port série et 2 LED.

Copie d'écran de YAT, en bleu les commandes envoyer et en rouge les réponses.

Vidéo du résultat :

On voit la LED du Raspberry clignoté. 

La LED rouge allumé, puis les 2 LED éteinte, la LED rouge allumé, la verte allumé, les 2 LED allumés.

Raspberry PI PICO : tests LED

 Petit passage par "Visual Studio Code".

C'est une application gratuite de chez Microsoft, ce n'est pas souvent que je les vois faire quelque chose de gratuit.

Je code l'exemple de l'article , l'entré de "debug" fonctionnait, par contre pour la diffusion elle ne marche plus depuis que j'ai voulus faire un téléchargement direct avec le driver décrit sur cette page.

En effet, si l'on veut faire un téléchargement direct après compilation, cela n'est pas directement possible.

Comme prévu, la LED en face avant clignote.

Petit passage vers "Aduino".

Fonctionnement identique.

Par contre on peut faire un téléchargement a volonté sans faire de manipulation sur le Raspberry PI PICO et on a directement un monitoring série par le port USB.

Par contre, sur la version 2 de ce programme, par rapport à la version 1, c'est que l'on n'a pas forcément une bonne compilation et les erreurs ne sont pas forcément claire. 

La reconnaissance des fichiers n'est pas forcement bonne. J'ai dû chercher longtemps pour comprendre que le .c d'un programme qui tournait sur FPGA ne marchait pas car il n'était pas en .cpp.

La suppression des fichiers ne fonctionne pas non plus. Je crois que c'est une modification en cours.

Conclusion :

J'utiliserai le Arduino, le "Visual Studio Code" ne fait que copier le code en Arduino, avec des problèmes.

Raspberry Pi Pico

 Je fais l'acquisition de Raspberry Pi Pico.

Cette carte a microcontrôleur RP2040, Processeur double cœur Arm Cortex M0+, horloge flexible fonctionnant jusqu'à 133 MHz.

264 Ko de SRAM et 2 Mo de mémoire flash intégrée. Pour ce prix, c'est très rare.

2 × SPI, 2 × I2C, 2 × UART, 3 × ADC 12 bits, 16 × canaux PWM contrôlables.

Bibliothèques à virgule flottante accélérées sur puce.

Je peux le programmer avec Arduino IDE ou Visual Studio Code.

Les valeurs en "int", en C++, sont directement en 32 bits, et non pas en 16 bits. Il peut également utiliser directement des valeurs en "float"

Je n'ai pas besoin de programmateur, il suffit de mettre le fichier comme si c'était une carte mémoire.

Le fait d'avoir 2 cœurs me permettra d'utiliser 2 processus en même temps.