[MPASM] [pic16f877a] astuces pour listing dans mémoire flash ou mieux

[inviteeae25a15]

Bonjour

Pour mon projet , j'ai un fichier .txt avec beaucoup de valeurs hexa l'une a la suite de l'autre , j'aimerais qu'elles se suivent pour pouvoir en faire la lecture en mémoire flash , octet par octet .

Mais je me vois mal mettre DA a chaque octet manuellement , déja que je vais devoir utiliser radix ce que je n'aime pas du tout .

quelques octets pour vous donner une idée de comment ce présente mon fichier .txt

00 00 00 02 00 01 00 40 1F 00 00 00 10 00 00 00 01 04 00 20 00 F4 01 07 00 00 01 00 00 00 02 00 
FF 00 00 00 00 C0 00 40 00 F0 00 00 00 CC 01 30 FF 88 01 18 FF 66 61 63 74 04 00 00 00 1E 33 00 
00 64 61 74 61 00 1B 00 00 00 1D 00 80 FE B4 FE 80 DF 51 00 1E C0 C0 FC 33 1C 1F 1D A6 10 00 00 ... etc

Donc je me demandais :

- Si c'est la bonne méthode pour stocker ce genre de données a restituer ( une intérruption timer devra utiliser chaque octet un par un ) , je suppose que je vai être très vite bloqué car ces fichier .txt sont les data d 'un sample wav pcm 4 bits et j'aimerai pouvoir stocker le plus de samples possible .

-Y a t il une autre méthode pour disposer de plus de mémoires ?

Si c'est la seul méthode

- Y' a t il une directives ou une astuce pour lister tous ces octets dans mplab et les utiliser un a la suite de l autre sans que je doive rajouter DA a chaque octet ?

N.B : je précise que je ne veux pas changer de pic

Merci d'avance
-----

[invitee05a3fcc]

Ton fichier .txt représente tes données en Ascii . Donc pour un octet, il y a 3 octets de stockés ( sans compter les CR LF tous les 32 triplets)

Si tu ne veux pas visualiser mais utiliser, il faut stocker les octets un par un . Par contre, avec un editeur de texte , tu verras du chinois .... façon de parler !

Par exemple :

00 00 00 02 00 01

C'est 00110000 00110000 00100000 00110000 00110000 00100000 00110000 00110000 00100000 00110000 00110010 00100000 00110000 00110000 00100000 00110000 00110001 00100000 00001101 00001010
alors que ça pourrait être :
00000000 00000000 00000000 00000010 00000000 00000001

[inviteeae25a15]

Sur hex edit y'a une collonne a droite qui me mettais l ascii , je pensais que c'était de l hexa que j'ai copier coller dans le .txt (j'ai copier coller la collonne principale , pas celle de droite qui me marquais RIFF etc ).

Si tu ne veux pas visualiser mais utiliser, il faut stocker les octets un par un

Oui justement si je dois stocker tous ça en mémoire flash j'en ai pour des jours a rajouter DA devant chaque octet ... et je me vois mal faire ça pour tous les autres samples .

A part me faire un mini prog qui lirai le txt et rajouterai DA a chaque octet puis passerai a la ligne , ça réorganiserai mes octet et je pourrais juste copier coller la liste dans MPLAB .
Je vois pas d'autre solution , j'espère quelqu'un en aura une plus pertinente .

Sinon niveau stockage la mémoire flash est la seul solution ? Y'a t il mieux pour pouvoir stocker le plus de samples possible ?

[invitee05a3fcc]

Sur hex edit y'a une collonne a droite qui me mettais l ascii , je pense que ce que j'avais mis était de l hexa .

Ton editeur Hexa te donne le contenu en Hexa et la visualisation Ascii (utile pour repérer des textes imprimables)

Sinon niveau stockage la mémoire flash est la seul solution ? Y'a t il mieux pour pouvoir stocker le plus de samples possible ?

flash, RAM, FRAM, EEPROM, peu importe le composant

[A voir en vidéo sur Futura]

[inviteeae25a15]

J'aurais du mieu préciser , ma questions aurai du être sur un pic 16f877 est-il possible d'avoir une mémoire externe si oui , laquelle et comment lire dans cette mémoire externe avec le pic ?

Et pour mes données c'est bien de l hexa alors ? Je doute maintenant

[invitee05a3fcc]

J'aurais du mieu préciser , ma questions aurai du être sur un pic 16f877 est-il possible d'avoir une mémoire externe si oui , laquelle et comment lire dans cette mémoire externe avec le pic ?

Tu mets une mémoire qui dialogue en SPI ou I²C

Et pour mes données c'est bien de l hexa alors ? Je doute maintenant

C'est toi qui décide ! Le mieux, le plus dense, c'est en binaire. L'hexa n'étant qu'une représentation imprimable du binaire !
Si un octet mémoire contient 11010100, perso, je préfère parler de D4

[inviteeae25a15]

merci beaucoup pour toutes ces réponses .

Sinon pour retranscrire toutes c'est données dans MPLAB tu aurais une idée pour pas y passer des jours ?
je ne connais pas le spi ou i2c , peu être que ça va résoudre le souci de retranscription ?

