wiring_serial.c

Go to the documentation of this file.

/*
 *  Copyright (c) 2005-2006 David A. Mellis
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 2.1 of the License, or
 *  (at your option) any later version.
   
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
  
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 

#include "wiring_private.h"

#ifndef __WASPCONSTANTS_H__
#include "WaspConstants.h"
#endif


// Define constants and variables for buffering incoming serial data.  We're
// using a ring buffer (I think), in which rx_buffer_head is the index of the
// location to which to write the next incoming character and rx_buffer_tail
// is the index of the location from which to read.
#define RX_BUFFER_SIZE_0 512
#define RX_BUFFER_SIZE_1 128
#define UART_LIMIT 134217728

        unsigned char rx_buffer0[RX_BUFFER_SIZE_0];
        unsigned char rx_buffer1[RX_BUFFER_SIZE_1];
        int rx_buffer_head0 = 0;
        int rx_buffer_tail0 = 0;
        int rx_buffer_head1 = 0;
        int rx_buffer_tail1 = 0;

// connects the internal peripheral in the processor and configures it
void beginSerial(long baud, uint8_t portNum)
{
        if (portNum == 0) {
                setIPF_(IPUSART0);
                UBRR0H = ((F_CPU / 16 + baud / 2) / baud - 1) >> 8;
                UBRR0L = ((F_CPU / 16 + baud / 2) / baud - 1);
                
                // enable rx and tx
                sbi(UCSR0B, RXEN0);
                sbi(UCSR0B, TXEN0);
                
                // enable interrupt on complete reception of a byte
                sbi(UCSR0B, RXCIE0);
                
                
        } else {
                setIPF_(IPUSART1);
                UBRR1H = ((F_CPU / 16 + baud / 2) / baud - 1) >> 8;
                UBRR1L = ((F_CPU / 16 + baud / 2) / baud - 1);
        
                // enable rx and tx
                sbi(UCSR1B, RXEN1);
                sbi(UCSR1B, TXEN1);
                
                // enable interrupt on complete reception of a byte
                sbi(UCSR1B, RXCIE1);
        }
        // defaults to 8-bit, no parity, 1 stop bit
}

// disconnects the internal peripheral in the processor
void closeSerial(uint8_t portNum)
{
        if (portNum == 0) {
                // turn off the internal peripheral, but also the interface
                // resetIPF is just turning off the clock, what is not helping
                // to save power, you gotta get rid of all the pull-ups in the sytem
                resetIPF_(IPUSART0);
                cbi(UCSR0B, RXEN0);
                cbi(UCSR0B, TXEN0);
        } else {
                // turn off the internal peripheral, but also the interface
                // resetIPF is just turning off the clock, what is not helping
                // to save power, you gotta get rid of all the pull-ups in the sytem
                resetIPF_(IPUSART1);
                cbi(UCSR1B, RXEN1);
                cbi(UCSR1B, TXEN1);
        }
}

void serialWrite(unsigned char c, uint8_t portNum)
{
        if (portNum == 0) {
                while (!(UCSR0A & (1 << UDRE0)))
                        ;

                UDR0 = c;
        } else {
                while (!(UCSR1A & (1 << UDRE1)))
                        ;

                UDR1 = c;
        }
}

int serialAvailable(uint8_t portNum)
{
        if (portNum == 0)
                return (RX_BUFFER_SIZE_0 + rx_buffer_head0 - rx_buffer_tail0) % RX_BUFFER_SIZE_0;
        else
                return (RX_BUFFER_SIZE_1 + rx_buffer_head1 - rx_buffer_tail1) % RX_BUFFER_SIZE_1;
}

int serialRead(uint8_t portNum)
{
        if (portNum == 0) {
                // if the head isn't ahead of the tail, we don't have any characters
                if (rx_buffer_head0 == rx_buffer_tail0) {
                        return -1;
                } else {
                        unsigned char c = rx_buffer0[rx_buffer_tail0];
                        rx_buffer_tail0 = (rx_buffer_tail0 + 1) % RX_BUFFER_SIZE_0;
                        return c;
                }
        }
        else {
                // if the head isn't ahead of the tail, we don't have any characters
                if (rx_buffer_head1 == rx_buffer_tail1) {
                        return -1;
                } else {
                        unsigned char c = rx_buffer1[rx_buffer_tail1];
                        rx_buffer_tail1 = (rx_buffer_tail1 + 1) % RX_BUFFER_SIZE_1;
                        return c;
                }
        }
}

void serialFlush(uint8_t portNum)
{
        // don't reverse this or there may be problems if the RX interrupt
        // occurs after reading the value of rx_buffer_head but before writing
        // the value to rx_buffer_tail; the previous value of rx_buffer_head
        // may be written to rx_buffer_tail, making it appear as if the buffer
        // were full, not empty.
        if (portNum == 0){
                rx_buffer_tail0=0;
                rx_buffer_head0 = rx_buffer_tail0;
        }
        else{
                rx_buffer_tail1=0;
                rx_buffer_head1 = rx_buffer_tail1;
        }
}

SIGNAL(USART0_RX_vect)
{
                unsigned char c = UDR0;
                
                int i = (rx_buffer_head0 + 1) % RX_BUFFER_SIZE_0;
                
                // if we should be storing the received character into the location
                // just before the tail (meaning that the head would advance to the
                // current location of the tail), we're about to overflow the buffer
                // and so we don't write the character or advance the head.
                if (i != rx_buffer_tail0) {
                        rx_buffer0[rx_buffer_head0] = c;
                        rx_buffer_head0 = i;
                        if(rx_buffer_head0==UART_LIMIT)
                        {
                                rx_buffer_head0=0;
                                rx_buffer_tail0=0;
                        }
                }
}

SIGNAL(USART1_RX_vect)
{
                unsigned char c = UDR1;

                int i = (rx_buffer_head1 + 1) % RX_BUFFER_SIZE_1;

                // if we should be storing the received character into the location
                // just before the tail (meaning that the head would advance to the
                // current location of the tail), we're about to overflow the buffer
                // and so we don't write the character or advance the head.
                if (i != rx_buffer_tail1) {
                        rx_buffer1[rx_buffer_head1] = c;
                        rx_buffer_head1 = i;
                        if(rx_buffer_head1==UART_LIMIT)
                        {
                                rx_buffer_head1=0;
                                rx_buffer_tail1=0;
                        }
                }
}

void printMode(int mode, uint8_t portNum)
{
        // do nothing, we only support serial printing, not lcd.
}

void printByte(unsigned char c, uint8_t portNum)
{
        serialWrite(c, portNum);
}

void printNewline(uint8_t portNum)
{
        printByte('\n', portNum);
}

void printString(const char *s, uint8_t portNum)
{
        while (*s)
                printByte(*s++, portNum);
}

void printIntegerInBase(unsigned long n, unsigned long base, uint8_t portNum)
{ 
        unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. 
        unsigned long i = 0;

        if (n == 0) {
                printByte('0', portNum);
                return;
        } 

        while (n > 0) {
                buf[i++] = n % base;
                n /= base;
        }

        for (; i > 0; i--)
                printByte(buf[i - 1] < 10 ?
                        '0' + buf[i - 1] :
                        'A' + buf[i - 1] - 10, portNum);
}

void printInteger(long n, uint8_t portNum)
{
        if (n < 0) {
                printByte('-', portNum);
                n = -n;
        }

        printIntegerInBase(n, 10, portNum);
}

void printHex(unsigned long n, uint8_t portNum)
{
        printIntegerInBase(n, 16, portNum);
}

void printOctal(unsigned long n, uint8_t portNum)
{
        printIntegerInBase(n, 8, portNum);
}

void printBinary(unsigned long n, uint8_t portNum)
{
        printIntegerInBase(n, 2, portNum);
}

/* Including print() adds approximately 1500 bytes to the binary size,
 * so we replace it with the smaller and less-confusing printString(),
 * printInteger(), etc.
void print(const char *format, ...)
{
        char buf[256];
        va_list ap;
        
        va_start(ap, format);
        vsnprintf(buf, 256, format, ap);
        va_end(ap);
        
        printString(buf);
}
*/

---