tmk_core/protocol/serial_soft.c

   1 /*
   2 Copyright 2012 Jun WAKO <wakojun@gmail.com>
   3
   4 This software is licensed with a Modified BSD License.
   5 All of this is supposed to be Free Software, Open Source, DFSG-free,
   6 GPL-compatible, and OK to use in both free and proprietary applications.
   7 Additions and corrections to this file are welcome.
   8
   9
  10 Redistribution and use in source and binary forms, with or without
  11 modification, are permitted provided that the following conditions are met:
  12
  13 * Redistributions of source code must retain the above copyright
  14   notice, this list of conditions and the following disclaimer.
  15
  16 * Redistributions in binary form must reproduce the above copyright
  17   notice, this list of conditions and the following disclaimer in
  18   the documentation and/or other materials provided with the
  19   distribution.
  20
  21 * Neither the name of the copyright holders nor the names of
  22   contributors may be used to endorse or promote products derived
  23   from this software without specific prior written permission.
  24
  25 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  29 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35 POSSIBILITY OF SUCH DAMAGE.
  36 */
  37
  38 #include <stdbool.h>
  39 #include <avr/io.h>
  40 #include <avr/interrupt.h>
  41 #include <util/delay.h>
  42 #include "serial.h"
  43
  44 /*
  45  *  Stupid Inefficient Busy-wait Software Serial
  46  *  which is still useful for negative logic signal like Sun protocol
  47  *  if it is not supported by hardware UART.
  48  *
  49  *  TODO: delay is not accurate enough. Instruction cycle should be counted and inline assemby is needed.
  50  */
  51
  52 #define WAIT_US     (1000000L/SERIAL_SOFT_BAUD)
  53
  54 #ifdef SERIAL_SOFT_LOGIC_NEGATIVE
  55     #define SERIAL_SOFT_RXD_IN()        !(SERIAL_SOFT_RXD_READ())
  56     #define SERIAL_SOFT_TXD_ON()        SERIAL_SOFT_TXD_LO()
  57     #define SERIAL_SOFT_TXD_OFF()       SERIAL_SOFT_TXD_HI()
  58 #else
  59     #define SERIAL_SOFT_RXD_IN()        !!(SERIAL_SOFT_RXD_READ())
  60     #define SERIAL_SOFT_TXD_ON()        SERIAL_SOFT_TXD_HI()
  61     #define SERIAL_SOFT_TXD_OFF()       SERIAL_SOFT_TXD_LO()
  62 #endif
  63
  64 #ifdef SERIAL_SOFT_PARITY_EVEN
  65     #define SERIAL_SOFT_PARITY_VAL      0
  66 #elif defined(SERIAL_SOFT_PARITY_ODD)
  67     #define SERIAL_SOFT_PARITY_VAL      1
  68 #endif
  69
  70 /* debug for signal timing, see debug pin with oscilloscope */
  71 #ifdef SERIAL_SOFT_DEBUG
  72     #define SERIAL_SOFT_DEBUG_INIT()    (DDRD |= 1<<7)
  73     #define SERIAL_SOFT_DEBUG_TGL()     (PORTD ^= 1<<7)
  74 #else
  75     #define SERIAL_SOFT_DEBUG_INIT()
  76     #define SERIAL_SOFT_DEBUG_TGL()
  77 #endif
  78
  79
  80 void serial_init(void)
  81 {
  82     SERIAL_SOFT_DEBUG_INIT();
  83
  84     SERIAL_SOFT_RXD_INIT();
  85     SERIAL_SOFT_TXD_INIT();
  86 }
  87
  88 /* RX ring buffer */
  89 #define RBUF_SIZE   8
  90 static uint8_t rbuf[RBUF_SIZE];
  91 static uint8_t rbuf_head = 0;
  92 static uint8_t rbuf_tail = 0;
  93
  94
  95 uint8_t serial_recv(void)
  96 {
  97     uint8_t data = 0;
  98     if (rbuf_head == rbuf_tail) {
  99         return 0;
 100     }
 101
 102     data = rbuf[rbuf_tail];
 103     rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
 104     return data;
 105 }
 106
 107 int16_t serial_recv2(void)
 108 {
 109     uint8_t data = 0;
 110     if (rbuf_head == rbuf_tail) {
 111         return -1;
 112     }
 113
 114     data = rbuf[rbuf_tail];
 115     rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
 116     return data;
 117 }
 118
 119 void serial_send(uint8_t data)
 120 {
 121     /* signal state: IDLE: ON, START: OFF, STOP: ON, DATA0: OFF, DATA1: ON */
 122
 123 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 124     #ifdef SERIAL_SOFT_DATA_7BIT
 125     uint8_t mask = 0x40;
 126     #else
 127     uint8_t mask = 0x80;
 128     #endif
 129 #else
 130     uint8_t mask = 0x01;
 131 #endif
 132
 133     uint8_t parity = 0;
 134
 135     /* start bit */
 136     SERIAL_SOFT_TXD_OFF();
 137     _delay_us(WAIT_US);
 138
 139 #ifdef SERIAL_SOFT_DATA_7BIT
 140     while (mask&0x7F) {
 141 #else
 142     while (mask&0xFF) {
 143 #endif
 144         if (data&mask) {
 145             SERIAL_SOFT_TXD_ON();
 146             parity ^= 1;
 147         } else {
 148             SERIAL_SOFT_TXD_OFF();
 149         }
 150         _delay_us(WAIT_US);
 151
 152 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 153         mask >>= 1;
 154 #else
 155         mask <<= 1;
 156 #endif
 157     }
 158
 159 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 160     /* to center of parity bit */
 161     if (parity != SERIAL_SOFT_PARITY_VAL) {
 162         SERIAL_SOFT_TXD_ON();
 163     } else {
 164         SERIAL_SOFT_TXD_OFF();
 165     }
 166     _delay_us(WAIT_US);
 167 #endif
 168
 169     /* stop bit */
 170     SERIAL_SOFT_TXD_ON();
 171     _delay_us(WAIT_US);
 172 }
 173
 174 /* detect edge of start bit */
 175 ISR(SERIAL_SOFT_RXD_VECT)
 176 {
 177     SERIAL_SOFT_DEBUG_TGL();
 178     SERIAL_SOFT_RXD_INT_ENTER();
 179
 180     uint8_t data = 0;
 181
 182 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 183     #ifdef SERIAL_SOFT_DATA_7BIT
 184     uint8_t mask = 0x40;
 185     #else
 186     uint8_t mask = 0x80;
 187     #endif
 188 #else
 189     uint8_t mask = 0x01;
 190 #endif
 191
 192     uint8_t parity = 0;
 193
 194     /* to center of start bit */
 195     _delay_us(WAIT_US/2);
 196     SERIAL_SOFT_DEBUG_TGL();
 197     do {
 198         /* to center of next bit */
 199         _delay_us(WAIT_US);
 200
 201     SERIAL_SOFT_DEBUG_TGL();
 202         if (SERIAL_SOFT_RXD_IN()) {
 203             data |= mask;
 204             parity ^= 1;
 205         }
 206 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 207         mask >>= 1;
 208 #else
 209         mask <<= 1;
 210 #endif
 211 #ifdef SERIAL_SOFT_DATA_7BIT
 212     } while (mask&0x7F);
 213 #else
 214     } while (mask&0xFF);
 215 #endif
 216
 217 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 218     /* to center of parity bit */
 219     _delay_us(WAIT_US);
 220     if (SERIAL_SOFT_RXD_IN()) { parity ^= 1; }
 221     SERIAL_SOFT_DEBUG_TGL();
 222 #endif
 223
 224     /* to center of stop bit */
 225     _delay_us(WAIT_US);
 226
 227     uint8_t next = (rbuf_head + 1) % RBUF_SIZE;
 228 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 229     if ((parity == SERIAL_SOFT_PARITY_VAL) && next != rbuf_tail) {
 230 #else
 231     if (next != rbuf_tail) {
 232 #endif
 233         rbuf[rbuf_head] = data;
 234         rbuf_head = next;
 235     }
 236
 237     SERIAL_SOFT_RXD_INT_EXIT();
 238     SERIAL_SOFT_DEBUG_TGL();
 239 }