Programmation PIC 18F97j60(langage C, MPLAB)

[invite304155d6]

Bonjour,

je fais actuellement un stage en entreprise et je dois programmer un PIC sur une carte électronique (PICDEM NET 2 board, Microchip) à l'aide de MPLAB et du Pickit 2.

Mon probleme est le suivant :

Je souhaite récupérer des données d'un site web à partir de la carte (qui va jouer le role de client TCP), puis les traiter et les envoyer vers un recepteur via RF.

J'ai donc décidé de faire une requete GET vers un site web prédéfini puis de filtrer les infos.

J'arrive à faire la requete, l'envoyer puis récupérer les informations via un buffer mais pas du tout à les filtrer: en effet, le buffer change continuellement de données et les fonctions habituelles de test ne marchent absolument pas.

J'ai donc pensé à stocker les infos dans 2 char* temporaires sur lesquels je pourrais effectuer mes tests.

Le principe est le suivant :

While(on recoit des données) {

1)Je remplis aux avec le buffer jusqu'au retour ligne

2)Je remplis partiellement aux2 jusqu'a la fin du buffer (taille fixe)

3)Je finis de remplir aux2 avec le buffer renouvelé jusqu'au retour ligne.

4)Je remplis partiellement aux jusqu'a la fin du buffer

5)Je fini de remplir aux, et je boucle sur 2)
}


