Bonjour sanitas,
Juste une question de code; comment change t-on toutes les valeurs d'un tableau par 0 , suis je obligé de faire une boucle ?
Sachant qu'il s'agit d'un certain nombre de tableau de "char" d'une structure mais pas tout ces éléments.
a un instant dans le soft (apui sur un bouton reset ) je souhaite mettre le valeur de tableau à 0 et d'après le net
en faisant ça
appDataTCPIP_WIFI.new_IP[0]={0};
tout serai à "0" seulement évidemment marche pas ):
Salut,
c'est possible mais uniquement lorsque tu déclares le tableau, on le remplit de 0 avec
char appDataTCPIP_WIFI.new_IP[16] = {0};
Mais c'est un tableau destiner à recevoir une chaîne, alors dans ce cas cela ne sert à rien de tout remplir, il suffit de mettre le premier octet à 0 avec
appDataTCPIP_WIFI.new_IP[0] = 0;
et la chaîne appDataTCPIP_WIFI.new_IP est vide.
Sinon pour remplir un tableau ou une structure, on utilise memset() ou memcpy()
Tu as abandonné la flash externe ?
Merci j'essaiEnvoyé par satinas
Non je n'ai pas abandonné, seulement pour mon moral et également l'avancement de mon projet qui à tendance à trainer,je suis passé sur des instructions que j'arrive plus facilement à faire, je reprend aussitôt la flash externe après.
Lis cette page, cela concerne les 2 erreurs de compilation que tu as.
https://msdn.microsoft.com/fr-fr/library/36k2cdd4.aspx
Ces 2 instructions font la même chose :
appDataTCPIP_WIFI.new_IP[0] = 0;
strcpy(appDataTCPIP_WIFI.new_I P, "");
Alors effectivement j'ai fait cette expression là
appDataTCPIP_WIFI.new_IP[0] = 0
Qui met un "0" à appDataTCPIP_WIFI.new_IP[0] et comme je test uniquement la première valeur du tableau c'est bien prise en compte et je n'est donc pas besoin de changer le reste des valeurs qui sont elles encore présente, seulement je pensais quand même qu'en faisant comme ça tout le tableau serai à "0"
tu me dis que strcpy(appDataTCPIP_WIFI.new_I P, ""); fait la même chose ?
Toi, tu le vois quoi faire de différent ?
Si tu me dis pas ce que tu ne comprends pas, je ne vais pas l'inventer.
appDataTCPIP_WIFI.new_IP[0] est un caractère, rien d'autre, tu ne sais toujours pas ce qu'est un type de donnée C.
Je t'ai parlé des tableaux et des chaînes, mais il semble que rien ne soit passé, on va dire que je suis très mauvais pédagogue.
Bonjour,
Avant de repasser à ma flash externe , je souhaitais finaliser la méthodologie de sauvegarde, notamment à la coupure d'alimentation comme descrit sur le poste que j'ai ouvert concernant le problème.
à la coupure j'ai une variable qui ce met à 1 pendant les dernières 600ms avant extinction qui fait appelle à la fonction de sauvegarde en flash interne, par la suite ce sera en externe.
Ce qui est bizzard est que quand je fais appel à cette fonction de sauvegarde lors de l'extinction, cela m'écrit que des 0xFF alors que quand je le fais par la modification de paramètre réseau (donc autre variable) évidamment sans extinction cela m'écrit des 0x00 ou il doit rien avoir et les données à leur emplacement.
Que ce passerait-il à t-on avis
Merci pour l'aide précieuse (:
Dernière modification par davidif ; 06/09/2016 à 21h49.
Tu aurais dû rester sur l'autre discussion parce que à mon avis, c'est un problème d'alimentation, qui n'est pas la même dans les 2 cas, si j'ai bien suivi. Si il y a des 0xff, l'effacement s'est bien passé, par contre pas d'écriture ...
La fonction write() flash retourne un booléen, affiche le sur le port série juste avant le power off.
Oui je vais vérifier ça ce matin,
Juste pour te répondre sur ton poste 70, je suis pas sûre que ce soit hard(graphe de l'autre sujet), car j'ai théoriquement le temps de sauvegarder à environ 600 ms après extinction c'est en ça que je ne comprend pas, bien que j'y ai crue l'espace d'un instant car en fait au dépard, je profitais des 600ms pour écrire en flash, en faisant ça
Seulement, "save_coupure" durait 600ms à la coupure, je passai donc dans cette condition tant que "save_coupure=1", donc pas terrible il me semble.Code:if(save_coupure==1) { WDRV_NVM_write_new((char *)&appDataTCPIP_WIFI, sizeof(appDataTCPIP_WIFI)); }
Ensuite, j'ai donc fait ça
Là je passe donc Qu'une fois, donc mieux mais apparemment pas suffisant, je repère bien en sortie un pic représentant "save_coupure=1" à la coupure .Code:if(save_coupure==1) { WDRV_NVM_write_new((char *)&appDataTCPIP_WIFI, sizeof(appDataTCPIP_WIFI)); save_coupure=0; }
Par contre, et là je sais pas pourquoi, car il n'y a pas de lien mais qu'en je change mes paramètres réseau via ça page web, je remplis donc ma structure à sauver, puis reboot la carte et là je ne vois pas le pic de sauvegarde à l'extinction bizarrement et donc ne sauvegarde pas.
Par contre, si j'utilise un flag de modification de changement de paramètre réseau, les changements on lieu, sans extinction tout de suite après, celle-ci est faite par moi après changement :
Code:if (move_tcpip==1) { WDRV_NVM_write_new((char *)&appDataTCPIP_WIFI, sizeof(appDataTCPIP_WIFI)); move_tcpip=0; }
Dernière modification par davidif ; 07/09/2016 à 08h49.
Bonjour, ça y est la mémorisation à l'extinction fonctionne correctement grâce aux signaux capteur de courant , je vais donc pouvoir me remettre sur cette flash extern
j'ai une question concernant le nombre d'écriture d'une mémoire, on compte également le nombre de fois que l'on reprogramme après plusieurs compilation et des nombreux essais ? ou c'est propre à l'écriture uniquement dans la flash seulement.
car en comptant le nombre de fois que j'ai reprogrammé ma carte pour arriver à lui faire faire ce que je souhaite en théorie sur 6 mois à raison d'une dizaine de reprogrammation c'est foutu ?... (:
Bonjour,
J'ai donc fait fonctionné mon bus spi qui a l'aire de bien ce porter, maintenant il faut que je fasse quelque choses de similaire par rapport au fichier
http://ww1.microchip.com/downloads/e...ST26VF064B.zip
Par contre, j'ai pas trop identifié la fonction qui permet d'écrire.
Il y a de la validation ou pas d'écriture
ouCode:void SPI_WREN() { CE_Low(); /* enable device */ Send_Byte(0x06); /* send WREN command */ CE_High(); /* disable device */ }
j'ai des fonctions de lecture de bloc de 256 si j'ai bien compris mais qu'elle serait les fonctions dont je devrais m'inspirer pour écrire ?Code:void SPI_WRDI() { CE_Low(); /* enable device */ Send_Byte(0x04); /* send WRDI command */ CE_High(); /* disable device */ }
Merci
merci pour ta réponse, seulement je préfère commencer doucement et ne pas tout prendre en faisant quelques changement mais intégrer les fonctions une à une et les débugger petit à petit car j'ai pu initialiser mon bus spi , vérifier l'envoi et la réception d'un octet qui à donc l'aire de bien fonctionner, seulement comme tu t'en doute les instructions propre harmony sont différentes au fichier et l'idée est de m'inspirer le plus possible de ce fichier avec mes paramètres.
J'ai donc une fichier
my_spi_pic32.c
my_spi_pic32.h
dans lesquels j'implémente mes fonctions de
j'ai défini ma pin csCode:void DRV_SPI_Init(void) { SYS_PORTS_PinWrite(PORTS_ID_0, SPI_CS_PORT_ID, SPI_CS_PORT_PIN,SYS_Pin_F_LAT); PLIB_PORTS_PinDirectionOutputSet(PORTS_ID_0,SPI_CS_PORT_ID, SPI_CS_PORT_PIN); } //void DRV_SPI_Put(chn, b) void DRV_SPI_Put(char b) { APP_SPI_CS_SELECT(); //APP_SPI_CS_DESELECT(); PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 , b ); } //void DRV_SPI_Get(chn){} uint8_t DRV_SPI_read(void) { uint8_t buffer; buffer=PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1); return buffer; }
Code:#define APP_SPI_CS_SELECT() \ SYS_PORTS_PinClear(PORTS_ID_0,SPI_CS_PORT_ID,SPI_CS_PORT_PIN) #define APP_SPI_CS_DESELECT() \ SYS_PORTS_PinSet(PORTS_ID_0,SPI_CS_PORT_ID,SPI_CS_PORT_PIN)
et je vais donc pouvoir utiliser tout ça dans les fonction d'écriture et de lecture du dit fichier.
Driver à tester
merci , mais il ne doit pas encore être validé car je n'y accède pas pour le moment
Code:#define LED_TRIS TRISA // display 8 leds #define LED_LAT LATA #define SST_CE_TRIS _TRISB0 // outputs sst #define SST_CE_LAT _LATB0 #define SST_SCK_TRIS _TRISB1 #define SST_SCK_LAT _LATB1 #define SST_SI_TRIS _TRISB2 #define SST_SI_LAT _LATB2 #define SST_SO_TRIS _TRISB3 // input so sst #define SST_SO_PORT _RB3
excuse moi , mais mes entrées sorties SPI sont déjà défini et fonctionnel , maintenant ce que je dois faire, envoyer les commande de lecture écriture de block mémoires via mon bus spi
Je ne lirai pas la doc de la flash !
le driver fait par SST fonctionne en :
BIT BANGING
BIT BANGING
BIT BANGING
BIT BANGING
BIT BANGING
BIT BANGING
J'ai oublié de mettre ces 2 lignes en commentaire
// TRISF = TRISF & ~(0x0100);
// TRISF = TRISF | (0x100);
Non je ne te demande pas de la lire , je suis actuellement dessus, histoire de comprendre mieux son fonctionnement et de faire les rapprochement avec le programme source.
Par contre, je ne comprend pas ce que tu veux dire par "BIT BANGING" ça fait partie du langage qui ne m'est pas très familier
La fonction Get_Byte() n'est pas bonne car j'ai oublié de remplacer dedans la pin data par SST_SO_PORT.
Et il reste à commenter tous les lignes restant avec des PORTF qui concernent le SQI, et qui risquent de griller ta carte, fais bien attention avant de tester, le driver au départ utilisait les ports A et F, tout ça en output.
ok merci pour le fichier modifier satinas, je suis dessus et regard, j'avais commencé à copier les fonctions en prenant mes variable comme ceci par exemple:
j'ai fais comme çaCode:void SPI_Page_Program(unsigned long Dst) { unsigned int i; i=0; CE_Low(); /* enable device */ Send_Byte(0x02); /* send Byte Program command */ Send_Byte(((Dst & 0xFFFFFF) >> 16)); /* send 3 address bytes */ Send_Byte(((Dst & 0xFFFF) >> 8)); Send_Byte(Dst & 0xFF); for (i=0;i<256;i++) { Send_Byte(data_256[i]); /* send byte to be programmed */ } CE_High(); /* disable device */ }
Code:void SPI_Page_Program(unsigned long Dst) { unsigned int i; i=0; APP_SPI_CS_SELECT(); DRV_SPI_Put(0x02); DRV_SPI_Put(((Dst & 0xFFFFFF) >> 16)); DRV_SPI_Put(((Dst & 0xFFFF) >> 8)); DRV_SPI_Put(Dst & 0xFF); for (i=0;i<256;i++) { DRV_SPI_Put(data_256[i]); /* send byte to be programmed */ } APP_SPI_CS_DESELECT(); /* disable device */ }
Le mieux est d'enlever toutes les fonctions de type Get/Send Double_Byte() et Get/Send SQI() qui sortent du format SPI si/so. Je pense pas qu'elles soient utilisées dans le main, car il se cantonne au SPI. A vérifier.
Bien sur qu'il vaudrait mieux repartir de zéro, en utilisant les fonctions de base, mais là il faut faire du C
j'ai juste besoin de reprendre les fonctions de lecture et d'écriture en remplaçant le variable comme j'ai fais plus haut, ça ne ma pas l'aire sorciè comme çaLe mieux est d'enlever toutes les fonctions de type Get/Send Double_Byte() et Get/Send SQI() qui sortent du format SPI si/so. Je pense pas qu'elles soient utilisées dans le main, car il se cantonne au SPI. A vérifier.
Bien sur qu'il vaudrait mieux repartir de zéro, en utilisant les fonctions de base, mais là il faut faire du C
je suis en train de retirer les fonctions ce rapportant au sqi et j'ai des doute concernant certains comme celle-ci
elle s'intitule "SPI_Quad_IO_NotInMode_Read_Co nt" mais parle de quad_io et à l'interieur ils font du "sendsqi" je comprend pas , est-ce du SPI ou SQI ?Code:void SPI_Quad_IO_NotInMode_Read_Cont(unsigned long Dst, unsigned long no_bytes) { unsigned long i = 0; CE_Low(); /* enable device */ SendSQI_Byte(((Dst & 0xFFFFFF) >> 16)); /* send 3 address bytes */ SendSQI_Byte(((Dst & 0xFFFF) >> 8)); SendSQI_Byte(Dst & 0xFF); SendSQI_Byte(0xFF); /*dummy byte*/ SendSQI_Byte(0xFF); /*dummy byte*/ SendSQI_Byte(0xFF); /*dummy byte*/ if (no_bytes>256) {no_bytes=256;} for (i = 0; i < no_bytes; i++) /* read until no_bytes is reached */ { data_256[i] = GetSQI_Byte(); } CE_High(); /* disable device */ }
j'ai donc repris et compiler correctement les fonctions, j'ai relu la docs et regarder le main du programme pour voir comment et quand fait-il pour écrire en mémoire avec la procédure à suivre, seulement je comprend pas à quel moment on vient écrire dans le main, j'ai vu qu'il effaçait certains emplacement et vient vérifier si les opérations sont bien faite, mais j'identifie mal ou ce fait l'écritures des données.
Le fichier recopier :
https://www.dropbox.com/s/a8c34nanr8...064_SPI.c?dl=0
a ton avis, on peut écrire une données isolé ou une page de 256.
doit-on effacer avant d'écrire ou peut-on ré-écrire par dessus, j'ai du mal à comprendre le procédé d'écriture lecture,
merci
après avoir implémenté mes fonctions , j'ai jeté un coup d'oeil sur les fichiers 'nvm_flash_spi_sst26vf0xxb' et repérer l'écriture
ils utilise les fonction DRV_SPI_Put avec 2 arguments, moi j'utilise également une fonction DRV_SPI_Put mais avec 1 argument , l'octet que j'envoi , comment pourrai-savoir ce que fait la fonction utilisé par l'écriture ?Code:void NVM_SST26VF0XXB_WriteByte(uint8_t data, uint32_t address) { NVM_SST26VF0XXB_WriteEnable(); NVM_SST26_ChipSelectEnable(); DRV_SPI_Put(spiInitData.channel, SST26_CMD_WRITE); DRV_SPI_Put(spiInitData.channel, ((SST26_ADDRESS)address).uint8Address[2]); DRV_SPI_Put(spiInitData.channel, ((SST26_ADDRESS)address).uint8Address[1]); DRV_SPI_Put(spiInitData.channel, ((SST26_ADDRESS)address).uint8Address[0]); DRV_SPI_Put(spiInitData.channel, data); NVM_SST26_ChipSelectDisable(); // Wait for write end while(NVM_SST26VF0XXB_IsWriteBusy()); }
Sur cette fonction il est donc envoyé la données puis sont adresse
