PlatformUart.cpp

00001 // interface for SPI implemented with mbed framework
00002 
00003 #include "PlatformUart.h"
00004 #include "mbed.h"
00005 #include "SerialBuffered.h"
00006 
00007 
00008 //Serial uart(PA_9, PA_10, 115200); // Serial(PinName tx, PinName rx, const char *name=NULL, int baud = MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
00009 SerialBuffered uart( 256, PA_9, PA_10, 115200 );
00010 
00011 
00012 int platformUart::write(int data)
00013 {
00014   return uart.putc(data);
00015 }
00016 /*
00017 int platformUart::write(char* str)
00018 {
00019   return uart.puts(str);
00020 }
00021 */
00022 
00023 size_t platformUart::println(void)
00024 {
00025   return uart.puts("\r\n");
00026 }
00027 
00028 size_t platformUart::print(const char str[])
00029 {
00030   return uart.puts(str);
00031 }
00032 
00033 size_t platformUart::print(char c)
00034 {
00035   return uart.putc(c);
00036 }
00037 
00038 size_t platformUart::print(unsigned char b, int base)
00039 {
00040   return print((unsigned long) b, base);
00041 }
00042 
00043 size_t platformUart::print(int n, int base)
00044 {
00045   return print((long) n, base);
00046 }
00047 
00048 size_t platformUart::print(unsigned int n, int base)
00049 {
00050   return print((unsigned long) n, base);
00051 }
00052 
00053 size_t platformUart::print(long n, int base)
00054 {
00055   if (base == 0) {
00056     return write(n);
00057   } else if (base == 10) {
00058     if (n < 0) {
00059       int t = print('-');
00060       n = -n;
00061       return printNumber(n, 10) + t;
00062     }
00063     return printNumber(n, 10);
00064   } else {
00065     return printNumber(n, base);
00066   }
00067 }
00068 
00069 size_t platformUart::print(unsigned long n, int base)
00070 {
00071   if (base == 0) return write(n);
00072   else return printNumber(n, base);
00073 }
00074 
00075 size_t platformUart::print(double n, int digits)
00076 {
00077   return printFloat(n, digits);
00078 }
00079 
00080 
00081 size_t platformUart::println(const char c[])
00082 {
00083   size_t n = print(c);
00084   n += println();
00085   return n;
00086 }
00087 
00088 size_t platformUart::println(char c)
00089 {
00090   size_t n = print(c);
00091   n += println();
00092   return n;
00093 }
00094 
00095 size_t platformUart::println(unsigned char b, int base)
00096 {
00097   size_t n = print(b, base);
00098   n += println();
00099   return n;
00100 }
00101 
00102 size_t platformUart::println(int num, int base)
00103 {
00104   size_t n = print(num, base);
00105   n += println();
00106   return n;
00107 }
00108 
00109 size_t platformUart::println(unsigned int num, int base)
00110 {
00111   size_t n = print(num, base);
00112   n += println();
00113   return n;
00114 }
00115 
00116 size_t platformUart::println(long num, int base)
00117 {
00118   size_t n = print(num, base);
00119   n += println();
00120   return n;
00121 }
00122 
00123 size_t platformUart::println(unsigned long num, int base)
00124 {
00125   size_t n = print(num, base);
00126   n += println();
00127   return n;
00128 }
00129 
00130 size_t platformUart::println(double num, int digits)
00131 {
00132   size_t n = print(num, digits);
00133   n += println();
00134   return n;
00135 }
00136 
00137 
00138 // Private Methods /////////////////////////////////////////////////////////////
00139 
00140 size_t platformUart::printNumber(unsigned long n, uint8_t base) {
00141   char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
00142   char *str = &buf[sizeof(buf) - 1];
00143 
00144   *str = '\0';
00145 
00146   // prevent crash if called with base == 1
00147   if (base < 2) base = 10;
00148 
00149   do {
00150     unsigned long m = n;
00151     n /= base;
00152     char c = m - base * n;
00153     *--str = c < 10 ? c + '0' : c + 'A' - 10;
00154   } while(n);
00155 
00156   return uart.puts(str);
00157 }
00158 
00159 size_t platformUart::printFloat(double number, uint8_t digits) 
00160 { 
00161   size_t n = 0;
00162   
00163   if (isnan(number)) return print("nan");
00164   if (isinf(number)) return print("inf");
00165   if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
00166   if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
00167   
00168   // Handle negative numbers
00169   if (number < 0.0)
00170   {
00171      n += print('-');
00172      number = -number;
00173   }
00174 
00175   // Round correctly so that print(1.999, 2) prints as "2.00"
00176   double rounding = 0.5;
00177   for (uint8_t i=0; i<digits; ++i)
00178     rounding /= 10.0;
00179   
00180   number += rounding;
00181 
00182   // Extract the integer part of the number and print it
00183   unsigned long int_part = (unsigned long)number;
00184   double remainder = number - (double)int_part;
00185   n += print(int_part);
00186 
00187   // platformUart the decimal point, but only if there are digits beyond
00188   if (digits > 0) {
00189     n += print("."); 
00190   }
00191 
00192   // Extract digits from the remainder one at a time
00193   while (digits-- > 0)
00194   {
00195     remainder *= 10.0;
00196     int toPrint = int(remainder);
00197     n += print(toPrint);
00198     remainder -= toPrint; 
00199   } 
00200   
00201   return n;
00202 }
00203 
00204 
00205 
00206 
00207 unsigned char rx_data;
00208 
00209 // Interupt Routine to read in data from serial port
00210 void Rx_interrupt() 
00211 {
00212     //while (uart.readable())
00213     {
00214       rx_data = uart.getc();
00215       //byteQueue_Put(&rxQueue, rx_data);
00216     }
00217 }
00218 
00219 
00220 
00221 platformUart::platformUart()
00222 {
00223     //byteQueue_Init(&rxQueue);
00224   
00225   //uart.attach(&Rx_interrupt, Serial::RxIrq);
00226 }
00227 
00228 unsigned char platformUart::available()
00229 {
00230   return uart.readable(); //!(byteQueue_IsEmpty(&rxQueue));
00231 }
00232 
00233 unsigned char platformUart::read()
00234 {
00235   return uart.getc(); //byteQueue_Get(&rxQueue);
00236 }
00237 
00238 
00239 
00240 
00241 platformUart Serial0;
00242 platformUart_Dummy Serial1;