Added support for serial functions in 1.0 and 1.5, specificaally Serial.peek and also Serial.find. Updated HardwareSerial class so it inhetits from Stream instead of Print, to confirm with Arduino 1.0 structure

STM32F1XX/cores/maple/HardwareSerial.cpp

@@ -137,17 +137,34 @@ void HardwareSerial::end(void) {
  * I/O
  */
 
-uint8 HardwareSerial::read(void) {
+int HardwareSerial::read(void) {
     // Block until a byte becomes available, to save user confusion.
     while (!this->available())
         ;
     return usart_getc(this->usart_device);
 }
 
-uint32 HardwareSerial::available(void) {
+int HardwareSerial::available(void) {
     return usart_data_available(this->usart_device);
 }
 
+/* Roger Clark. Added function missing from LibMaple code */
+
+int HardwareSerial::peek(void)
+{
+    return usart_getc(this->usart_device);
+}
+
+int HardwareSerial::availableForWrite(void)
+{
+/* Roger Clark. 
+ * Currently there isn't an output ring buffer, chars are sent straight to the hardware. 
+ * so just return 1, meaning that 1 char can be written
+ * This will be slower than a ring buffer implementation, but it should at least work !
+ */
+  return 1;
+}
+
 size_t HardwareSerial::write(unsigned char ch) {
 
     usart_putc(this->usart_device, ch);

STM32F1XX/cores/maple/HardwareSerial.h

@@ -48,9 +48,40 @@
  * the documentation accordingly.
  */
 
+ 
+ 
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which head is the index of the location
+// to which to write the next incoming character and tail is the index of the
+// location from which to read.
+#if !(defined(SERIAL_TX_BUFFER_SIZE) && defined(SERIAL_RX_BUFFER_SIZE))
+#if (RAMEND < 1000)
+#define SERIAL_TX_BUFFER_SIZE 16
+#define SERIAL_RX_BUFFER_SIZE 16
+#else
+#define SERIAL_TX_BUFFER_SIZE 64
+#define SERIAL_RX_BUFFER_SIZE 64
+#endif
+#endif
+#if (SERIAL_TX_BUFFER_SIZE>256)
+typedef uint16_t tx_buffer_index_t;
+#else
+typedef uint8_t tx_buffer_index_t;
+#endif
+#if  (SERIAL_RX_BUFFER_SIZE>256)
+typedef uint16_t rx_buffer_index_t;
+#else
+typedef uint8_t rx_buffer_index_t;
+#endif
+ 
 struct usart_dev;
 
-class HardwareSerial : public Print {
+/* Roger clark. Changed class inheritance from Print to Stream.
+ * Also added new functions for peek() and availableForWrite()
+ * Note. AvailableForWrite is only a stub function in the cpp
+ */
+class HardwareSerial : public Stream {
+
 public:
     HardwareSerial(struct usart_dev *usart_device,
                    uint8 tx_pin,
@@ -58,13 +89,17 @@ public:
 
     /* Set up/tear down */
     void begin(uint32 baud);
-    void end(void);
-
-    /* I/O */
-    uint32 available(void);
-    uint8 read(void);
-    void flush(void);
-    virtual size_t  write(unsigned char);
+       void end();
+    virtual int available(void);
+    virtual int peek(void);
+    virtual int read(void);
+    int availableForWrite(void);
+    virtual void flush(void);
+    virtual size_t write(uint8_t);
+    inline size_t write(unsigned long n) { return write((uint8_t)n); }
+    inline size_t write(long n) { return write((uint8_t)n); }
+    inline size_t write(unsigned int n) { return write((uint8_t)n); }
+    inline size_t write(int n) { return write((uint8_t)n); }
     using Print::write;
 
     /* Pin accessors */
@@ -80,6 +115,27 @@ private:
     struct usart_dev *usart_device;
     uint8 tx_pin;
     uint8 rx_pin;
+  protected:
+#if 0  
+    volatile uint8_t * const _ubrrh;
+    volatile uint8_t * const _ubrrl;
+    volatile uint8_t * const _ucsra;
+    volatile uint8_t * const _ucsrb;
+    volatile uint8_t * const _ucsrc;
+    volatile uint8_t * const _udr;
+    // Has any byte been written to the UART since begin()
+    bool _written;
+
+    volatile rx_buffer_index_t _rx_buffer_head;
+    volatile rx_buffer_index_t _rx_buffer_tail;
+    volatile tx_buffer_index_t _tx_buffer_head;
+    volatile tx_buffer_index_t _tx_buffer_tail;	
+    // Don't put any members after these buffers, since only the first
+    // 32 bytes of this struct can be accessed quickly using the ldd
+    // instruction.
+    unsigned char _rx_buffer[SERIAL_RX_BUFFER_SIZE];
+    unsigned char _tx_buffer[SERIAL_TX_BUFFER_SIZE];	
+#endif
 };
 
 #ifdef BOOTLOADER_maple 

STM32F1XX/system/libmaple/include/libmaple/ring_buffer.h

@@ -126,6 +126,26 @@ static inline uint8 rb_remove(ring_buffer *rb) {
     return ch;
 }
 
+/*
+ * Roger Clark. 20141125, 
+ * added peek function.
+ * @brief Return the first item from a ring buffer, without removing it
+ * @param rb Buffer to remove from, must contain at least one element.
+ */
+
+static inline int rb_peek(ring_buffer *rb) 
+{  
+	if (rb->head == rb->tail)
+	{
+		return -1;
+	}
+	else
+	{
+		return rb->buf[rb->head];
+	}
+}
+
+
 /**
  * @brief Attempt to remove the first item from a ring buffer.
  *

STM32F1XX/system/libmaple/include/libmaple/usart.h

@@ -473,6 +473,18 @@ static inline uint8 usart_getc(usart_dev *dev) {
     return rb_remove(dev->rb);
 }
 
+/*
+ * Roger Clark. 20141125, 
+ * added peek function.
+ * @param dev Serial port to read from
+ * @return byte read
+ */
+static inline int usart_peek(usart_dev *dev)
+{
+	return rb_peek(dev->rb);
+}
+
+
 /**
  * @brief Return the amount of data available in a serial port's RX buffer.
  * @param dev Serial port to check