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 #define SERIAL_SOFT_DEBUG
  72 #ifdef SERIAL_SOFT_DEBUG
  73     #define SERIAL_SOFT_DEBUG_INIT()    (DDRD |= 1<<7)
  74     #define SERIAL_SOFT_DEBUG_TGL()     (PORTD ^= 1<<7)
  75 #else
  76     #define SERIAL_SOFT_DEBUG_INIT()
  77     #define SERIAL_SOFT_DEBUG_TGL()
  78 #endif
  79
  80
  81 void serial_init(void)
  82 {
  83     SERIAL_SOFT_DEBUG_INIT();
  84
  85     SERIAL_SOFT_RXD_INIT();
  86     SERIAL_SOFT_TXD_INIT();
  87 }
  88
  89 /* RX ring buffer */
  90 #define RBUF_SIZE   8
  91 static uint8_t rbuf[RBUF_SIZE];
  92 static uint8_t rbuf_head = 0;
  93 static uint8_t rbuf_tail = 0;
  94
  95
  96 uint8_t serial_recv(void)
  97 {
  98     uint8_t data = 0;
  99     if (rbuf_head == rbuf_tail) {
 100         return 0;
 101     }
 102
 103     data = rbuf[rbuf_tail];
 104     rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
 105     return data;
 106 }
 107
 108 int16_t serial_recv2(void)
 109 {
 110     uint8_t data = 0;
 111     if (rbuf_head == rbuf_tail) {
 112         return -1;
 113     }
 114
 115     data = rbuf[rbuf_tail];
 116     rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
 117     return data;
 118 }
 119
 120 void serial_send(uint8_t data)
 121 {
 122     /* signal state: IDLE: ON, START: OFF, STOP: ON, DATA0: OFF, DATA1: ON */
 123
 124 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 125     uint8_t mask = 0x80;
 126 #else
 127     uint8_t mask = 0x01;
 128 #endif
 129
 130     uint8_t parity = 0;
 131
 132     /* start bit */
 133     SERIAL_SOFT_TXD_OFF();
 134     _delay_us(WAIT_US);
 135
 136     while (mask) {
 137         if (data&mask) {
 138             SERIAL_SOFT_TXD_ON();
 139             parity ^= 1;
 140         } else {
 141             SERIAL_SOFT_TXD_OFF();
 142         }
 143         _delay_us(WAIT_US);
 144
 145 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 146         mask >>= 1;
 147 #else
 148         mask <<= 1;
 149 #endif
 150     }
 151
 152 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 153     /* to center of parity bit */
 154     if (parity != SERIAL_SOFT_PARITY_VAL) {
 155         SERIAL_SOFT_TXD_ON();
 156     } else {
 157         SERIAL_SOFT_TXD_OFF();
 158     }
 159     _delay_us(WAIT_US);
 160 #endif
 161
 162     /* stop bit */
 163     SERIAL_SOFT_TXD_ON();
 164     _delay_us(WAIT_US);
 165 }
 166
 167 /* detect edge of start bit */
 168 ISR(SERIAL_SOFT_RXD_VECT)
 169 {
 170     SERIAL_SOFT_DEBUG_TGL();
 171     SERIAL_SOFT_RXD_INT_ENTER()
 172
 173     uint8_t data = 0;
 174
 175 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 176     uint8_t mask = 0x80;
 177 #else
 178     uint8_t mask = 0x01;
 179 #endif
 180
 181     uint8_t parity = 0;
 182
 183     /* to center of start bit */
 184     _delay_us(WAIT_US/2);
 185     SERIAL_SOFT_DEBUG_TGL();
 186     do {
 187         /* to center of next bit */
 188         _delay_us(WAIT_US);
 189
 190     SERIAL_SOFT_DEBUG_TGL();
 191         if (SERIAL_SOFT_RXD_IN()) {
 192             data |= mask;
 193             parity ^= 1;
 194         }
 195 #ifdef SERIAL_SOFT_BIT_ORDER_MSB
 196         mask >>= 1;
 197 #else
 198         mask <<= 1;
 199 #endif
 200     } while (mask);
 201
 202 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 203     /* to center of parity bit */
 204     _delay_us(WAIT_US);
 205     if (SERIAL_SOFT_RXD_IN()) { parity ^= 1; }
 206     SERIAL_SOFT_DEBUG_TGL();
 207 #endif
 208
 209     /* to center of stop bit */
 210     _delay_us(WAIT_US);
 211
 212     uint8_t next = (rbuf_head + 1) % RBUF_SIZE;
 213 #if defined(SERIAL_SOFT_PARITY_EVEN) || defined(SERIAL_SOFT_PARITY_ODD)
 214     if ((parity == SERIAL_SOFT_PARITY_VAL) && next != rbuf_tail) {
 215 #else
 216     if (next != rbuf_tail) {
 217 #endif
 218         rbuf[rbuf_head] = data;
 219         rbuf_head = next;
 220     }
 221
 222     SERIAL_SOFT_RXD_INT_EXIT();
 223     SERIAL_SOFT_DEBUG_TGL();
 224 }