Mais, je déclare des "int" au début de mon programme, et lorsque je les change dans le while ( ex: int tempaux; tempaux = 1 ils sont reinitialisés à la boucle suivante, alors qu'ils sont déclaré en haut du programme.

S'agit il d'un probleme de type ? Comme MPLAB va interfacer avec l'assembleur (que je ne maitrise pas), comment régler ce probleme ?
J'ai besoin de tester des données, et de les changer pour les retester (en gros faire if (tempaux ==1) { tempaux =0, //traitement}, plusieurs fois avec plusieurs variables du meme acabis).

J'ai essayé beaucoup de solutions (comme changer de type) mais rien n'a marché.

Je pourrais poster le code si nécéssaire ou plus de précisions.

Merci de l'aide !
-----

[simon.]

Yo,

Fais voir le code, ça sera plus simple.

[invite304155d6]

Les "PutrsUART" et "PutsUART" c'est pour le débug, je lis l'USART via Hyperteminal.

Sinon, pour le code, principe simple de machine à état (définir un socket, ouvrir connexion, envoyer données, état recevoir...)
------------------------------------------------------------------------


#define __GENERICTCPCLIENT_C

#define HTTP_MAX_DATA_LEN2 (50u) //Taille max du buffer

#include "TCPIPConfig.h"

#if defined(STACK_USE_GENERIC_TCP_ CLIENT_EXAMPLE)

#include "TCPIP Stack/TCPIP.h"


// Defines the server to be accessed for this application
static BYTE ServerName[] = "test.zetsolutions.fr";

// Defines the port to be accessed for this application
static WORD ServerPort = 80;

// Defines the URL to be requested by this HTTP client
static ROM BYTE RemoteURL[] = "/Axible.html";




/****************************** ****************************** *****************
Function:
void GenericTCPClient(void)

Summary:
Implements a simple HTTP client (over TCP).

Description:
This function implements a simple HTTP client, which operates over TCP.
The function is called periodically by the stack, and waits for BUTTON1
to be pressed. When the button is pressed, the application opens a TCP
connection to an Internet search engine, performs a search for the word
"Microchip" on "microchip.com", and prints the resulting HTML page to
the UART.

This example can be used as a model for many TCP and HTTP client
applications.

Precondition:
TCP is initialized.

Parameters:
None

Returns:
None
****************************** ****************************** ***************/
void GenericTCPClient(void)
{
BYTE i;
WORD w;
BYTE vBuffer[30];
/****************************** ****************************** *******************/
/* AJOUT PERSO */
/****************************** ****************************** *******************/
BYTE* ptr2;
BYTE* ptr;
WORD w2;
int j,k,x;
int v1;
int v2;
BYTE passe;
BYTE tempaux;
BYTE tempaux2;
BYTE finiraux;
BYTE finiraux2;
char* test;
char const *pattern = "Axible";
char const *doh = "xdfdsj";
BYTE mchar[9];
BYTE hchar[5];
BYTE aux[30];
BYTE aux2[30];

/****************************** ****************************** *******************/
static TICK Timer;
static TCP_SOCKET MySocket = INVALID_SOCKET;
static enum _GenericTCPExampleState
{
SM_HOME = 0,
SM_SOCKET_OBTAINED,
SM_PROCESS_RESPONSE,
SM_DISCONNECT,
SM_DONE
} GenericTCPExampleState = SM_DONE;

switch(GenericTCPExampleState)
{
case SM_HOME:
// Connect a socket to the remote TCP server
MySocket = TCPOpen((DWORD)&ServerName[0], TCP_OPEN_RAM_HOST, ServerPort, TCP_PURPOSE_GENERIC_TCP_CLIENT );

// Abort operation if no TCP socket of type TCP_PURPOSE_GENERIC_TCP_CLIENT is available
// If this ever happens, you need to go add one to TCPIPConfig.h
if(MySocket == INVALID_SOCKET)
break;

#if defined(STACK_USE_UART)
putrsUART((ROM char*)"\r\n\r\nConnecting using Microchip TCP API...\r\n");
#endif


GenericTCPExampleState++;
Timer = TickGet();
break;

case SM_SOCKET_OBTAINED:
// Wait for the remote server to accept our connection request
if(!TCPIsConnected(MySocket))
{
// Time out if too much time is spent in this state
if(TickGet()-Timer > 5*TICK_SECOND)
{
// Close the socket so it can be used by other modules
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState--;
}
break;
}

Timer = TickGet();

// Make certain the socket can be written to
if(TCPIsPutReady(MySocket) < 125u)
break;

// Place the application protocol data into the transmit buffer. For this example, we are connected to an HTTP server, so we'll send an HTTP GET request.
TCPPutROMString(MySocket, (ROM BYTE*)"GET ");
TCPPutROMString(MySocket, RemoteURL);
TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.0\r\nHost: ");
TCPPutString(MySocket, ServerName);
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nConnection: close\r\n\r\n");
v1= 0;
v2= 0;
passe=0;
tempaux=0;
tempaux2=0;
finiraux=0;
finiraux2=0;
PORTJ=0b00000000;
// Send the packet
TCPFlush(MySocket);
GenericTCPExampleState++;
break;

case SM_PROCESS_RESPONSE:
// Check to see if the remote node has disconnected from us or sent us any application data
// If application data is available, write it to the UART


if(!TCPIsConnected(MySocket))
{
GenericTCPExampleState = SM_DISCONNECT;
// Do not break; We might still have data in the TCP RX FIFO waiting for us
}

// Get count of RX bytes waiting
w = TCPIsGetReady(MySocket);

// Obtian and print the server reply
i = sizeof(vBuffer)-1;
vBuffer[i] = '\0';
while(w)
{
if ((tempaux == 0) && (finiraux == 0) && (tempaux2 == 0) && (finiraux == 0)){
putrsUART((ROM char*) " \r\n------------------- ALL STAR ------------------- \r\n");
}


if(w < i)
{
i = w;
vBuffer[i] = '\0';
}

w -= TCPGetArray(MySocket, vBuffer, i);


//tentative de récupérer les lignes avec taille dynamique

// si on a deja fait une lecture et que le 2e buffer a commencé a se remplir, on continue



//On lit le buffer jusqu'a la fin de la 1ere ligne et on écrit dans un char* auxiliaire
if (passe==0){
passe = 1;

while (vBuffer[v1] != '\r'){
aux[v1]=vBuffer[v1];
v1++;
putrsUART((ROM char*)" 1 ");
}
aux[v1]='\0';

tempaux2 = 1;
}

if (finiraux == 1){
//on finit de remplir aux
finiraux = 0;
while (vBuffer[v1] != '\r') {
aux[v2]=vBuffer[v1];
v2++;
v1++;
putrsUART((ROM char*)" 5 ");
}
tempaux2 = 1;
aux[v2]='\0';
v2=0;
}

//il faut finir aux 2 !
if (finiraux2 == 1){
finiraux2 = 0;
PORTJ = 0b00000001;
while (vBuffer[v1] != '\r') {
aux2[v2]=vBuffer[v1];
v2++;
v1++;
putrsUART((ROM char*)" 3 ");
}
tempaux = 1;
aux2[v2]='\0';
v2=0;
}


if (tempaux == 1){
//on remplit partiellement aux
tempaux = 0;
PORTJ = 0b00000001;
while (vBuffer[v1] != '\0'){
aux[v2]=vBuffer[v1];
v1++;
v2++;
putrsUART((ROM char*)" 4 ");
}
finiraux = 1;
v1=0;
}






//if (tempaux2 == 1){
//on remplit partiellement aux2
tempaux2 = 0;
while (vBuffer[v1] != '\0'){
aux2[v2]=vBuffer[v1];
v1++;
v2++;
putrsUART((ROM char*)" 2 ");
}
finiraux2 = 1;
v1=0;
}

putsUART(aux);
putrsUART((ROM char*)" /// ");
putsUART(aux2);
putrsUART((ROM char *)" \r\n ");

if ((tempaux == 0) && (finiraux == 0) && (tempaux2 == 0) && (finiraux2 == 0)){
putrsUART((ROM char*) " \r\n------------------- ALL ------------------- \r\n");
}

if(GenericTCPExampleState == SM_PROCESS_RESPONSE)
break;

}

break;

case SM_DISCONNECT:
// Close the socket so it can be used by other modules
// For this application, we wish to stay connected, but this state will still get entered if the remote server decides to disconnect
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState = SM_DONE;
break;

case SM_DONE:
// Do nothing unless the user pushes BUTTON1 and wants to restart the whole connection/download process
//Delay10KTCYx(1000);
if(BUTTON1_IO == 0u)
GenericTCPExampleState = SM_HOME;
break;
}
}

