keyboards/vitamins_included/serial.c

   1 /*
   2  * WARNING: be careful changing this code, it is very timing dependent
   3  */
   4
   5 #ifndef F_CPU
   6 #define F_CPU 16000000
   7 #endif
   8
   9 #include <avr/io.h>
  10 #include <avr/interrupt.h>
  11 #include <util/delay.h>
  12 #include <stdbool.h>
  13 #include "serial.h"
  14
  15 #ifndef USE_I2C
  16
  17 // Serial pulse period in microseconds. Its probably a bad idea to lower this
  18 // value.
  19 #define SERIAL_DELAY 24
  20
  21 uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
  22 uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
  23
  24 #define SLAVE_DATA_CORRUPT (1<<0)
  25 volatile uint8_t status = 0;
  26
  27 inline static
  28 void serial_delay(void) {
  29   _delay_us(SERIAL_DELAY);
  30 }
  31
  32 inline static
  33 void serial_output(void) {
  34   SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
  35 }
  36
  37 // make the serial pin an input with pull-up resistor
  38 inline static
  39 void serial_input(void) {
  40   SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
  41   SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
  42 }
  43
  44 inline static
  45 uint8_t serial_read_pin(void) {
  46   return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
  47 }
  48
  49 inline static
  50 void serial_low(void) {
  51   SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
  52 }
  53
  54 inline static
  55 void serial_high(void) {
  56   SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
  57 }
  58
  59 void serial_master_init(void) {
  60   serial_output();
  61   serial_high();
  62 }
  63
  64 void serial_slave_init(void) {
  65   serial_input();
  66
  67   // Enable INT0
  68   EIMSK |= _BV(INT0);
  69   // Trigger on falling edge of INT0
  70   EICRA &= ~(_BV(ISC00) | _BV(ISC01));
  71 }
  72
  73 // Used by the master to synchronize timing with the slave.
  74 static
  75 void sync_recv(void) {
  76   serial_input();
  77   // This shouldn't hang if the slave disconnects because the
  78   // serial line will float to high if the slave does disconnect.
  79   while (!serial_read_pin());
  80   serial_delay();
  81 }
  82
  83 // Used by the slave to send a synchronization signal to the master.
  84 static
  85 void sync_send(void) {
  86   serial_output();
  87
  88   serial_low();
  89   serial_delay();
  90
  91   serial_high();
  92 }
  93
  94 // Reads a byte from the serial line
  95 static
  96 uint8_t serial_read_byte(void) {
  97   uint8_t byte = 0;
  98   serial_input();
  99   for ( uint8_t i = 0; i < 8; ++i) {
 100     byte = (byte << 1) | serial_read_pin();
 101     serial_delay();
 102     _delay_us(1);
 103   }
 104
 105   return byte;
 106 }
 107
 108 // Sends a byte with MSB ordering
 109 static
 110 void serial_write_byte(uint8_t data) {
 111   uint8_t b = 8;
 112   serial_output();
 113   while( b-- ) {
 114     if(data & (1 << b)) {
 115       serial_high();
 116     } else {
 117       serial_low();
 118     }
 119     serial_delay();
 120   }
 121 }
 122
 123 // interrupt handle to be used by the slave device
 124 ISR(SERIAL_PIN_INTERRUPT) {
 125   sync_send();
 126
 127   uint8_t checksum = 0;
 128   for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
 129     serial_write_byte(serial_slave_buffer[i]);
 130     sync_send();
 131     checksum += serial_slave_buffer[i];
 132   }
 133   serial_write_byte(checksum);
 134   sync_send();
 135
 136   // wait for the sync to finish sending
 137   serial_delay();
 138
 139   // read the middle of pulses
 140   _delay_us(SERIAL_DELAY/2);
 141
 142   uint8_t checksum_computed = 0;
 143   for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
 144     serial_master_buffer[i] = serial_read_byte();
 145     sync_send();
 146     checksum_computed += serial_master_buffer[i];
 147   }
 148   uint8_t checksum_received = serial_read_byte();
 149   sync_send();
 150
 151   serial_input(); // end transaction
 152
 153   if ( checksum_computed != checksum_received ) {
 154     status |= SLAVE_DATA_CORRUPT;
 155   } else {
 156     status &= ~SLAVE_DATA_CORRUPT;
 157   }
 158   contacted_by_master = true;
 159 }
 160
 161 inline
 162 bool serial_slave_DATA_CORRUPT(void) {
 163   return status & SLAVE_DATA_CORRUPT;
 164 }
 165
 166 // Copies the serial_slave_buffer to the master and sends the
 167 // serial_master_buffer to the slave.
 168 //
 169 // Returns:
 170 // 0 => no error
 171 // 1 => slave did not respond
 172 int serial_update_buffers(void) {
 173   // this code is very time dependent, so we need to disable interrupts
 174   cli();
 175
 176   // signal to the slave that we want to start a transaction
 177   serial_output();
 178   serial_low();
 179   _delay_us(1);
 180
 181   // wait for the slaves response
 182   serial_input();
 183   serial_high();
 184   _delay_us(SERIAL_DELAY);
 185
 186   // check if the slave is present
 187   if (serial_read_pin()) {
 188     // slave failed to pull the line low, assume not present
 189     sei();
 190     return 1;
 191   }
 192
 193   // if the slave is present syncronize with it
 194   sync_recv();
 195
 196   uint8_t checksum_computed = 0;
 197   // receive data from the slave
 198   for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
 199     serial_slave_buffer[i] = serial_read_byte();
 200     sync_recv();
 201     checksum_computed += serial_slave_buffer[i];
 202   }
 203   uint8_t checksum_received = serial_read_byte();
 204   sync_recv();
 205
 206   if (checksum_computed != checksum_received) {
 207     sei();
 208     return 1;
 209   }
 210
 211   uint8_t checksum = 0;
 212   // send data to the slave
 213   for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
 214     serial_write_byte(serial_master_buffer[i]);
 215     sync_recv();
 216     checksum += serial_master_buffer[i];
 217   }
 218   serial_write_byte(checksum);
 219   sync_recv();
 220
 221   // always, release the line when not in use
 222   serial_output();
 223   serial_high();
 224
 225   sei();
 226   return 0;
 227 }
 228
 229 #endif