Web client + FreeRTOS

Version imprimable

Salut,

Voila je voudrais mettre une requête à un serveur dans une tache FreeRTOS mais ça ne fonctionne pas
voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
// Les bibliothèques utilisées :
#include <SoftwareSerial.h>
#include <Ethernet.h>
#include <SPI.h>
#include <FreeRTOS_AVR.h>
 
int a,b;
 
// L'adresse IP de l'Arduino dans le cas où elle n'est pas donnée par le serveur DHCP :
IPAddress IPArduino(192,168,1,10);
 
// L'adresse MAC de l'Arduino :
byte MACArduino[]={0xDE,0xAD,0xBE,0xEF,0xFE,0xED};
 
// L'adresse IP du serveur :
char IPServeur[]="192.168.1.4";
 
// Instanciation de la classe EthernetClient :
EthernetClient client; 
 
// Définition des pins 2 et 3 comme un port série (2=RX 3=TX) :
SoftwareSerial MonNouveauPortSerie(3,4); 
 
// Variable pour lire le code du tag RFID :
char val;
 
// Variable utilisée pour indexer le tableau "code[11]" :
int bytesread;
 
// Tableau servant à stocker la trame de 11 octets du code du tag RFID :
unsigned char code[11];
 
//---------------------------------------------------------------------------------------------
//--------------------------------------- Fonction tache 2--------------------------------------------
//---------------------------------------------------------------------------------------------
void FontionTache_2()
  {
//================== PARTIE RFID ==================//
 
  // Si des données sont présentes sur le nouveau port série " le lecteur a detecté un tag RFID " :
  if (MonNouveauPortSerie.available()) {
 
    bytesread = 0;
 
    while (bytesread<11) {
 
      if (MonNouveauPortSerie.available() > 0) {
 
        val = MonNouveauPortSerie.read();
        code[bytesread] =val;
       // Serial.print(code[bytesread],HEX);
        bytesread++;
 
        }
 
      }
 
    // Declancher un bip:
    digitalWrite(PinBuzzer,HIGH);
    delay(100);
    digitalWrite(PinBuzzer,LOW);
 
    // Vider le buffer du nouveau port série :   
    MonNouveauPortSerie.flush();
 
    }
 
    // connexion et envoie du code du tag RFID lu vers la base de données :
  if (client.connect(IPServeur, 80)) {
 
   // Serial.println("1) ->->-> Connecte a la base de donnee.");
   // Serial.println("envoie du RFID a la base de donnee :");
 
    // Faire une requete HTTP vers la page web de traitement des RFID :
    client.print("GET /site2/traitement_medecin_ajax_rfid.php?");
    client.print("rfid=");      
    client.print(code[0],HEX);      
    client.print(code[1],HEX);
    client.print(code[2],HEX);
    client.print(code[3],HEX);
    client.print(code[4],HEX);
    client.print(code[5],HEX);
    client.print(code[6],HEX);
    client.print(code[7],HEX);
    client.print(code[8],HEX);
    client.print(code[9],HEX);
    client.println(code[10],HEX);
    client.println(" HTTP/1.1");
    client.println("Host:192.168.1.5" );
 
    // Deconnexion :
    client.stop();      
   // Serial.println("RFID envoye a la base de donnee." );
 
    }
 
  // Echec lors de la connexion :
  else {
 
   // Serial.println("Erreur lors de l'envoie du RFID a la base de donnee.\n");
 
    }
 
  }
 
 
//---------------------------------------------------------------------------------------------
//--------------------------------------- Blink_LED--------------------------------------------
//---------------------------------------------------------------------------------------------
void Blink_LED(const uint8_t Led, int Delay)
  {
    digitalWrite(Led, HIGH);
    delay(Delay);
    //vTaskDelay((Delay * configTICK_RATE_HZ) / 1000L);
    digitalWrite(Led, LOW);
  }
 
//-------------------------------------------------------------------------------------------
//------------------------------------- Tache 1 ---------------------------------------------
//-------------------------------------------------------------------------------------------
void Tache_1(void * pvParameters ) 
  {
    while (1) 
      {
        Blink_LED(9, 100);
        vTaskDelay(5000);
      }
  }
//---------------------------------------------------------------------------------------------
//--------------------------------------- Tache 2 ---------------------------------------------
//---------------------------------------------------------------------------------------------
void Tache_2(void * pvParameters )
  {
    while (1) 
      {
        FontionTache_2();
        vTaskDelay(500);
      }
  }
 