[invitee05a3fcc]

Sinon pour retranscrire toutes c'est données dans MPLAB tu aurais une idée pour pas y passer des jours ?

Je ne connais pas MPLAB

je ne connais pas le spi ou i2c , peu être que ça va résoudre le souci de retranscription ?

SPI ou I²C, ce n'est qu'un protocole hard pour échanger des données entre un µC et un périphérique

[paulfjujo]

bonjour,

A part me faire un mini prog qui lirai le txt et rajouterai DA

copier le fichier original en *.csv ou *.txt
l'importer dans excel ...
inserer une colonne sur la gauche
DA dans le debut , on tire vers le bas jusqu'a xxxx lignes pour le copier
puis on joint DA et le reste dans une autre colonne
et on sauvegarde en mode text
(ou avec une macro vba)

On appelais ces petits trucs utilitaires: des moulinettes

vu le sigle RIFF .. fichier WAV ?
un riblon en exemple avec TurboC2.00 de Borland :
-toujour OK dans une fenetre DOS sous XP !!)

#include <stdio.h>
#include <io.h>
#include <alloc.h>
#include <Dos.h>
#include <Bios.h>
#include <string.h>
#include <conio.h>
#include <dir.h>
#include <fcntl.h>

#define CR printf("\n");

typedef enum {FALSE,TRUE} bool;
typedef unsigned char byte;
typedef unsigned int word;

struct REGPACK Rg;

unsigned long int Taille;
word i,j,k,l,m;
int argc;
char * argv;
char  NomFich[128];
char  * Tampon;
FILE  * f1;
FILE  * f2;
char drive[3];
char dir[32];
char name[64];
char ext[3];
int *Mesure;

struct FileHeader
{   long lRiff  ;
    long lFileSize ;
    long lWave;
    long lFormat ;
    long lFormatLength;
};

struct WaveFormat
 {
    int  wFormatTag ;
    int nChannels ;
    long nSamplesPerSec ;
    long nAvgBytesPerSec;
    int nBlockAlign ;
    int wBitsPerSample;
};

struct ChunkHeader
 {
    long lData;
    long lLen;
};

struct FileHeader fh;
struct WaveFormat wf;
struct ChunkHeader chu;

void Couine()
{
int i,iii;
 for (i=100;i<1000;i=i+10) {  sound(i); for
(iii=0;iii<20000;iii++);nosound(); }
nosound();
}

void LitFichier()
{
 word j,j1;
 strupr(NomFich);
 f1=fopen(NomFich,"r+b");
 if(f1==NULL)
 {
  printf("\nProbleme sur ouverture de %s......",NomFich);
  Couine();  sleep(1);  exit(1);
  }
  else
  {
  printf("\nLecture de %s ",NomFich);
  sleep(2);
  j=fseek(f1,0L,SEEK_END);
  Taille=ftell(f1);  printf("\nTaille fichier =%8ld octets",Taille);
  if (Taille>64)
   {
   j=strlen(NomFich);
   j1=memicmp(NomFich+j-3,"WAV",3);
   if(j1==0)
    {
    fseek(f1,0,SEEK_SET);
    textcolor(GREEN);CR
    cprintf("Lecture Header");
    textcolor(WHITE);
    Taille=fread(&fh,sizeof(fh),1 ,f1);
    strncpy(Tampon,&fh,4);*(Tampon+4)=0;
    printf("\n1ere Signature Ascii       = %4s",Tampon);
    printf("\nTaille fichier - 8         = %8ld",fh.lFileSize);
    strcpy(Tampon,&fh.lWave);*(Tampon+4)=0;
    printf("\n2em signature Ascii        = %4s",Tampon);
    strncpy(Tampon,&fh.lFormat,4);
    *(Tampon+4)=0;
    printf("\n3em signature Ascii        = %4s",Tampon);
    printf("\nformat Nb de bits          = %8ld",fh.lFormatLength);

    textcolor(GREEN); CR
    cprintf("Lecture Wave Format");
    textcolor(WHITE);
    Taille=fread(&wf,sizeof(wf),1 ,f1);
    printf("\nFormat tag                 = %5d",wf.wFormatTag);
    printf("\nNombre de chanel           = %5d",wf.nChannels);
    printf("\nEchantillons par seconde   = %8u",wf.nSamplesPerSec);
    printf("\nNb Octest par echantillon  = %8u",wf.nAvgBytesPerSec );
    printf("\nBlock Align                = %5d",wf.nBlockAlign);
    printf("\nBits per sample            = %5d",wf.wBitsPerSample);

    textcolor(GREEN);CR
    cprintf("Lecture Chunk");
    textcolor(WHITE);
    Taille=fread(&chu,sizeof(chu),1 ,f1);
    strcpy(Tampon,&chu.lData);
    *(Tampon+4)=0;
    printf("\nData Signature Ascii       = %s",Tampon);
    printf("\nLen                        =%8ld",chu.lLen);
   Mesure=(int *) malloc(4096);

 Taille=fread(Mesure,sizeof(int),4096,f1);
  printf("\nLecture de %8ld data ",Taille);
  if (Taille!=4096)
   {
   CR; textcolor(RED); cprintf(" ..PB de lecture data..");CR
   sleep(3); exit(3);
    }
     else   {  textcolor(GREEN);cprintf("..OK ");}
       }
      else { printf("\nCe n'est pas un WAV !!!..."); sleep(1);  }
   }
   else  {  printf("\nFichier trop court pour etre normal !..");  sleep(1);  }
 }
fclose(f1);
sleep(3);
}


