Lire un fichier sd card a la place d'un fichier progmem

Bonjour
je cherche à modifier un sketch
je lit un fichier progmem:
const byte PROGMEM ROM[bytes] = {
0X00, 0XCF, 0XFF, 0X90, 0X1E, 0X37, 0XC2, 0X0C, etc......
j'écrit dans la rom avec:
for (Addr=0;Addr<bytes;Addr++) {
// Read the data to be programmed
Data=pgm_read_byte(ROM+Addr);
PORTD=(PORTD&B00000011)|(Addr<<2);
PORTB=(PORTB&B11101111)|((Addr>>2)&B00010000);
delayMicroseconds(1);
for (BitNo=Nibble;BitNo<Nibble+4;BitNo++) {
if (((Data>>BitNo)&B00000001)==1) {
// Set Data bit
PORTB=(PORTB&B11110000)|(B00000001<<(BitNo-Nibble));
comment remplacer ROM par un fichier SD type TEST.txt ??
..........................................................................................
myFile = SD.open("test_wr.txt");
Serial.write(myFile.read());
Data=pgm_read_byte(myFile+Addr); ne fonctionne pas

Lit des données en mémoire

Pour exploiter un fichier sur une carte SD tu trouveras des infos ici
https://www.arduino.cc/en/Reference/SD

Bonjour
merci j'ai fouillé cette Librairie.pas trouvé la solution
les declarations:
File myFile;
byte FPort;
unsigned char Data;
byte Addr;
byte Nibble=0;
byte BitNo;
byte Pass;
byte Verify;
char Ans;
PORTK|=B00000011;
for (Addr=0;Addr<bytes;Addr++) {
// Read the data to be programmed
//Data=pgm_read_byte(ROM+Addr);// ici avec const byte PROGMEM ROM2[bytes] = { //0X08, 0XC8, 0XFB, 0X40, 0XC8, 0XF9, 0X06, 0XC8, etc.....
Data=pgm_read_byte(myFile.read()+Addr);//ici avec myFile = SD.open("test_wr.txt");
//Serial.write(myFile.read());
//Serial.println(Data,HEX);
//Data=myFile.read;
PORTA=(PORTA&B00000000)|(Addr);
//PORTC=(PORTC&B11111111)|((Addr)&B00000000);
delayMicroseconds(1);

  for (BitNo=Nibble;BitNo<Nibble+4;BitNo++) {
    if (((Data>>BitNo)&B00000001)==1) {
      
      // Set Data bit
      PORTC=(PORTC&B00000000)|(B00000001<<(BitNo-Nibble));

Tu dois créer un fichier sur la SD contenant les octets voulus. Ensuite chaque octet doit être lu avec myFile.read().
pgm_read_byte() n'a rien à faire dans cette histoire.

Merci de lire

et de placer ton code entre balises pour le rendre lisible

Bonjour
oui le fichier existe dans la SD "test_wr.txt"genre 0X08, 0XC8, 0XFB, 0X40, 0XC8, 0XF9, 0X06, 0XC8, etc.....
si je fait un Serial.println(Data,HEX);
apres le Data=pgm_read_byte(ROM+Addr);
cela fonctionne precision
byte Data;
byte Addr;
donc
myFile = SD.open("test_wr.txt", FILE_READ);
if (myFile) //{
while (myFile.available()) //{
data = byte(myFile.read());

Question
const byte PROGMEM ROM[bytes] = {
0X00, 0XCF, 0XFF, 0X90, 0X1E, 0X37, 0XC2, 0X0C
quand ont fait
for (Addr=0;Addr<bytes;Addr++) {
Data=pgm_read_byte(ROM+Addr);
Serial.print(Data,HEX);
j obtient
0
CF
FF
90
1E
37
C2
0C
je n'arrive pas à lire la sd dans le même format
une idée??

Bonjour
comme je n'arrive pas à lire correctement ma carte sd. j ai choisi de stocker mon fichier
dans une EEPROM externe.
je lit les adresses les une après les autres
exemple;
0
0
C
F
9
0
1
E
3
7
etc..
je voudrais pouvoir renvoyer une variable (val)
00
CF
FF
90
1E
37 etc..
j utilise
un test adresse pair impaire:
for (long x = 0 ; x < 0x100 ; x++) //Read bytes from EEPROM
{
if (x % 2 == 0) {
byte valp= readEEPROM(x);
data=vali;
//Serial.println();
//Serial.write(valp);
}
else {
byte vali= readEEPROM(x);
Data=valp;
//Serial.println();
//Serial.write(valp+vali);
}
val=16*(data)+(Data);
Serial.println();
Serial.println(val,HEX);
j obtient:
F2
3A
60
73
89

je bloque vraiment et je tourne en rond !!!!
et comprend les base 16(HEX) et ASCII
mais je comprend pas pourquoi j'obtient F2 par exemple

correction:
88
D0
30
43
A3
A6

Pourquoi ne pas stocker directement les bytes dans ce cas, au lieu de les stocker en ASCII ?

Le fichier est un fichier teste envoyé dans l'EEPROM 24c512
avec une routine appelé dans un menu (fichier pour programmer une EPROM)
// ******************** Write_Function *******************

void TransferToEEPROM(void){
byte c;
int i=0;
boolean k=LOW;
//DrawStringSH1106(" ", 0, 7, SmallFont);
while(!k){
while(!Serial.available());
c = Serial.read();
if(c=='&'){ // last character
k=HIGH;
}
i2c_eeprom_write_byte(0x50, i, c);
delay(5); // wait for EEPROM to transfer Data
i++;
}

}

void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
int rdata = data;
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.write(rdata);
Wire.endTransmission();
}

Tout dépend du logiciel qui envoie les données sur le PC. Si ce logiciel est un terminal, ou serial monitor, tu ne peux pas faire autrement, mais s'il est écrit en C ou PYTHON ou autre il peut envoyer les bytes directement, sans avoir recours à l'ASCII.

D'autre part quand tu reçois "CF", tu reçois deux caractères : 'C' puis 'F'.
Essaie :

void setup() {
  Serial.begin(115200);
  char s[] = "CF";
  byte b;
  sscanf(s, "%02x", &b);
  Serial.println(b);
  Serial.println(b, HEX);
}

void loop() {
}

Merci je test
si:
char s = val;
j obtient
initializer fails to determine size of 's'

Là tu te trouves confronté à un problème typique des gens qui ne connaissent pas le C.
Pourquoi ne pas utiliser val directement, si c'est une chaîne de caractères ? Il faut que ta variable val soit terminée par '\0'.
C'est à dire quelle doit avoir une valeur de : "CF\0".

val est le resultat de la lecture de l'EEPROM qui contient le code à graver dans une PROM
je doit convertir en hex pour commander des sorties binaire (genre D0,D1,D2,D3)
le projet est de réaliser un programmateur de PROM 74S571 j ai modifié le skech initial pour le faire fonctionner sur un mega en modifiant les registres et port de sorties ,la maquette initial fonctionne .Mais le code doit être charger avec le sketch c'est un tableau PROGMEM.(0x00,0xCF,0xFF...etc
donc pour améliorer je voudrais via le moniteur serie charger ce code
j y arrive mais la lecture et donc la programmation de l'EPROM est fausse.
le code est en caractères ascii et non en hex
une autre solution est le fichier sur une SD(pas plus de resultat)
MERCI pour l'aide je planche dessus depuis 3 semaines tout les soir ouf

Les caractères envoyés par le moniteur série doivent être reçus dans un buffer (char [ ]) et décodés deux par deux :

void setup() {
  Serial.begin(115200);
}

void loop() {
  char buffer[100];
  if (Serial.available()) {
    int len = Serial.readBytesUntil('\n', buffer, 100);
    if (len > 0) {
      if (buffer[len-1] == '\r') { // élimine retour chariot éventuel
        len--;
      }
      buffer[len] = '\0';   // termine par ZERO
      Serial.print(len); Serial.print("chars: "); Serial.print(buffer);
      for (int cnt = 0 ; cnt < len ; cnt += 2) {
        char token[3];
        byte value;
        token[0] = buffer[cnt];
        token[1] = buffer[cnt+1];
        token[2] = '\0';
        sscanf(token, "%02x", &value);
        Serial.println(value, HEX);
      }
    }
  }
}

value est un byte à stocker en EEPROM (0x00, 0xCF, 0xFF, 0x90, 0x1E, 0x37, etc.). Ensuite à la lecture de l'EEPROM, la valeur lue est utilisable directement.
Le moniteur série doit être réglé de préférence avec "Nouvelle ligne" ou "Les deux, NL et CR".

Merci d’éditer TOUS vos post pour rajouter les balises de de code, c’est pénible à lire et moche tel quel:

  • sélectionner la partie du texte qui correspond au code
  • appuyez sur l’icône </> dans la barre d’outils pour indiquer que c’est du code

(Assurez vous aussi d’indenter le code correctement dans l’IDE avant de le copier pour le coller ici. Cela se fait en pressant ctrlT sur PC ou cmdT sur un Mac)

merci
pour lire EEPROM
Serial.println("Start Reading...");

for (long x = 0 ; x < 0xFF ; x++) //Read bytes from EERPROM
{ byte val = readEEPROM(x);// routine qui lit l'EEPROM a chaque adresse x

Serial.write(val);// affiche le contenue de l'EEPROM
caractere en ascii donc valeur ascii si je fait un Serial.print(val);
je ne comprend pas a quoi correspond "len"

Vos posts contiennent toujours du code sans balises…