2 * WARNING: be careful changing this code, it is very timing dependent
10 #include <avr/interrupt.h>
11 #include <util/delay.h>
17 #define _delay_sub_us(x) __builtin_avr_delay_cycles(x)
19 // Serial pulse period in microseconds.
20 #define SELECT_SERIAL_SPEED 1
21 #if SELECT_SERIAL_SPEED == 0
23 #define SERIAL_DELAY 4 // micro sec
24 #define READ_WRITE_START_ADJUST 30 // cycles
25 #define READ_WRITE_WIDTH_ADJUST 10 // cycles
26 #elif SELECT_SERIAL_SPEED == 1
28 #define SERIAL_DELAY 6 // micro sec
29 #define READ_WRITE_START_ADJUST 23 // cycles
30 #define READ_WRITE_WIDTH_ADJUST 10 // cycles
31 #elif SELECT_SERIAL_SPEED == 2
33 #define SERIAL_DELAY 12 // micro sec
34 #define READ_WRITE_START_ADJUST 25 // cycles
35 #define READ_WRITE_WIDTH_ADJUST 10 // cycles
36 #elif SELECT_SERIAL_SPEED == 3
38 #define SERIAL_DELAY 24 // micro sec
39 #define READ_WRITE_START_ADJUST 25 // cycles
40 #define READ_WRITE_WIDTH_ADJUST 10 // cycles
41 #elif SELECT_SERIAL_SPEED == 4
43 #define SERIAL_DELAY 50 // micro sec
44 #define READ_WRITE_START_ADJUST 25 // cycles
45 #define READ_WRITE_WIDTH_ADJUST 10 // cycles
47 #error Illegal Serial Speed
51 #define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
52 #define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
54 #define SLAVE_INT_WIDTH 1
55 #define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
57 uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
58 uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
60 #define SLAVE_DATA_CORRUPT (1<<0)
61 volatile uint8_t status = 0;
64 void serial_delay(void) {
65 _delay_us(SERIAL_DELAY);
69 void serial_delay_half1(void) {
70 _delay_us(SERIAL_DELAY_HALF1);
74 void serial_delay_half2(void) {
75 _delay_us(SERIAL_DELAY_HALF2);
79 void serial_output(void) {
80 SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
83 // make the serial pin an input with pull-up resistor
85 void serial_input_with_pullup(void) {
86 SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
87 SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
91 uint8_t serial_read_pin(void) {
92 return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
96 void serial_low(void) {
97 SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
101 void serial_high(void) {
102 SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
105 void serial_master_init(void) {
110 void serial_slave_init(void) {
111 serial_input_with_pullup();
113 #if SERIAL_PIN_MASK == _BV(PD0)
116 // Trigger on falling edge of INT0
117 EICRA &= ~(_BV(ISC00) | _BV(ISC01));
118 #elif SERIAL_PIN_MASK == _BV(PD2)
121 // Trigger on falling edge of INT2
122 EICRA &= ~(_BV(ISC20) | _BV(ISC21));
124 #error unknown SERIAL_PIN_MASK value
128 // Used by the sender to synchronize timing with the reciver.
130 void sync_recv(void) {
131 for (int i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
133 // This shouldn't hang if the slave disconnects because the
134 // serial line will float to high if the slave does disconnect.
135 while (!serial_read_pin());
138 // Used by the reciver to send a synchronization signal to the sender.
140 void sync_send(void) {
146 // Reads a byte from the serial line
148 uint8_t serial_read_byte(void) {
150 _delay_sub_us(READ_WRITE_START_ADJUST);
151 for ( uint8_t i = 0; i < 8; ++i) {
152 serial_delay_half1(); // read the middle of pulses
153 byte = (byte << 1) | serial_read_pin();
154 _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
155 serial_delay_half2();
160 // Sends a byte with MSB ordering
162 void serial_write_byte(uint8_t data) {
173 serial_low(); // sync_send() / senc_recv() need raise edge
176 // interrupt handle to be used by the slave device
177 ISR(SERIAL_PIN_INTERRUPT) {
181 uint8_t checksum = 0;
182 for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
184 serial_write_byte(serial_slave_buffer[i]);
185 checksum += serial_slave_buffer[i];
188 serial_write_byte(checksum);
190 // slave switch to input
192 serial_delay_half1(); //1
194 serial_input_with_pullup(); //2
195 serial_delay_half1(); //3
197 // slave recive phase
198 uint8_t checksum_computed = 0;
199 for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
201 serial_master_buffer[i] = serial_read_byte();
202 checksum_computed += serial_master_buffer[i];
205 uint8_t checksum_received = serial_read_byte();
207 if ( checksum_computed != checksum_received ) {
208 status |= SLAVE_DATA_CORRUPT;
210 status &= ~SLAVE_DATA_CORRUPT;
213 sync_recv(); //weit master output to high
217 bool serial_slave_DATA_CORRUPT(void) {
218 return status & SLAVE_DATA_CORRUPT;
221 // Copies the serial_slave_buffer to the master and sends the
222 // serial_master_buffer to the slave.
226 // 1 => slave did not respond
227 // 2 => checksum error
228 int serial_update_buffers(void) {
229 // this code is very time dependent, so we need to disable interrupts
232 // signal to the slave that we want to start a transaction
235 _delay_us(SLAVE_INT_WIDTH);
237 // wait for the slaves response
238 serial_input_with_pullup();
239 _delay_us(SLAVE_INT_RESPONSE_TIME);
241 // check if the slave is present
242 if (serial_read_pin()) {
243 // slave failed to pull the line low, assume not present
250 // master recive phase
251 // if the slave is present syncronize with it
253 uint8_t checksum_computed = 0;
254 // receive data from the slave
255 for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
257 serial_slave_buffer[i] = serial_read_byte();
258 checksum_computed += serial_slave_buffer[i];
261 uint8_t checksum_received = serial_read_byte();
263 if (checksum_computed != checksum_received) {
270 // master switch to output
274 serial_output(); // 3
275 serial_delay_half1(); //4
278 uint8_t checksum = 0;
280 for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
282 serial_write_byte(serial_master_buffer[i]);
283 checksum += serial_master_buffer[i];
286 serial_write_byte(checksum);
288 // always, release the line when not in use