void EcritFichier()
{
long i;
 _fmode=O_BINARY;
 strcpy(NomFich,name);
 strcat(NomFich,".DAT");
 f2=fopen(NomFich,"wr+b");
 printf("\nOuverture fichier %s ",NomFich);
 if(f2==NULL)
 {
 printf("\nProbleme ouverture fichier %x",f2);
 Couine();
 fcloseall;
 exit(4);
 }
  else
  {
  rewind(f2);  i=fseek(f2,0,SEEK_SET);
  i=fwrite(Mesure,sizeof(int),4096,f1);
  if(i==4096)
     {printf("\nEcriture  reussie..de %8ld mots.",i);}
	 else
	 {
	 CR;textcolor(RED);cprintf(" PB Ecriture ..i= %8ld  ",i);
	 CR; Couine();fcloseall;
	 exit(5);
	 }
  i=fwrite(&wf.nSamplesPerSec,sizeof(long),1,f2);
 }
 sleep(1);
 fclose(f2);
}



void main(int argc,char * argv[])
{
  clrscr();
  Tampon=(char *)malloc(256);
  Mesure=(int *)malloc(4096+4);
  textcolor(12);  gotoxy(1,2);
  cprintf("\nWav2Dat.c (V1.0  PF 01/01).LECTURE ENTETE D'UN FICHIER *.WAV");
  k=argc;
  if (k>1)
  {
   strcpy(Tampon,argv[1]);
   printf("\nNom de fichier pass‚ en parametre : %s",Tampon);
  }
  else
  {
   printf("\nNom du fichier :");   gets(Tampon);
  }
 strcpy(NomFich,Tampon);
  k=fnsplit(Tampon,drive,dir,name,ext);
  printf("\nSplit nom du fichier  donne :");
  printf("\ndrive : %s",drive);
  printf("\ndir : %s",dir);
  printf("\nname : %s ",name);
  printf("\next : %s",ext);

  LitFichier();

  EcritFichier();

  textcolor(GREEN);CR;CR
  cprintf("....fin normale"); CR
  sleep(2);
  while (!kbhit());
   free(Tampon);
 free(Mesure);
}

[inviteeae25a15]

vu le sigle RIFF .. fichier WAV ?
un riblon en exemple avec TurboC2.00 de Borland

Oui c'est un fichier wav , en quoi consiste ce programme ? Il transcrit juste l entète du fichier wav ou il liste aussi les datas ( je n'ai pas besoin de l entete juste des datas )?

En tous cas merci pour le truc de la moulinette

[paulfjujo]

il isole effectivement les donnees du header
mais aussi recupere les datas brutes dans une table
pour les renvoyer dans un fichier de sortie au format txt..

... il faudrait modifier cette moulinette pour rajouter 'dt'
et des separateur ";"

En assembleur on peut mettre aussi
dt sur une seule ligne , si les datas sont en Hexa
exemple police 5x7

	
        dt 0x00,0x00,0x00,0x00,0x00,0x00 ;   0x20
	dt 0x00,0x00,0x5F,0x00,0x00,0x00 ; ! 0x21
	dt 0x00,0x07,0x00,0x07,0x00,0x00 ; " 0x22
	dt 0x14,0x7F,0x14,0x7F,0x14,0x00 ; # 0x23
	dt 0x24,0x2A,0x7F,0x2A,0x12,0x00 ; $ 0x24
	dt 0x26,0x16,0x08,0x34,0x32,0x00 ; % 0x25
	dt 0x76,0x49,0x55,0x22,0x50,0x00 ; & 0x26
	dt 0x00,0x00,0x05,0x03,0x00,0x00 ; ' 0x27
	dt 0x00,0x1C,0x22,0x41,0x00,0x00 ; ( 0x28
	dt 0x00,0x41,0x22,0x1C,0x00,0x00 ; ) 0x29
	dt 0x14,0x08,0x3E,0x08,0x14,0x00 ; * 0x2A
	dt 0x08,0x08,0x3E,0x08,0x08,0x00 ; + 0x2B
	dt 0x00,0x50,0x30,0x00,0x00,0x00 ; , 0x2C
	dt 0x08,0x08,0x08,0x08,0x08,0x00 ; - 0x2D
	dt 0x00,0x60,0x60,0x00,0x00,0x00 ; . 0x2E
.. etc ....

avant de renvoyer le tout dans le fichier de sortie texte..

Je me servais du fichier de sortie pour faire une analyse FFT ...
avec SCILAB ou un autre programme en C.

[inviteeae25a15]

merci beaucoup, en triturant ce code je vai arriver a mes fin , merci beaucoup