Mercurial > hp34970-firmware / file comparison

comparison: src/hp34comm.cpp

src/hp34comm.cpp

changeset 21
9ffa9d727d80
parent 19
a52d60613cf7
child 28
424d792fea4f
equal deleted inserted replaced
20:b4658776abb6 21:9ffa9d727d80
8 8
9 DigitalOut inrx(D9); 9 DigitalOut inrx(D9);
10 10
11 #endif 11 #endif
12 12
13 DigitalOut lled(LED1); 13 DigitalOut lled(LED3);
14 14
15 #define RXTIMEOUT 0.05 15 #define RXTIMEOUT 0.05
16 #define STARTUPRETRY 0.5 16 #define STARTUPRETRY 0.5
17
17 const uint8_t startup_seq[] = { 18 const uint8_t startup_seq[] = {
18 0x33,
19 0x01,
20 0x01,
21 0x40,
22 // 0x02,
23 };
24
25 const uint8_t startup_seq2[] = {
26 0x33, 19 0x33,
27 0x02, 20 0x02,
28 0x00, 21 0x00,
29 0x00,
30 // 0x02,
31 }; 22 };
32 23
33 HPSerial::statemethod HPSerial::state_table[NUM_STATES] = { 24 HPSerial::statemethod HPSerial::state_table[NUM_STATES] = {
34 &HPSerial::do_state_initial, 25 &HPSerial::do_state_initial,
35 &HPSerial::do_state_command, 26 &HPSerial::do_state_command,
42 HPSerial::HPSerial(PinName tx, PinName rx): 33 HPSerial::HPSerial(PinName tx, PinName rx):
43 serial(tx, rx), 34 serial(tx, rx),
44 cur_gstate(GSTATE_IDLE), 35 cur_gstate(GSTATE_IDLE),
45 ncmd(0) 36 ncmd(0)
46 { 37 {
47 serial.baud(187500); 38 serial.baud(187500);
48 cur_state = STATE_IDLE; 39 cur_state = STATE_IDLE;
49 serial.attach(callback(this, &HPSerial::rxIrq), Serial::RxIrq); 40 serial.attach(callback(this, &HPSerial::rxIrq), Serial::RxIrq);
50 } 41 }
51 42
52 void HPSerial::startup(void) { 43 void HPSerial::startup(void) {
53 if (cur_gstate != GSTATE_STARTING) { 44 cur_gstate = GSTATE_STARTING;
54 //_startup();
55 cur_gstate = GSTATE_STARTING;
56 }
57 set_timer(0.002); // launch the startup in 10ms 45 set_timer(0.002); // launch the startup in 10ms
58 } 46 }
59 47
60 void HPSerial::_startup(void) 48 void HPSerial::_startup(void)
61 { 49 {
66 for(uint8_t i=0; i<tr_data.size; i++) 54 for(uint8_t i=0; i<tr_data.size; i++)
67 tr_data.payload[i] = startup_seq[i]; 55 tr_data.payload[i] = startup_seq[i];
68 cur_state = do_state_sending(); 56 cur_state = do_state_sending();
69 } 57 }
70 58
71 void HPSerial::_startup2(void)
72 {
73 cur_gstate = GSTATE_STARTING2;
74 tr_data.size = sizeof(startup_seq2);
75 tr_data.cmd = 0xFF;
76 tr_data.pos = 0;
77 for(uint8_t i=0; i<tr_data.size; i++)
78 tr_data.payload[i] = startup_seq2[i];
79 cur_state = do_state_sending();
80 }
81
82 void HPSerial::send(const uint8_t *buf, uint8_t size) 59 void HPSerial::send(const uint8_t *buf, uint8_t size)
83 { 60 {
84 // tx_data-> 61 // tx_data->
85 //send(startup, sizeof(startup)/sizeof(startup[0])); 62 //send(startup, sizeof(startup)/sizeof(startup[0]));
86 } 63 }
109 { 86 {
110 return cmdbuf.full(); 87 return cmdbuf.full();
111 } 88 }
112 89
113 unsigned int HPSerial::nerrors(uint8_t errorno) 90 unsigned int HPSerial::nerrors(uint8_t errorno)
114 { 91 {
115 return errs[errorno]; 92 return errs[errorno];
116 } 93 }
117 94
118 void HPSerial::pushCmd(uint8_t cmd, uint8_t size, char *payload) { 95 void HPSerial::pushCmd(uint8_t cmd, uint8_t size, char *payload) {
119 CMD val; 96 CMD val;
169 send_ack(0x00); 146 send_ack(0x00);
170 147
171 if (c == 0x86) { // shutdown 148 if (c == 0x86) { // shutdown
172 pushCmd(tr_data.cmd, tr_data.size, tr_data.payload); 149 pushCmd(tr_data.cmd, tr_data.size, tr_data.payload);
173 return HPSerial::STATE_IDLE; 150 return HPSerial::STATE_IDLE;
174 } 151 }
175 return STATE_PAYLOAD_SIZE; 152 return STATE_PAYLOAD_SIZE;
176 } 153 }
177 154
178 HPSerial::state_t HPSerial::do_state_payload_size(uint8_t c) 155 HPSerial::state_t HPSerial::do_state_payload_size(uint8_t c)
179 { 156 {
196 173
197 HPSerial::state_t HPSerial::do_state_sending(uint8_t c) 174 HPSerial::state_t HPSerial::do_state_sending(uint8_t c)
198 { 175 {
199 // ghee 176 // ghee
200 if (c == 0xFF) 177 if (c == 0xFF)
201 { 178 { // resend current char
202 tr_data.pos--; 179 tr_data.pos--;
203 tr_data.payload[tr_data.pos] += 1; 180 tr_data.payload[tr_data.pos] += 1;
204 } 181 }
205 // TODO: check ACK values (c is the received ack) 182 // TODO: check ACK values (c is the received ack)
206 if (tr_data.pos >= tr_data.size) 183 if (tr_data.pos >= tr_data.size)
207 { 184 {
208 return do_state_eot(); 185 return do_state_eot();
209 } 186 }
210 serial.putc(tr_data.payload[tr_data.pos++]); 187 serial.putc(tr_data.payload[tr_data.pos++]);
211 set_timer(RXTIMEOUT); 188 set_timer(RXTIMEOUT);
212 return HPSerial::STATE_SENDING; 189 return HPSerial::STATE_SENDING;
213 } 190 }
214 191
215 HPSerial::state_t HPSerial::do_state_eot(uint8_t c) 192 HPSerial::state_t HPSerial::do_state_eot(uint8_t c)
216 { 193 {
217 serial.putc(0x55); // EoT 194 serial.putc(0x55); // EoT
218 if (cur_gstate == GSTATE_STARTING) { 195 cur_gstate = GSTATE_IDLE;
219 cur_gstate = GSTATE_STARTING2; 196 set_timer(); // We are IDLE, detach the timeouter
220 set_timer(0.002); // launch startup2 in 10ms
221 }
222 else {
223 cur_gstate = GSTATE_IDLE;
224 set_timer(); // We are IDLE, detach the timeouter
225 }
226 return STATE_IDLE; 197 return STATE_IDLE;
227 } 198 }
228 199
229 HPSerial::state_t HPSerial::run_state(HPSerial::state_t cur_state, 200 HPSerial::state_t HPSerial::run_state(HPSerial::state_t cur_state,
230 uint8_t c) 201 uint8_t c)
232 return (this->*(HPSerial::state_table[cur_state]))(c); 203 return (this->*(HPSerial::state_table[cur_state]))(c);
233 }; 204 };
234 205
235 void HPSerial::rxIrq(void) { 206 void HPSerial::rxIrq(void) {
236 uint8_t val; 207 uint8_t val;
237 if(serial.readable()) { // no reason why we would end here without 208 if(serial.readable())
238 // this condition, but hey 209 { // no reason why we would end here without
210 // this condition, but hey
239 #ifdef DEBUG2 211 #ifdef DEBUG2
240 inrx=1; 212 inrx=1;
241 #endif 213 #endif
242 lled = 1; 214 //lled = 1;
243 val = serial.getc(); 215 val = serial.getc();
244 cur_state = run_state(cur_state, val); 216 cur_state = run_state(cur_state, val);
245 lled = 0; 217 //lled = 0;
246 #ifdef DEBUG2 218 #ifdef DEBUG2
247 inrx=0; 219 inrx=0;
248 #endif 220 #endif
249 } 221 }
250 } 222 }
252 224
253 void HPSerial::timeout(void) { 225 void HPSerial::timeout(void) {
254 set_timer(); // detach the timeouter 226 set_timer(); // detach the timeouter
255 if (cur_gstate == GSTATE_STARTING) 227 if (cur_gstate == GSTATE_STARTING)
256 _startup(); 228 _startup();
257 else if (cur_gstate == GSTATE_STARTING2)
258 _startup2();
259 else // reset 229 else // reset
260 { 230 {
261 cur_gstate = GSTATE_IDLE; 231 cur_gstate = GSTATE_IDLE;
262 cur_state = STATE_IDLE; 232 cur_state = STATE_IDLE;
263 } 233 }
264 } 234 }
265
266

Mercurial Repository: hp34970-firmware

mercurial