Mercurial > hp34970-firmware / file comparison

comparison: src/hp34comm.h

src/hp34comm.h

changeset 19
a52d60613cf7
parent 18
4fd621551d55
child 21
9ffa9d727d80
equal deleted inserted replaced
18:4fd621551d55 19:a52d60613cf7
20 uint8_t cmd; 20 uint8_t cmd;
21 uint8_t size; 21 uint8_t size;
22 char value[MAX_BUFF+1]; 22 char value[MAX_BUFF+1];
23 unsigned long id; 23 unsigned long id;
24 } CMD; 24 } CMD;
25
26
27 25
28 HPSerial(PinName tx, PinName rx); 26 HPSerial(PinName tx, PinName rx);
29 27
30 bool cmd_available(void); 28 bool cmd_available(void);
31 bool pop(CMD& cmd); 29 bool pop(CMD& cmd);
32 bool cmd_buf_full(void); 30 bool cmd_buf_full(void);
33 unsigned int nerrors(uint8_t errorno); 31 unsigned int nerrors(uint8_t errorno);
34 32
33 void startup(void);
34 void send(const uint8_t *buf, uint8_t size);
35 void sendkey(uint8_t keycode);
35 36
36 private: 37 private:
37 void pushCmd(uint8_t cmd, uint8_t size, char *payload); 38 void pushCmd(uint8_t cmd, uint8_t size, char *payload);
38 void rxIrq(void); 39 void rxIrq(void);
39 void timeout(void); 40 void timeout(void);
41 void set_timer(float v=0.0) {
42 timeouter.detach();
43 if (v > 0.0)
44 timeouter.attach(callback(this, &HPSerial::timeout), v);
45 }
40 46
41 private: 47 private:
42 RawSerial serial; 48 RawSerial serial;
43 uint8_t buf[BUF_SIZE]; 49 uint8_t buf[BUF_SIZE];
44 uint8_t head; 50 uint8_t head;
45 CircularBuffer<CMD, 32> cmdbuf; 51 CircularBuffer<CMD, 32> cmdbuf;
46 unsigned long ncmd; 52 unsigned long ncmd;
47 unsigned int errs[MAX_ERRS]; 53 unsigned int errs[MAX_ERRS];
48 Ticker timeouter; 54 Ticker timeouter;
49 55
50 // state machine stuff 56 public:
51 typedef enum {STATE_IDLE, 57 // global state machine
52 STATE_HANDCHEKED, 58 typedef enum {
53 STATE_COMMAND, 59 GSTATE_STARTING,
54 STATE_PAYLOAD_SIZE, 60 GSTATE_STARTING2,
55 STATE_PAYLOAD, 61 GSTATE_IDLE,
56 NUM_STATES} state_t; 62 GSTATE_TX,
57 63 GSTATE_RX,
64 NUM_GSTATES} gstate_t;
65 gstate_t gstate() {return cur_gstate;};
66 /* gstate_t do_start(); */
67 /* gstate_t do_send(); */
68 /* gstate_t do_receive(); */
58 69
59 typedef struct instance_data { 70 /* typedef gstate_t(HPSerial::*gstatemethod)(); */
71 /* statemethod const gstate_table[NUM_GSTATES] = { */
72 /* &HPSerial::do_start, */
73 /* &HPSerial::do_send, */
74 /* &HPSerial::do_receive, */
75 /* }; */
76
77 /* gstate_t run_gstate(gstate_t cur_state); */
78 private:
79 gstate_t cur_gstate;
80
81 public:
82 // transmission state machine
83 typedef enum {
84 STATE_IDLE,
85 STATE_COMMAND,
86 STATE_PAYLOAD_SIZE,
87 STATE_PAYLOAD,
88 STATE_SENDING,
89 STATE_EOT,
90 NUM_STATES} state_t;
91 state_t state() {return cur_state;};
92
93 private:
94 typedef struct state_data {
60 uint8_t cmd; 95 uint8_t cmd;
61 uint8_t size; 96 uint8_t size;
62 uint8_t received; 97 uint8_t pos;
63 char payload[MAX_BUFF]; 98 char payload[MAX_BUFF];
64 } instance_data_t; 99 } state_data_t;
65 100
66 state_t do_state_initial(instance_data_t *data, uint8_t c); 101 void _startup(void);
67 state_t do_state_handcheck(instance_data_t *data, uint8_t c); 102 void _startup2(void);
68 state_t do_state_command(instance_data_t *data, uint8_t c); 103 state_t do_state_initial(uint8_t c=0x00);
69 state_t do_state_payload_size(instance_data_t *data, uint8_t c); 104 state_t do_state_command(uint8_t c);
70 state_t do_state_payload(instance_data_t *data, uint8_t c); 105 state_t do_state_payload_size(uint8_t c);
106 state_t do_state_payload(uint8_t c);
107 state_t do_state_sending(uint8_t c=0x00);
108 state_t do_state_eot(uint8_t c=0x00);
71 109
72 void send_ack(uint8_t c); 110 void send_ack(uint8_t c);
73 111
74 // pointer to "state method" (ie. one of the just above) 112 typedef state_t(HPSerial::*statemethod)(uint8_t c);
75 typedef state_t(HPSerial::*statemethod)(instance_data_t *data, uint8_t c); 113 static statemethod state_table[NUM_STATES];
76 statemethod const state_table[NUM_STATES] = { 114 state_t run_state(state_t cur_state, uint8_t c);
77 &HPSerial::do_state_initial,
78 &HPSerial::do_state_handcheck,
79 &HPSerial::do_state_command,
80 &HPSerial::do_state_payload_size,
81 &HPSerial::do_state_payload,
82 };
83
84 state_t run_state(state_t cur_state, instance_data_t *data, uint8_t c);
85 115
86 state_t cur_state; 116 state_t cur_state;
87 instance_data rx_data; 117 state_data_t tr_data;
88 }; 118 };
89 119
120
90 #endif 121 #endif

Mercurial Repository: hp34970-firmware

mercurial