#endif //#if defined(STACK_USE_GENERIC_TCP_ CLIENT_EXAMPLE)

[simon.]

La prochaine fois tu utiliseras la balise code...

Bon, est-ce que tu peux dire précisément quelle variable, dans l'état du code que tu as posté, ne fait pas ce que tu attends ?

[A voir en vidéo sur Futura]

[invite304155d6]

Mais certainement !

Il s'agit des variables "tempaux, tempaux2, finiraux, finiraux2" qui déja quand je les initialise à 0 ne s'initialisent pas (test non concluant) et lorsque je les passe à 1 dans le while, elles passent à 1 temporairement et lors de la boucle suivante repassent à leur état d'avant

[sdec25]

Bonjour,
Exécute ce programme sur simulateur et dis-nous à quel endroit précisément le contenu de la variable est changé alors qu'il ne devrait pas l'être (tu peux utiliser un point d'arrêt).

[invite304155d6]

Bonjour,

bonne idée mais les points d'arrêt ne marchent pas du tout.

J'ai parcouru de nombreux forum et apparamment ca ne s'interface pas bien avec le langage C.

Dommage ça m'aurait bien aidé.

Et du coup, le "Watch" dans l'onglet "View" me met "Out of scope" pour TOUTES les variables.

Ca n'aide pas !

[simon.]

lorsque je les passe à 1 dans le while, elles passent à 1 temporairement et lors de la boucle suivante repassent à leur état d'avant

Pour tempaux, tempaux2, c'est normal tu le remets à zero toi-même.

Excuse moi mais ce que tu dis est encore trop flou.

Peux tu donner un programme précis, et dire ce que tu attends comme résultat, et ce que tu obtiens à la place ?

[invite304155d6]

Et bien je les remet à 0 lorsque je veux qu'elles soient à 0.

Le programme remplit alternativement 2 char* avec les informations d'un buffer (vBuffer) qui se remplit octet par octets d'informations qu'il recoit du serveur auquel j'ai fait la requete.

Normalement, le programme devrait bien se dérouler et mes 2 buffers se remplir correctement.

Je les affiche d'ailleurs en tant que débuggage à chaque étape (aux /// aux2) sur mon hyperterminal connecté en série avec la carte électronique.

Or , avec la syntaxe que j'ai copié (désolé pour les balises code), il ne rentre meme pas dans la premiere condition ( if (passe ==0) ) c'est comme s'il ne reconnaissait aucune valeur des int.

En tant que résultat, jai donc uniquement les " /// " qui s'affichent...

[guillaume83]

Bonsoir,
les variables "tempaux, tempaux2, finiraux, finiraux2" elles sont créées dans la fonction : void GenericTCPClient(void)

void GenericTCPClient(void)
{
BYTE i;
WORD w;
BYTE vBuffer[30];
/****************************** ****************************** *******************/
/* AJOUT PERSO */
/****************************** ****************************** *******************/
BYTE* ptr2;
BYTE* ptr;
WORD w2;
int j,k,x;
int v1;
int v2;
BYTE passe;
BYTE tempaux;
BYTE tempaux2;
BYTE finiraux;
BYTE finiraux2;
char* test;
char const *pattern = "Axible";
char const *doh = "xdfdsj";
BYTE mchar[9];
BYTE hchar[5];
BYTE aux[30];
BYTE aux2[30];

donc les variables sont créées à l' applel (réservation de l'espace mémoire), elles sont utilisées dans la fonction puis à la fin de l'utilisation de la fonction la variables sont détruites (libération de l' espace mémoire)
Cette méthode est utilisé pour l'utilisation de varibles qui ne sont utilisées seulement dans une fonction.
pour pouvoir utiliser des fonctions dans tout le programme il faut déclarer cellesci en tout début de programme , avant la toute premiére fonction .
bon courage @+

[freepicbasic]

on peut aussi utiliser static
static BYTE finiraux;

La variable ne s'effacera pas et sera vu que par cette procédure.

[invite304155d6]

Merci pour vos réponses,

guillaume83: les variables n'avaient pas à être plus globales quelles ne l'étaient déja : a l'appel de la fonction GenericTCPClient, tout ce petit monde devait etre reinitialisé bien sur.

freepicbasic: parfait ça a super bien marché, jai passé toute une journée à débugger pour pas grand chose

[sdec25]

les variables n'avaient pas à être plus globales quelles ne l'étaient déja : a l'appel de la fonction GenericTCPClient, tout ce petit monde devait etre reinitialisé bien sur.

Une variable définie dans une fonction tu appelles ça global ?
Avec ton switch il y a 2 cas distincts : tu initialise la variable OU tu testes sa valeur.

[invite304155d6]

c'était "global" par rapport à mon switch sur l'état actuel de la machine à état. Le terme n'était peut etre pas super correct effectivement.

En tout cas tout fonctionne (ou presque) à présent, et j'ai pu apprécier la rapidité et l'efficacité de ce forum !

Merci encore