serial.h

#ifndef LIBPROPELLER_SERIAL_H_
#define LIBPROPELLER_SERIAL_H_
 
#include <cstdarg>
#include <propeller.h>
#include "libpropeller/numbers/numbers.h"
 
#include "libpropeller/streaminterface/streaminterface.h"
 
#include "libpropeller/printstream/printstream.h"
 
extern char _load_start_serial_cog[];
 
namespace libpropeller {
 
class Serial : public InputStream<Serial>, public OutputStream<Serial>{
//class Serial : public StreamInterface{
//class Serial{
public:
 
    static const int kBufferLength = 512;
 
    ~Serial() {
        Stop();
    }
 
    bool Start(const int rxpin, const int txpin, const int rate, const int ctspin = -1) {
        
        // Prevent garbage collection of the ASM code
        volatile void * asm_driver_reference = NULL;
        __asm__ volatile ("mov %[asm_driver_reference], #Fds_entry \n\t"
                : [asm_driver_reference] "+r" (asm_driver_reference));
 
        Stop();
 
        extern char * Masktx asm("Masktx");
        extern char * Maskrx asm("Maskrx");
        extern char * Ctra_val asm("Ctra_val");
        extern char * Ctrb_val asm("Ctrb_val");
        extern char * Period_ptr asm("Period_ptr");
        extern char * Rx_head_ptr asm("Rx_head_ptr");
        extern char * Rx_end_ptr asm("Rx_end_ptr");
        extern char * Update_head_ptr asm("Update_head_ptr");
        extern char * Maskcts asm("Maskcts");
 
 
        SetDriverLong(&Masktx, 0);
        SetDriverLong(&Ctra_val, 0);
        if (txpin >= 0) {
            DIRA |= 1 << txpin;
            SetDriverLong(&Masktx, 1 << txpin);
            SetDriverLong(&Ctra_val, 0x10000000 | txpin);
        }
        SetDriverLong(&Maskrx, 0);
        SetDriverLong(&Ctrb_val, 0);
        if (rxpin >= 0) {
            DIRA &= ~(1 << rxpin);
 
            SetDriverLong(&Maskrx, 1 << rxpin);
            SetDriverLong(&Ctrb_val, 0x54000000 | rxpin);
        }
 
 
        SetDriverLong(&Maskcts, 0);
        if (ctspin >= 0) {
            //Set CTS pin to input:
            DIRA &= ~(1 << ctspin);
 
            SetDriverLong(&Maskcts, 1 << ctspin);
        }
 
 
        SetBaud(rate);
 
        SetDriverLong(&Period_ptr, (int) &half_bit_period_);
        memset((void *) &rx_buffer_, 0, kBufferLength);
 
        SetDriverLong(&Rx_head_ptr, (int) &rx_buffer_);
        SetDriverLong(&Rx_end_ptr, (int) &rx_buffer_ + kBufferLength);
 
        rx_head_ = 0;
        rx_tail_ = 0;
 
        SetDriverLong(&Update_head_ptr, (int) &rx_head_);
        write_buf_ptr_ = 1;
        cog_ = 1 + cognew((int) (&(*(int *) &_load_start_serial_cog[0])), (int) (&write_buf_ptr_));
        if (cog_) {
            WaitForTransmissionCompletion();
            return true;
        }
        return false;
    }
 
    void Stop(void) {
        WaitForTransmissionCompletion();
        if (cog_) {
            cogstop(cog_ - 1);
            cog_ = 0;
        }
    }
 
    bool SetBaud(const int rate) {
        return SetBaudClock(rate, CLKFREQ);
    }
 
    bool SetBaudClock(const unsigned int rate, const unsigned int sysclock) {
        WaitForTransmissionCompletion();
 
        // how many clocks per 1/2 bit (pre-round to the nearest integer)
        int got_rate = ((sysclock >> 1) + (rate >> 1)) / rate;
 
        // clamp the period to the allowable range
        half_bit_period_ = got_rate > kMinimumHalfPeriod ? got_rate : kMinimumHalfPeriod;
 
        // return true if the requested period was >= the allowable limit
        return got_rate >= kMinimumHalfPeriod;
    }
 
    void Put(const char character) {
        WaitForTransmissionCompletion();
        send_temp_ = character;
        write_buf_ptr_ = (int) (&send_temp_);
    }
 
    int Put(const char * buffer_ptr, const int count) {
        WaitForTransmissionCompletion();
        for (int i = 0; i < count; i++) {
            Put(buffer_ptr[i]);
        }
        return count;
    }
 
    int Put(const char * buffer_ptr) {
        return Put(buffer_ptr, strlen(buffer_ptr));
    }
 
    
 