//---------------------------------------------------------------------------------------------
//--------------------------------------- Setup -----------------------------------------------
//---------------------------------------------------------------------------------------------
void setup() 
  {
 
  // Initialisation du nouveau port série :
  MonNouveauPortSerie.begin(9600); 
 
  // Initialisation du port série de l'Arduino :
  Serial.begin(9600); 
 
  // Initialisation de l'Arduino Ethernet avec une addresse MAC et IP :
  Ethernet.begin(MACArduino,IPArduino);
 
    pinMode(9, OUTPUT);  // configuration de pin 13 en sortie
 
//************ Création de trois taches périodiques *****
    xTaskCreate(Tache_1, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(Tache_2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
 
//*********** Lancement du Scheduler ********************
    vTaskStartScheduler();
    while(1);
}
//------------------------------------------------------------------------------
 
void loop() 
  {
 
  }

si je remplace le code de la requete par autre chose genre clignoter une autre led , les deux taches s'exécutent normalement ça coince à partir de if (client.connect)

REMERCIEMENTS...

11/05/2015, 23h50
Vincent PETIT

Salut,
Petite suggestion, si tu créais qu'une seule tâche est ce que ça fonctionne ? Ce que je veux dire c'est plutôt as tu tenter d'isoler le code de la requête pour t'assurer qu'il fonctionne hors os temps réel ?
12/05/2015, 05h39
nad_ii

salut,

oui il fonctionne parfaitement

Bonjour,

Quel est le code erreur retourné par la fonction connect ?
Modifie ton code comme suit :
Code:

1 2 3 4 5 6 7 8 result = client.connect(IPServeur, 80); if (result==1) { // Traitement ... } else{ Serial.print("Erreur lors de l'envoie du RFID a la base de donnee. Code erreur: "); Serial.println(result); }
Avec le code erreur retourné, dirige toi sur cette page pour avoir de plus amples informations : http://www.arduino.cc/en/Reference/ClientConnect

Cdlt, dM

12/05/2015, 16h51
Vincent PETIT

Bonne suggestion de deleteme, donne nous le code d'erreur.

Autre remarque :
- Comme le code fonctionne lorsqu'il est isolé
- Comme tu as fait des tests en remplaçant la requête par un test LED et que ça fonctionne

Je pense que le soucis (ou conflit) vient de freeRTOS. Peut être que la pile n'est pas suffisante pour empiler la tâche2 puis la dépiler.

Il faut que je regarde les fonctions vTaskDelay() et xTaskCreate() pour comprendre un peu ce qui se passe.
A bientôt.

Salut,
Je viens de regarder un peu plus en profondeur ton OS temps réel FreeRTOS et je crains fort que tu sois confronté à un problème de taille (sans jeu de mot) !
Pour calculer la taille de ta stack dans ta fonction

Code:

xTaskCreate(Tache_2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);

il va falloir que tu connaisses l'occupation mémoire de toute ta tâche et de ses fonctions dont celle d'Arduino :aie:

Regarde comment se passe la détermination de "configMINIMAL_STACK_SIZE"
source : http://www.socialledge.com/sjsu/inde...eRTOS_Tutorial
J'ai mis mes traductions entre parenthèses

Code:

1
2
3
4
5
6
7
8
9
10
 
// exemple de tâche
void hello_world_task(void* p)
{
    char mem[128];
    while(1) {
    }
}
//The task above uses 128 bytes of stack. 
// (la pile a besoin d'avoir une taille de 128 octets que sont char mem[128])

Code:

1
2
3
4
5
6
7
8
9
10
11
 
// exemple de tâche
void hello_world_task(void* p)
{
    char mem[128];
    int  int_mem[128]; // 4 bytes per int
    while(1) {
    }
}
// The task above uses 128+ (128*4) bytes of stack. 
// (la pile a besoin d'avoir une taille de 128 octets + 128 variables de type int qui font 32 bits soit 4 octets)

Code:

1
2
3
4
5
6
7
8
9
10
11
 
// exemple de tâche
void hello_world_task(void* p)
{
    char mem[128];
    while(1) {
        foo(); // Assume foo uses 128 bytes of stack.
    }
}
// The task above uses 128+128 bytes of stack.
//(la pile a besoin d'avoir une taille de 128 octets + ce que la fonction foo consomme en mémoire)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
// exemple de tâche
void hello_world_task(void* p)
{
    char mem[128];
    while(1) {
        if(...) {
            char mem_one[128];
        }
        else(...) {
            char mem_two[256];
        }
    }
}
/* The task above uses 128 + 256 bytes of stack.  
 * Note that it is not 128+128+256, because only one branch statement
 * will execute and in the worst case, branch two's code will end up 
 * using 128+256 bytes of stack.
 */
// (la pile a besoin de 128 octets pour char mem[128] + le pire des cas dans le if else car
// seulement une des 2 branches sera utilisés à la fois donc 256 octets est le cas le plus défavorable)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
// exemple de tâche
void hello_world_task(void* p)
{
    char *mem = char* malloc(128);
    while(1) {
    }
}
// The task above uses just 4 bytes of stack (to hold mem pointer)
// The actual memory comes from HEAP, which is not part of the stack.
// (la pile a besoin de 4 octets pour mémoriser le pointeur vers l'espace allouée hors de la pile dans le tas)
// petit rappel : le tas c'est la mémoire RAM de ton µC et l'autre segment mémoire est la pile
// quand tu imbriques des fonctions les variables locales sont dans la pile, comme ça ton programme entre dans les fonctions 
// et en sort en ayant mémorisé l'endroit d'où il arrive et il reprend ce qu'il est sensé faire. quand tu déclares une variable globale, 
// ou que tu alloues avec malloc un espace mémoire, par exemple elle est dans le tas et non plus dans la pile

As tu calculé l'occupation mémoire de la tâche 2 mais aussi de toutes les fonctions Arduino afin de voir combien de place ça prend ?

Tu es sur quel micro-contrôleur ? Un Atmel quoi ?