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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#include <Arduino.h>
#include "data.h"
#include "cmd.h"
#include <elapsedMillis.h>
SDATA *pDeb ; // pointer sur premiere Data
/*
* debug procedure pour aafichier la RAM dispo
*/
int freeRam ()
{
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
/*
initilise une liste chainée des DATA
*/
/*
schema classique
Les DELAIS sont données en 1/10 de ms
L;4;1;0^0;185^2;200^0;300^
L --> commande LOAD
4 --> nombre de date set
1;0 --> premiere data , la valve 1 open sans delais
^
0;185 --> toutes les vannes fermées apres 185 ms
^
2;200 --> apres 1,5 ms, ouverture de la vanne 2
^
0;300 --> apre 10,0ms, fermeture de la vanne
^
schema moins classique
L;8;1;0^3;100^7;110^6;185^4;200^0;230^8;1500^0;3300^
1;0
a T0 ouverture vanne 1 pour 185ms PORTB = 1
3;100
a T0 + 10,0 ms ouverture vane 2 pour 10,0ms ( V1 et V2 ouvert ) PORTB = 3
7;110
a T0 + 11,0 ms ouverture vanne 3 pour 12,0ms ( V1 V2 V3 ouverts ) PORTB = 7
6;185
a T0 + 18,5 ms fermeture vanne 1 ( V2 V3 ouvert ) PORTB = 6
4;200
a T0 + 20,0 ms fermeture vanne 2 ( V3 ouvert ) PORTB = 4
0;230
a T0 + 23,0 ms fermeture vanne 3 PORTB = 0
8;1500
a T0 + 150,0 ms ouverture APN, PORTB = 8
0;3300
a T0 + 330,0 ms Fermeture APN PORTB = 0
*/
/*
* Les data sont chargées dans un liste chainée de pointer SDATA
typedef struct SDATA {
unsigned long Wait ; --> delais pour changer l'etat du PORTB
char Valve ; --> etat du PORTB apres le delais
SDATA *suivi ;
} ;
*/
void processLoadData() {
short int i ;
unsigned int iValve ;
unsigned long iWait ;
char N ; // nombre des item de la liste SDATA
SDATA *data ;
SDATA *pBck ; // pointer de backup d'une Data
if (pDeb != NULL) cleanData() ;
pDeb = NULL ;
pBck = NULL ;
// recuperation du nombre de DATA a traiter
if (sscanf(strtok(NULL, FIELD_SEPARATOR), "%d", &N ) < 1) {
logging(ERROR, "load Wrong Format");
return;
}
// chargement de la liste chainée
for ( i = 0; i < N ; i++) {
iWait = 0 ;
iValve = 0 ;
sscanf( strtok(NULL, "^" ), "%d;%d", &iValve, &iWait) ;
data = (SDATA *) malloc(sizeof(struct SDATA )) ;
if ( data == 0 ) {
logging(DEBUG, "erreur memoire");
}
// les valeur DELAIS sont passées en 0,1 mS == 100 µS
// on les multiple par 100 les avoir en µS
// precision du compteur superMicros
data->Wait = iWait * 100 ; /* precision 1/10 de ms */
data->Valve = iValve ;
data->suivi = NULL ;
if (pBck == NULL ) {
pDeb = data ;
pBck = data ;
}
else {
pBck->suivi = data ;
pBck = data ;
}
}
// logging(DEBUG, "fin de load");
// printdata () ;
}
/*
* petite procedure pour verifier le bon chargement des datas
*/
void printdata () {
SDATA *pdata = pDeb;
char buffer[100];
while ( pdata != NULL) {
buffer[0] = '\0' ;
Serial.println("-------------");
sprintf(buffer, "v:%d : %lu ", pdata->Valve, pdata->Wait );
Serial.println(buffer);
Serial.println("-------------");
pdata = pdata->suivi ;
}
}
void cleanData () {
SDATA *data = pDeb;
while ( data != NULL) {
SDATA *next = data->suivi ;
free(data) ;
data = next ;
}
pDeb = NULL ;
Serial.print("Free memory: ");
Serial.println(freeRam() );
}
/*
* on parcours la liste des data SDATA
* pour chaque item on attend les delais data->Wait pour initialiser le PPORTB avec data->Valve
*/
void execRunCommand() {
SDATA *data = pDeb;
volatile uint8_t _valve ;
// arret de toutes les vannes
//PORTB = PORTB & B11110000;
//PORTB = 240 ;
PORTB = 0 ;
elapsedMicros waiting ;
// data = pDeb;
waiting = 0 ;
while ( data != NULL) {
while ( waiting < data->Wait ) { }
// PORTB = data->Valve ;
/*
* test avec une intruction code machine, pas concluant
*/
_valve = data->Valve ;
asm volatile( "out %1, %0" "\n\t" : : "r"(_valve) , "I" (_SFR_IO_ADDR(PORTB)));
waiting = data->Wait ;
data = data->suivi ;
}
} |