    int Get(const int timeout = -1) {
        int rxbyte = 0;
 
        if (timeout <= -1) { //No timeout, wait forever
 
            while ((rxbyte = CheckBuffer()) < 0);
            return (char) rxbyte;
        } else if (timeout == 0){
            // Optimization: no wait if we just want a check.
            return CheckBuffer();
        } else {
            unsigned int total_cycles = (CLKFREQ / 1000) * timeout;
            unsigned int elapsed_cycles = 0;
 
            int previous_cnt = CNT;
            do {
                rxbyte = CheckBuffer();
                int current_cnt = CNT;
                elapsed_cycles += current_cnt - previous_cnt;
                previous_cnt = current_cnt;
            } while (rxbyte < 0 && elapsed_cycles < total_cycles);
            return rxbyte;
        }
    }
 
    int Get(char * const buffer, const int length, const int timeout = -1) {
        int character_count;
        for (character_count = 0; character_count < length; ++character_count) {
            int character = Get(timeout);
            if (character <= -1) {
                return character_count;
            }
            buffer[character_count] = (char) character;
        }
        return character_count;
    }
 
    int Get(char * const buffer, const char terminator = '\n') {
        int character_count;
        char received_character = terminator + 1; // guarantee that they differ the first time.
        for (character_count = 0; received_character != terminator; ++character_count) {
            received_character = (char) Get();
            buffer[character_count] = received_character;
        }
        buffer[character_count] = '\0';
        return character_count;
    }
 
    void GetFlush(void) {
        rx_tail_ = rx_head_;
    }
 
    int GetCount(void) const {
        const int tail = rx_tail_;
        const int head = rx_head_;
        if (head >= tail) {
            return head - tail;
        } else {
            return kBufferLength - tail + head;
        }
    }
    
    int PutFormatted(const char * formatString, ...){
        PrintStream<Serial> ps(this);
        
        va_list list;
        va_start(list, formatString);
        int result = ps.Format(formatString, list);
        va_end(list);
        return result;
    }
 
 
private:
    static const int kMinimumHalfPeriod = 86;
 
    volatile int write_buf_ptr_;
    volatile int send_temp_;
    volatile int half_bit_period_;
    volatile short rx_head_;
    volatile short rx_tail_;
    volatile char rx_buffer_[kBufferLength];
    int cog_;
 
    int CheckBuffer(void) {
        int rxbyte = -1;
        if (rx_tail_ != rx_head_) {
            rxbyte = rx_buffer_[rx_tail_];
            rx_buffer_[rx_tail_] = 0;
            
            // Optimization:
            // Was 
            // rx_tail_ = ((rx_tail_ + 1) % kBufferLength);
            // But the modulo MAY be very slow. Edit: it's a bit faster...
            rx_tail_++;
            if (rx_tail_ == kBufferLength) {
                rx_tail_ = 0;
            }
        }
        return rxbyte;
    }
 
    void WaitForTransmissionCompletion(void) {
        while (write_buf_ptr_) {
        };
    }
 
    void SetDriverLong(const int index, const int value) {
        ((int *) &_load_start_serial_cog[index])[0] = value;
    }
 
    /* Warning: SetDriverLong(char **, int) must be declared second, otherwise it calls itself! */
    void SetDriverLong(char ** index, const int value) {
        SetDriverLong((int) index, value);
    }
};
 
//
// The Put(buffer) function doesn't seem to work in CMM mode. In the tests, I 
// get a -1 for the matching Get(), instead of the character sent. The same code
// can pass in LMM mode.
 
// Update: now, it doesn't work at all.
 
//int Serial::PutBuffer(char * buffer_ptr, const bool wait, int buffer_bytes, const char terminator)
//{
//  volatile char * volatile temp_ptr = buffer_ptr;
//  if(buffer_bytes == -1){
//      if(terminator == '\0'){
//          buffer_bytes = strlen(buffer_ptr);
//          
//      }else{
//          for(buffer_bytes = 0; buffer_ptr[buffer_bytes] != terminator; buffer_bytes++){}
//      }
//          
//  }
 
//  buffer_bytes = 5;
 
//  if (buffer_bytes > 0 && buffer_ptr != NULL) {
//  
//      send_temp_ = (int)(buffer_ptr);
//      write_buf_ptr_ = (send_temp_ | ((buffer_bytes - 1) << 16));
//      }
//  
//  if(wait){
//      while (write_buf_ptr_){}
//  }
//  return buffer_bytes;
//}
 
}
 
#endif // LIBPROPELLER_SERIAL_H_