From 5b1afe32cf7496acea8182278aca83f59e8384e3 Mon Sep 17 00:00:00 2001 From: Florian Pritz Date: Mon, 11 Feb 2013 22:58:16 +0100 Subject: Make code launchpad/energia compatible Signed-off-by: Florian Pritz --- lib/msp430/Arduino.h | 4 + lib/msp430/Energia.h | 231 ++++++++++++ lib/msp430/HardwareSerial.cpp | 237 ++++++++++++ lib/msp430/HardwareSerial.h | 69 ++++ lib/msp430/Print.cpp | 252 +++++++++++++ lib/msp430/Print.h | 85 +++++ lib/msp430/Printable.h | 40 ++ lib/msp430/Stream.cpp | 246 ++++++++++++ lib/msp430/Stream.h | 94 +++++ lib/msp430/TimerSerial.cpp | 272 ++++++++++++++ lib/msp430/TimerSerial.h | 78 ++++ lib/msp430/Tone.cpp | 223 +++++++++++ lib/msp430/WCharacter.h | 170 +++++++++ lib/msp430/WInterrupts.c | 138 +++++++ lib/msp430/WMath.cpp | 65 ++++ lib/msp430/WString.cpp | 649 ++++++++++++++++++++++++++++++++ lib/msp430/WString.h | 204 ++++++++++ lib/msp430/Wire.cpp | 307 +++++++++++++++ lib/msp430/Wire.h | 94 +++++ lib/msp430/binary.h | 515 +++++++++++++++++++++++++ lib/msp430/main.cpp | 16 + lib/msp430/new.cpp | 18 + lib/msp430/new.h | 22 ++ lib/msp430/random.c | 90 +++++ lib/msp430/twi.c | 850 ++++++++++++++++++++++++++++++++++++++++++ lib/msp430/twi.h | 104 ++++++ lib/msp430/usci_isr_handler.c | 59 +++ lib/msp430/usci_isr_handler.h | 18 + lib/msp430/wiring.c | 223 +++++++++++ lib/msp430/wiring_analog.c | 297 +++++++++++++++ lib/msp430/wiring_digital.c | 181 +++++++++ lib/msp430/wiring_private.h | 60 +++ lib/msp430/wiring_pulse.c | 76 ++++ lib/msp430/wiring_shift.c | 63 ++++ 34 files changed, 6050 insertions(+) create mode 100644 lib/msp430/Arduino.h create mode 100644 lib/msp430/Energia.h create mode 100644 lib/msp430/HardwareSerial.cpp create mode 100644 lib/msp430/HardwareSerial.h create mode 100644 lib/msp430/Print.cpp create mode 100644 lib/msp430/Print.h create mode 100644 lib/msp430/Printable.h create mode 100644 lib/msp430/Stream.cpp create mode 100644 lib/msp430/Stream.h create mode 100644 lib/msp430/TimerSerial.cpp create mode 100644 lib/msp430/TimerSerial.h create mode 100755 lib/msp430/Tone.cpp create mode 100644 lib/msp430/WCharacter.h create mode 100644 lib/msp430/WInterrupts.c create mode 100644 lib/msp430/WMath.cpp create mode 100644 lib/msp430/WString.cpp create mode 100644 lib/msp430/WString.h create mode 100644 lib/msp430/Wire.cpp create mode 100644 lib/msp430/Wire.h create mode 100644 lib/msp430/binary.h create mode 100644 lib/msp430/main.cpp create mode 100644 lib/msp430/new.cpp create mode 100644 lib/msp430/new.h create mode 100644 lib/msp430/random.c create mode 100644 lib/msp430/twi.c create mode 100644 lib/msp430/twi.h create mode 100644 lib/msp430/usci_isr_handler.c create mode 100644 lib/msp430/usci_isr_handler.h create mode 100644 lib/msp430/wiring.c create mode 100644 lib/msp430/wiring_analog.c create mode 100644 lib/msp430/wiring_digital.c create mode 100644 lib/msp430/wiring_private.h create mode 100755 lib/msp430/wiring_pulse.c create mode 100755 lib/msp430/wiring_shift.c (limited to 'lib/msp430') diff --git a/lib/msp430/Arduino.h b/lib/msp430/Arduino.h new file mode 100644 index 0000000..5f3919f --- /dev/null +++ b/lib/msp430/Arduino.h @@ -0,0 +1,4 @@ +// Stub for Arduino header file - For added compatibility with existing arduino libraries +// Include Energia instead +#include "Energia.h" + diff --git a/lib/msp430/Energia.h b/lib/msp430/Energia.h new file mode 100644 index 0000000..facfd06 --- /dev/null +++ b/lib/msp430/Energia.h @@ -0,0 +1,231 @@ +#ifndef Energia_h +#define Energia_h + +#include +#include +#include +#include + +#include "binary.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +#define NOT_A_PORT 0 +#define NOT_A_PIN 0 +#define NOT_ON_TIMER 0 + +#define HIGH 0x1 +#define LOW 0x0 + +#define LSBFIRST 0 +#define MSBFIRST 1 + +#define CHANGE 1 +#define FALLING 2 +#define RISING 3 + +#define INPUT 0x0 +#define OUTPUT 0x1 +#define INPUT_PULLUP 0x2 +#define INPUT_PULLDOWN 0x4 +#define PORT_SELECTION0 0x10 +#define PORT_SELECTION1 0x20 + + +#define true 0x1 +#define false 0x0 + +#define PI 3.1415926535897932384626433832795 +#define HALF_PI 1.5707963267948966192313216916398 +#define TWO_PI 6.283185307179586476925286766559 +#define DEG_TO_RAD 0.017453292519943295769236907684886 +#define RAD_TO_DEG 57.295779513082320876798154814105 + +#if defined(__MSP430_HAS_ADC10__) +#define DEFAULT SREF_0 +#define INTERNAL1V5 SREF_1 + REFON +#define INTERNAL2V5 SREF_1 + REFON + REF2_5V +#define EXTERNAL SREF_2 +#endif + +#if defined(__MSP430_HAS_ADC10_B__) +#define DEFAULT ADC10SREF_0 +#define INTERNAL1V5 ADC10SREF_1 + REFON + REFVSEL_0 +#define INTERNAL2V5 ADC10SREF_1 + REFON + REFVSEL_2 +#define EXTERNAL ADC10SREF_2 +#endif + +enum{ + P1 = 1, + P2, +#ifdef __MSP430_HAS_PORT3_R__ + P3, +#endif +#ifdef __MSP430_HAS_PORT4_R__ + P4, +#endif +#ifdef __MSP430_HAS_PORT5_R__ + P5, +#endif +#ifdef __MSP430_HAS_PORT6_R__ + P6, +#endif +#ifdef __MSP430_HAS_PORT7_R__ + P7, +#endif +#ifdef __MSP430_HAS_PORTJ_R__ + PJ, +#endif + }; + +enum{ + T0A0, + T0A1, + T0A2, + T1A0, + T1A1, + T1A2, + T1A3, + T1A4, + T1A5, + T2A0, + T2A1, + T2A2, + T0B0, + T0B1, + T0B2, + T1B0, + T1B1, + T1B2, + T2B0, + T2B1, + T2B2 + }; + +typedef uint8_t boolean; +typedef uint8_t byte; + +#define min(a,b) ((a)<(b)?(a):(b)) +#define max(a,b) ((a)>(b)?(a):(b)) +#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt))) +#define round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5)) +#define radians(deg) ((deg)*DEG_TO_RAD) +#define degrees(rad) ((rad)*RAD_TO_DEG) +#define sq(x) ((x)*(x)) + +#define interrupts() __bis_SR_register(GIE) +#define noInterrupts() __bic_SR_register(GIE) + +#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L ) +#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() ) +#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() ) + +#define lowByte(w) ((uint8_t) ((w) & 0xff)) +#define highByte(w) ((uint8_t) ((w) >> 8)) + +#define bitRead(value, bit) (((value) >> (bit)) & 0x01) +#define bitSet(value, bit) ((value) |= (1UL << (bit))) +#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) +#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit)) + + +typedef unsigned int word; + +#define bit(b) (1UL << (b)) + +void init(void); +void setup(void); +void loop(void); + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val); +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout); +void pinMode(uint8_t, uint8_t); +void pinMode_int(uint8_t, uint8_t); +void digitalWrite(uint8_t, uint8_t); +int digitalRead(uint8_t); +uint16_t analogRead(uint8_t); +void analogWrite(uint8_t, int); +void analogReference(uint16_t); +void analogFrequency(uint32_t); +void analogResolution(uint16_t); + + + +void delay(uint32_t milliseconds); + +void attachInterrupt(uint8_t, void (*)(void), int mode); +void detachInterrupt(uint8_t); + +extern const uint8_t digital_pin_to_timer[]; +extern const uint8_t digital_pin_to_port[]; +extern const uint8_t digital_pin_to_bit_mask[]; +extern const uint16_t port_to_sel0[]; +extern const uint16_t port_to_sel1[]; +extern const uint16_t port_to_sel2[]; +extern const uint16_t port_to_input[]; +extern const uint16_t port_to_output[]; + +#define digitalPinToPort(P) ( digital_pin_to_port[P] ) +#define digitalPinToBitMask(P) ( digital_pin_to_bit_mask[P] ) +#define digitalPinToTimer(P) ( digital_pin_to_timer[P] ) +#define portDirRegister(P) ( (volatile uint8_t *)( port_to_dir[P]) ) +/* + * We either of the compination PxSEL and PxSEL2 or PxSEL0 and PxSEL1 + * So we can remap PxSEL and PxSEL2 to PxSEL0 and PxSEL1 +*/ +#define portSelRegister(P) ( (volatile uint8_t *)( port_to_sel0[P]) ) +#define portSel2Register(P) ( (volatile uint8_t *)( port_to_sel2[P]) ) + +#define portSel0Register(P) ( (volatile uint8_t *)( port_to_sel0[P]) ) +#define portSel1Register(P) ( (volatile uint8_t *)( port_to_sel1[P]) ) +#define portRenRegister(P) ( (volatile uint8_t *)( port_to_ren[P]) ) +#define portOutputRegister(P) ( (volatile uint8_t *)( port_to_output[P]) ) +#define portInputRegister(P) ( (volatile uint8_t *)( port_to_input[P]) ) +#define digitalPinToTimer(P) ( digital_pin_to_timer[P] ) + +// Implemented in wiring.c +void delayMicroseconds(unsigned int us); +unsigned long micros(); +unsigned long millis(); +void disableWatchDog(); +void enableWatchDog(); + +#ifdef __cplusplus +} // extern "C" +#endif + +#ifdef __cplusplus +#include "WCharacter.h" +#include "WString.h" +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) +#include "HardwareSerial.h" +#else +#include "TimerSerial.h" +#endif + +uint16_t makeWord(uint16_t w); +uint16_t makeWord(byte h, byte l); + +#define word(...) makeWord(__VA_ARGS__) + +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L); + +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0); +void noTone(uint8_t _pin); + +// WMath prototypes +long random(long); +long random(long, long); +void randomSeed(unsigned int); +long map(long, long, long, long, long); + +#endif + +#include "pins_energia.h" + +#endif + + diff --git a/lib/msp430/HardwareSerial.cpp b/lib/msp430/HardwareSerial.cpp new file mode 100644 index 0000000..1195262 --- /dev/null +++ b/lib/msp430/HardwareSerial.cpp @@ -0,0 +1,237 @@ +/* + ************************************************************************ + * HardwareSerial.cpp + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + HardwareSerial.cpp - Hardware serial library for Wiring + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 23 November 2006 by David A. Mellis + Modified 28 September 2010 by Mark Sproul +*/ + +#include +#include +#include +#include +#include "Energia.h" +#include "wiring_private.h" +#include "usci_isr_handler.h" + +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) + +#include "HardwareSerial.h" + +HardwareSerial *SerialPtr; + + + +#define SERIAL_BUFFER_SIZE 64 + +struct ring_buffer +{ + unsigned char buffer[SERIAL_BUFFER_SIZE]; + volatile unsigned int head; + volatile unsigned int tail; +}; + +ring_buffer rx_buffer = { { 0 }, 0, 0 }; +ring_buffer tx_buffer = { { 0 }, 0, 0 }; + +inline void store_char(unsigned char c, ring_buffer *buffer) +{ + unsigned int i = (unsigned int)(buffer->head + 1) % SERIAL_BUFFER_SIZE; + + // 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 != buffer->tail) { + buffer->buffer[buffer->head] = c; + buffer->head = i; + } +} + +void serialEvent() __attribute__((weak)); +void serialEvent() {} + +void serialEventRun(void) +{ + if (Serial.available()) serialEvent(); +} +// Constructors //////////////////////////////////////////////////////////////// + +HardwareSerial::HardwareSerial(ring_buffer *rx_buffer, ring_buffer *tx_buffer) +{ + _rx_buffer = rx_buffer; + _tx_buffer = tx_buffer; +} + +// Public Methods ////////////////////////////////////////////////////////////// +#define SMCLK F_CPU //SMCLK = F_CPU for now + +void HardwareSerial::begin(unsigned long baud) +{ + unsigned int mod, divider; + unsigned char oversampling; + + /* Calling this dummy function prevents the linker + * from stripping the USCI interupt vectors.*/ + usci_isr_install(); + if (SMCLK/baud>=48) { // requires SMCLK for oversampling + oversampling = 1; + } + else { + oversampling= 0; + } + + divider=(SMCLK<<4)/baud; + + SerialPtr = this; + + pinMode_int(UARTRXD, UARTRXD_SET_MODE); + pinMode_int(UARTTXD, UARTTXD_SET_MODE); + + UCA0CTL1 = UCSWRST; + UCA0CTL1 = UCSSEL_2; // SMCLK + UCA0CTL0 = 0; + UCA0ABCTL = 0; +#if defined(__MSP430_HAS_EUSCI_A0__) + if(!oversampling) { + mod = ((divider&0xF)+1)&0xE; // UCBRSx (bit 1-3) + divider >>=4; + } else { + mod = divider&0xFFF0; // UCBRFx = INT([(N/16) – INT(N/16)] × 16) + divider>>=8; + } + UCA0BR0 = divider; + UCA0BR1 = divider>>8; + UCA0MCTLW = (oversampling ? UCOS16:0) | mod; +#else + if(!oversampling) { + mod = ((divider&0xF)+1)&0xE; // UCBRSx (bit 1-3) + divider >>=4; + } else { + mod = ((divider&0xf8)+0x8)&0xf0; // UCBRFx (bit 4-7) + divider>>=8; + } + UCA0BR0 = divider; + UCA0BR1 = divider>>8; + UCA0MCTL = (unsigned char)(oversampling ? UCOS16:0) | mod; +#endif + UCA0CTL1 &= ~UCSWRST; +#if defined(__MSP430_HAS_EUSCI_A0__) + UCA0IE |= UCRXIE; +#else + UC0IE |= UCA0RXIE; +#endif +} + +void HardwareSerial::end() +{ + // wait for transmission of outgoing data + while (_tx_buffer->head != _tx_buffer->tail); + + _rx_buffer->head = _rx_buffer->tail; +} + +int HardwareSerial::available(void) +{ + return (unsigned int)(SERIAL_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % SERIAL_BUFFER_SIZE; +} + +int HardwareSerial::peek(void) +{ + if (_rx_buffer->head == _rx_buffer->tail) { + return -1; + } else { + return _rx_buffer->buffer[_rx_buffer->tail]; + } +} + +int HardwareSerial::read(void) +{ + // if the head isn't ahead of the tail, we don't have any characters + if (_rx_buffer->head == _rx_buffer->tail) { + return -1; + } else { + unsigned char c = _rx_buffer->buffer[_rx_buffer->tail]; + _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE; + return c; + } +} + +void HardwareSerial::flush() +{ + while (_tx_buffer->head != _tx_buffer->tail); +} + +size_t HardwareSerial::write(uint8_t c) +{ + unsigned int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE; + + // If the output buffer is full, there's nothing for it other than to + // wait for the interrupt handler to empty it a bit + // ???: return 0 here instead? + while (i == _tx_buffer->tail); + + _tx_buffer->buffer[_tx_buffer->head] = c; + _tx_buffer->head = i; + +#if defined(__MSP430_HAS_EUSCI_A0__) + UCA0IE |= UCTXIE; +#else + UC0IE |= UCA0TXIE; +#endif + + return 1; +} + +void uart_rx_isr(void) +{ + unsigned char c = UCA0RXBUF; + store_char(c, &rx_buffer); +} + +void uart_tx_isr(void) +{ + if (tx_buffer.head == tx_buffer.tail) { + // Buffer empty, so disable interrupts +#if defined(__MSP430_HAS_EUSCI_A0__) + UCA0IE &= ~UCTXIE; + UCA0IFG |= UCTXIFG; // Set Flag again +#else + UC0IE &= ~UCA0TXIE; +#endif + return; + } + + unsigned char c = tx_buffer.buffer[tx_buffer.tail]; + tx_buffer.tail = (tx_buffer.tail + 1) % SERIAL_BUFFER_SIZE; + UCA0TXBUF = c; +} + +// Preinstantiate Objects ////////////////////////////////////////////////////// + +HardwareSerial Serial(&rx_buffer, &tx_buffer); + +#endif diff --git a/lib/msp430/HardwareSerial.h b/lib/msp430/HardwareSerial.h new file mode 100644 index 0000000..8f3bf39 --- /dev/null +++ b/lib/msp430/HardwareSerial.h @@ -0,0 +1,69 @@ +/* + ************************************************************************ + * TimerSerial.h + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + HardwareSerial.cpp - Hardware serial library for Wiring + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef HardwareSerial_h +#define HardwareSerial_h + +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) +#include + +#include "Stream.h" + +struct ring_buffer; + +class HardwareSerial : public Stream +{ + private: + uint8_t lock; + ring_buffer *_rx_buffer; + ring_buffer *_tx_buffer; +#if defined(__MSP430_HAS_EUSCI_A0__) + static void USCIA0_ISR (void); +#else + static void USCI0RX_ISR (void); + static void USCI0TX_ISR (void); +#endif + public: + HardwareSerial(ring_buffer *rx_buffer, ring_buffer *tx_buffer); + void begin(unsigned long); + void end(); + virtual int available(void); + virtual int peek(void); + virtual int read(void); + virtual void flush(void); + virtual size_t write(uint8_t); + using Print::write; // pull in write(str) and write(buf, size) from Print +}; + +extern HardwareSerial Serial; + +extern void serialEventRun(void) __attribute__((weak)); + +#endif // __MSP430_HAS_USCI__ + +#endif diff --git a/lib/msp430/Print.cpp b/lib/msp430/Print.cpp new file mode 100644 index 0000000..18c48f1 --- /dev/null +++ b/lib/msp430/Print.cpp @@ -0,0 +1,252 @@ +/* + Print.cpp - Base class that provides print() and println() + Copyright (c) 2008 David A. Mellis. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 23 November 2006 by David A. Mellis + Modified for msp403 2012 by Robert Wessels + */ + +#include +#include +#include +#include +#include "Energia.h" + +#include "Print.h" + +// Public Methods ////////////////////////////////////////////////////////////// + +/* default implementation: may be overridden */ +size_t Print::write(const uint8_t *buffer, size_t size) +{ + size_t n = 0; + while (size--) { + n += write(*buffer++); + } + return n; +} + +size_t Print::print(const String &s) +{ + size_t n = 0; + for (uint16_t i = 0; i < s.length(); i++) { + n += write(s[i]); + } + return n; +} + +size_t Print::print(const char str[]) +{ + return write(str); +} + +size_t Print::print(char c) +{ + return write(c); +} + +size_t Print::print(unsigned char b, int base) +{ + return print((unsigned long) b, base); +} + +size_t Print::print(int n, int base) +{ + return print((long) n, base); +} + +size_t Print::print(unsigned int n, int base) +{ + return print((unsigned long) n, base); +} + +size_t Print::print(long n, int base) +{ + if (base == 0) { + return write(n); + } else if (base == 10) { + if (n < 0) { + int t = print('-'); + n = -n; + return printNumber(n, 10) + t; + } + return printNumber(n, 10); + } else { + return printNumber(n, base); + } +} + +size_t Print::print(unsigned long n, int base) +{ + if (base == 0) return write(n); + else return printNumber(n, base); +} + +size_t Print::print(double n, int digits) +{ + return printFloat(n, digits); +} + +//size_t Print::println(const __FlashStringHelper *ifsh) +//{ +// size_t n = print(ifsh); +// n += println(); +// return n; +//} + +size_t Print::print(const Printable& x) +{ + return x.printTo(*this); +} + +size_t Print::println(void) +{ + size_t n = print('\r'); + n += print('\n'); + return n; +} + +size_t Print::println(const String &s) +{ + size_t n = print(s); + n += println(); + return n; +} + +size_t Print::println(const char c[]) +{ + size_t n = print(c); + n += println(); + return n; +} + +size_t Print::println(char c) +{ + size_t n = print(c); + n += println(); + return n; +} + +size_t Print::println(unsigned char b, int base) +{ + size_t n = print(b, base); + n += println(); + return n; +} + +size_t Print::println(int num, int base) +{ + size_t n = print(num, base); + n += println(); + return n; +} + +size_t Print::println(unsigned int num, int base) +{ + size_t n = print(num, base); + n += println(); + return n; +} + +size_t Print::println(long num, int base) +{ + size_t n = print(num, base); + n += println(); + return n; +} + +size_t Print::println(unsigned long num, int base) +{ + size_t n = print(num, base); + n += println(); + return n; +} + +size_t Print::println(double num, int digits) +{ + size_t n = print(num, digits); + n += println(); + return n; +} + +size_t Print::println(const Printable& x) +{ + size_t n = print(x); + n += println(); + return n; +} + +// Private Methods ///////////////////////////////////////////////////////////// + +size_t Print::printNumber(unsigned long n, uint8_t base) { + char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte. + char *str = &buf[sizeof(buf) - 1]; + + *str = '\0'; + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + unsigned long m = n; + n /= base; + char c = m - base * n; + *--str = c < 10 ? c + '0' : c + 'A' - 10; + } while(n); + + return write(str); +} + +size_t Print::printFloat(double number, uint8_t digits) +{ + size_t n = 0; + + // Handle negative numbers + if (number < 0.0) + { + n += print('-'); + number = -number; + } + + // Round correctly so that print(1.999, 2) prints as "2.00" + double rounding = 0.5; + for (uint8_t i=0; i 0) { + n += print("."); + } + + // Extract digits from the remainder one at a time + while (digits-- > 0) + { + remainder *= 10.0; + int toPrint = int(remainder); + n += print(toPrint); + remainder -= toPrint; + } + + return n; +} diff --git a/lib/msp430/Print.h b/lib/msp430/Print.h new file mode 100644 index 0000000..65ca598 --- /dev/null +++ b/lib/msp430/Print.h @@ -0,0 +1,85 @@ +/* + Print.h - Base class that provides print() and println() + Copyright (c) 2008 David A. Mellis. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef Print_h +#define Print_h + +#include +#include // for size_t + +#include "WString.h" +#include "Printable.h" + +#define DEC 10 +#define HEX 16 +#define OCT 8 +#define BIN 2 + +class Print +{ + private: + int write_error; + size_t printNumber(unsigned long, uint8_t); + size_t printFloat(double, uint8_t); + + // Prevent heap allocation + void * operator new (size_t); + void * operator new[] (size_t); + void operator delete (void *); + void operator delete[] (void*); + + protected: + void setWriteError(int err = 1) { write_error = err; } + public: + Print() : write_error(0) {} + + int getWriteError() { return write_error; } + void clearWriteError() { setWriteError(0); } + + virtual size_t write(uint8_t) = 0; + size_t write(const char *str) { return write((const uint8_t *)str, strlen(str)); } + virtual size_t write(const uint8_t *buffer, size_t size); + + //size_t print(const __FlashStringHelper *); + size_t print(const String &); + size_t print(const char[]); + size_t print(char); + size_t print(unsigned char, int = DEC); + size_t print(int, int = DEC); + size_t print(unsigned int, int = DEC); + size_t print(long, int = DEC); + size_t print(unsigned long, int = DEC); + size_t print(double, int = 2); + size_t print(const Printable&); + + //size_t println(const __FlashStringHelper *); + size_t println(const String &s); + size_t println(const char[]); + size_t println(char); + size_t println(unsigned char, int = DEC); + size_t println(int, int = DEC); + size_t println(unsigned int, int = DEC); + size_t println(long, int = DEC); + size_t println(unsigned long, int = DEC); + size_t println(double, int = 2); + size_t println(const Printable&); + size_t println(void); +}; + +#endif diff --git a/lib/msp430/Printable.h b/lib/msp430/Printable.h new file mode 100644 index 0000000..d03c9af --- /dev/null +++ b/lib/msp430/Printable.h @@ -0,0 +1,40 @@ +/* + Printable.h - Interface class that allows printing of complex types + Copyright (c) 2011 Adrian McEwen. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef Printable_h +#define Printable_h + +#include + +class Print; + +/** The Printable class provides a way for new classes to allow themselves to be printed. + By deriving from Printable and implementing the printTo method, it will then be possible + for users to print out instances of this class by passing them into the usual + Print::print and Print::println methods. +*/ + +class Printable +{ + public: + virtual size_t printTo(Print& p) const = 0; +}; + +#endif + diff --git a/lib/msp430/Stream.cpp b/lib/msp430/Stream.cpp new file mode 100644 index 0000000..c7d1863 --- /dev/null +++ b/lib/msp430/Stream.cpp @@ -0,0 +1,246 @@ +/* + Stream.cpp - adds parsing methods to Stream class + Copyright (c) 2008 David A. Mellis. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Created July 2011 + parsing functions based on TextFinder library by Michael Margolis + */ + +#include "Energia.h" +#include "Stream.h" + +#define PARSE_TIMEOUT 1000 // default number of milli-seconds to wait +#define NO_SKIP_CHAR 1 // a magic char not found in a valid ASCII numeric field + +// private method to read stream with timeout +int Stream::timedRead() +{ + int c; + _startMillis = millis(); + do { + c = read(); + if (c >= 0) return c; + } while(millis() - _startMillis < _timeout); + return -1; // -1 indicates timeout +} + +// private method to peek stream with timeout +int Stream::timedPeek() +{ + int c; + _startMillis = millis(); + do { + c = peek(); + if (c >= 0) return c; + } while(millis() - _startMillis < _timeout); + return -1; // -1 indicates timeout +} + +// returns peek of the next digit in the stream or -1 if timeout +// discards non-numeric characters +int Stream::peekNextDigit() +{ + int c; + while (1) { + c = timedPeek(); + if (c < 0) return c; // timeout + if (c == '-') return c; + if (c >= '0' && c <= '9') return c; + read(); // discard non-numeric + } +} + +// Public Methods +////////////////////////////////////////////////////////////// + +void Stream::setTimeout(unsigned long timeout) // sets the maximum number of milliseconds to wait +{ + _timeout = timeout; +} + + // find returns true if the target string is found +bool Stream::find(char *target) +{ + return findUntil(target, NULL); +} + +// reads data from the stream until the target string of given length is found +// returns true if target string is found, false if timed out +bool Stream::find(char *target, size_t length) +{ + return findUntil(target, length, NULL, 0); +} + +// as find but search ends if the terminator string is found +bool Stream::findUntil(char *target, char *terminator) +{ + return findUntil(target, strlen(target), terminator, strlen(terminator)); +} + +// reads data from the stream until the target string of the given length is found +// search terminated if the terminator string is found +// returns true if target string is found, false if terminated or timed out +bool Stream::findUntil(char *target, size_t targetLen, char *terminator, size_t termLen) +{ + size_t index = 0; // maximum target string length is 64k bytes! + size_t termIndex = 0; + int c; + + if( *target == 0) + return true; // return true if target is a null string + while( (c = timedRead()) > 0){ + + if(c != target[index]) + index = 0; // reset index if any char does not match + + if( c == target[index]){ + //////Serial.print("found "); Serial.write(c); Serial.print("index now"); Serial.println(index+1); + if(++index >= targetLen){ // return true if all chars in the target match + return true; + } + } + + if(termLen > 0 && c == terminator[termIndex]){ + if(++termIndex >= termLen) + return false; // return false if terminate string found before target string + } + else + termIndex = 0; + } + return false; +} + + +// returns the first valid (long) integer value from the current position. +// initial characters that are not digits (or the minus sign) are skipped +// function is terminated by the first character that is not a digit. +long Stream::parseInt() +{ + return parseInt(NO_SKIP_CHAR); // terminate on first non-digit character (or timeout) +} + +// as above but a given skipChar is ignored +// this allows format characters (typically commas) in values to be ignored +long Stream::parseInt(char skipChar) +{ + boolean isNegative = false; + long value = 0; + int c; + + c = peekNextDigit(); + // ignore non numeric leading characters + if(c < 0) + return 0; // zero returned if timeout + + do{ + if(c == skipChar) + ; // ignore this charactor + else if(c == '-') + isNegative = true; + else if(c >= '0' && c <= '9') // is c a digit? + value = value * 10 + c - '0'; + read(); // consume the character we got with peek + c = timedPeek(); + } + while( (c >= '0' && c <= '9') || c == skipChar ); + + if(isNegative) + value = -value; + return value; +} + + +// as parseInt but returns a floating point value +float Stream::parseFloat() +{ + return parseFloat(NO_SKIP_CHAR); +} + +// as above but the given skipChar is ignored +// this allows format characters (typically commas) in values to be ignored +float Stream::parseFloat(char skipChar){ + boolean isNegative = false; + boolean isFraction = false; + long value = 0; + char c; + float fraction = 1.0; + + c = peekNextDigit(); + // ignore non numeric leading characters + if(c < 0) + return 0; // zero returned if timeout + + do{ + if(c == skipChar) + ; // ignore + else if(c == '-') + isNegative = true; + else if (c == '.') + isFraction = true; + else if(c >= '0' && c <= '9') { // is c a digit? + value = value * 10 + c - '0'; + if(isFraction) + fraction *= 0.1; + } + read(); // consume the character we got with peek + c = timedPeek(); + } + while( (c >= '0' && c <= '9') || c == '.' || c == skipChar ); + + if(isNegative) + value = -value; + if(isFraction) + return value * fraction; + else + return value; +} + +// read characters from stream into buffer +// terminates if length characters have been read, or timeout (see setTimeout) +// returns the number of characters placed in the buffer +// the buffer is NOT null terminated. +// +size_t Stream::readBytes(char *buffer, size_t length) +{ + size_t count = 0; + while (count < length) { + int c = timedRead(); + if (c < 0) break; + *buffer++ = (char)c; + count++; + } + return count; +} + + +// as readBytes with terminator character +// terminates if length characters have been read, timeout, or if the terminator character detected +// returns the number of characters placed in the buffer (0 means no valid data found) + +size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length) +{ + if (length < 1) return 0; + size_t index = 0; + while (index < length) { + int c = timedRead(); + if (c < 0 || c == terminator) break; + *buffer++ = (char)c; + index++; + } + return index; // return number of characters, not including null terminator +} + diff --git a/lib/msp430/Stream.h b/lib/msp430/Stream.h new file mode 100644 index 0000000..13f11be --- /dev/null +++ b/lib/msp430/Stream.h @@ -0,0 +1,94 @@ +/* + Stream.h - base class for character-based streams. + Copyright (c) 2010 David A. Mellis. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + parsing functions based on TextFinder library by Michael Margolis +*/ + +#ifndef Stream_h +#define Stream_h + +#include +#include "Print.h" + +// compatability macros for testing +/* +#define getInt() parseInt() +#define getInt(skipChar) parseInt(skipchar) +#define getFloat() parseFloat() +#define getFloat(skipChar) parseFloat(skipChar) +#define getString( pre_string, post_string, buffer, length) +readBytesBetween( pre_string, terminator, buffer, length) +*/ + +class Stream : public Print +{ + private: + unsigned long _timeout; // number of milliseconds to wait for the next char before aborting timed read + unsigned long _startMillis; // used for timeout measurement + int timedRead(); // private method to read stream with timeout + int timedPeek(); // private method to peek stream with timeout + int peekNextDigit(); // returns the next numeric digit in the stream or -1 if timeout + + public: + virtual int available() = 0; + virtual int read() = 0; + virtual int peek() = 0; + virtual void flush() = 0; + + Stream() {_timeout=1000;} + +// parsing methods + + void setTimeout(unsigned long timeout); // sets maximum milliseconds to wait for stream data, default is 1 second + + bool find(char *target); // reads data from the stream until the target string is found + // returns true if target string is found, false if timed out (see setTimeout) + + bool find(char *target, size_t length); // reads data from the stream until the target string of given length is found + // returns true if target string is found, false if timed out + + bool findUntil(char *target, char *terminator); // as find but search ends if the terminator string is found + + bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen); // as above but search ends if the terminate string is found + + + long parseInt(); // returns the first valid (long) integer value from the current position. + // initial characters that are not digits (or the minus sign) are skipped + // integer is terminated by the first character that is not a digit. + + float parseFloat(); // float version of parseInt + + size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer + // terminates if length characters have been read or timeout (see setTimeout) + // returns the number of characters placed in the buffer (0 means no valid data found) + + size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character + // terminates if length characters have been read, timeout, or if the terminator character detected + // returns the number of characters placed in the buffer (0 means no valid data found) + + // Arduino String functions to be added here + + protected: + long parseInt(char skipChar); // as above but the given skipChar is ignored + // as above but the given skipChar is ignored + // this allows format characters (typically commas) in values to be ignored + + float parseFloat(char skipChar); // as above but the given skipChar is ignored +}; + +#endif diff --git a/lib/msp430/TimerSerial.cpp b/lib/msp430/TimerSerial.cpp new file mode 100644 index 0000000..e32d902 --- /dev/null +++ b/lib/msp430/TimerSerial.cpp @@ -0,0 +1,272 @@ +/* + ************************************************************************ + * TimerSerial.cpp + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + HardwareSerial.cpp - Hardware serial library for Wiring + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + and + msp430softserial by Rick Kimball + https://github.com/RickKimball + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include "Energia.h" +#include "TimerSerial.h" + +#define SERIAL_BUFFER_SIZE 64 + +#ifndef TIMERA0_VECTOR + #define TIMERA0_VECTOR TIMER0_A0_VECTOR +#endif /* TIMER0_A0_VECTOR */ + +#ifndef TIMERA1_VECTOR + #define TIMERA1_VECTOR TIMER0_A1_VECTOR +#endif /* TIMERA1_VECTOR */ + +struct ring_buffer_ts +{ + volatile unsigned int head; + volatile unsigned int tail; + unsigned char buffer[SERIAL_BUFFER_SIZE]; +}; + +/** + * uint8x2_t - optimized structure storage for ISR. Fits our static variables in one register + * This tweak allows the ISR to use one less register saving a push and pop + * We also save a couple of instructions being able to write to both values with + * one mov.w instruction. + */ +typedef union uint8x2_t { + //---------- word access + uint16_t mask_data; // access both as a word: mask is low byte, data is high byte + //--- or --- individual byte access + struct { + uint8_t mask:8; // bit mask to set data bits. Also used as a loop end flag + uint8_t data:8; // working value for bits received + } b; +} uint8x2_t; + +// --- --- +static volatile unsigned int USARTTXBUF; +static uint16_t TICKS_PER_BIT; +static uint16_t TICKS_PER_BIT_DIV2; +static ring_buffer_ts rx_buffer; + +#if NEEDS_BUFF_PTR + static ring_buffer_ts tx_buffer; // required for the g2231, without it we get garbage +#endif + +#if !defined(__MSP430_HAS_USCI__) && !defined(__MSP430_HAS_EUSCI_A0__) +TimerSerial Serial; +#endif + +void serialEvent() __attribute__((weak)); +void serialEvent() {} + +void serialEventRun(void) +{ + if (Serial.available()) serialEvent(); +} + +TimerSerial::TimerSerial() +{ +#if NEEDS_BUFF_PTR + _rx_buffer = &rx_buffer; + _tx_buffer = &tx_buffer; +#endif +} + +void TimerSerial::begin(register unsigned long baud) +{ + pinMode_int(UARTRXD, UARTRXD_SET_MODE); + pinMode_int(UARTTXD, UARTTXD_SET_MODE); + + TA0CCTL0 = OUT; // Set TXD Idle state as Mark = '1', +3.3 volts normal + TA0CCTL1 = SCS | CM1 | CAP | CCIE; // Sync TACLK and MCLK, Detect Neg Edge, Enable Capture mode and RX Interrupt + TA0CTL = TASSEL_2 | MC_2 | TACLR; // Clock TIMERA from SMCLK, run in continuous mode counting from to 0-0xFFFF + +#if F_CPU == 1000000 + baud = (baud<=4800) ? baud : 4800; // force 4800 for slow F_CPU +#endif + + TICKS_PER_BIT = F_CPU / baud; + TICKS_PER_BIT_DIV2 = TICKS_PER_BIT >> 1; +} + +void TimerSerial::end() +{ + while (TA0CCTL0 & CCIE) { + ; // wait for previous xmit to finish + } + pinMode(UARTTXD, INPUT); +} + +int TimerSerial::read() +{ + register uint16_t temp_tail=rx_buffer.tail; + + if (rx_buffer.head != temp_tail) { + uint8_t c = rx_buffer.buffer[temp_tail++]; + rx_buffer.tail = temp_tail % SERIAL_BUFFER_SIZE; + return c; + } + else { + return -1; + } +} + +int TimerSerial::available() +{ + unsigned cnt = (rx_buffer.head - rx_buffer.tail) % SERIAL_BUFFER_SIZE; + + return cnt; +} + +void TimerSerial::flush() +{ + while (TA0CCTL0 & CCIE) { + ; // wait for previous xmit to finish + } +} + +int TimerSerial::peek() +{ + register uint16_t temp_tail=rx_buffer.tail; + + if (rx_buffer.head != temp_tail) { + return rx_buffer.buffer[temp_tail]; + } + else { + return -1; + } +} + +size_t TimerSerial::write(uint8_t c) +{ + // TIMERA0 disables the interrupt flag when it has sent + // the final stop bit. While a transmit is in progress the + // interrupt is enabled + while (TA0CCTL0 & CCIE) { + ; // wait for previous xmit to finish + } + + // make the next output at least TICKS_PER_BIT in the future + // so we don't stomp on the the stop bit from our previous xmt + + TA0CCR0 = TA0R; // resync with current TimerA clock + TA0CCR0 += TICKS_PER_BIT; // setup the next timer tick + TA0CCTL0 = OUTMOD0 + CCIE; // set TX_PIN HIGH and reenable interrupts + + // now that we have set the next interrupt in motion + // we quickly need to set the TX data. Hopefully the + // next 2 lines happens before the next timer tick. + + // Note: This code makes great use of multiple peripherals + // + // In the code above, we start with a busy wait on the CCIE + // interrupt flag. As soon as it is available, we setup the next + // send time and then enable the interrupt. Until that time happens, + // we have a few free cycles available to stuff the start and stop bits + // into the data buffer before the timer ISR kicks in and handles + // the event. Note: if you are using a really slow clock or a really + // fast baud rate you could run into problems if the interrupt is + // triggered before you have finished with the USARTTXBUF + + register unsigned value = c | 0x100; // add stop bit '1' + value <<= 1; // Add the start bit '0' + USARTTXBUF=value; // queue up the byte for xmit + return 1; +} + + +#ifndef TIMER0_A0_VECTOR +#define TIMER0_A0_VECTOR TIMERA0_VECTOR +#endif /* TIMER0_A0_VECTOR */ + +#ifndef __GNUC__ +#pragma vector = TIMER0_A0_VECTOR +__interrupt +#else +__attribute__((interrupt(TIMER0_A0_VECTOR))) +#endif +//Timer0 A0 interrupt service routine +static void TimerSerial__TxIsr(void) +{ + TA0CCR0 += TICKS_PER_BIT; // setup next time to send a bit, OUT will be set then + + TA0CCTL0 |= OUTMOD2; // reset OUT (set to 0) OUTMOD2|OUTMOD0 (0b101) + if ( USARTTXBUF & 0x01 ) { // look at LSB if 1 then set OUT high + TA0CCTL0 &= ~OUTMOD2; // set OUT (set to 1) OUTMOD0 (0b001) + } + + if (!(USARTTXBUF >>= 1)) { // All bits transmitted ? + TA0CCTL0 &= ~CCIE; // disable interrupt, indicates we are done + } +} + +#define store_rxchar(c) { \ + register unsigned int next_head;\ + next_head = rx_buffer.head;\ + rx_buffer.buffer[next_head++]=c; \ + next_head %= SERIAL_BUFFER_SIZE; \ + if ( next_head != rx_buffer.tail ) { \ + rx_buffer.head = next_head; \ + } \ +} + +#ifndef TIMER0_A1_VECTOR +#define TIMER0_A1_VECTOR TIMERA1_VECTOR +#endif /* TIMER0_A0_VECTOR */ + +#ifndef __GNUC__ +#pragma vector = TIMER0_A1_VECTOR +__interrupt +#else +__attribute__((interrupt(TIMER0_A1_VECTOR))) +#endif +//Timer A1 interrupt service routine +static void TimerSerial__RxIsr(void) +{ + static uint8x2_t rx_bits; // persistent storage for data and mask. fits in one 16 bit register + volatile uint16_t resetTAIVIFG; // just reading TAIV will reset the interrupt flag + resetTAIVIFG=TA0IV;(void)resetTAIVIFG; + + register uint16_t regCCTL1=TA0CCTL1; // using a temp register provides a slight performance improvement + + TA0CCR1 += TICKS_PER_BIT; // Setup next time to sample + + if (regCCTL1 & CAP) { // Are we in capture mode? If so, this is a start bit + TA0CCR1 += TICKS_PER_BIT_DIV2; // adjust sample time, so next sample is in the middle of the bit width + rx_bits.mask_data = 0x0001; // initialize both values, set data to 0x00 and mask to 0x01 + TA0CCTL1 = regCCTL1 & ~CAP; // Switch from capture mode to compare mode + } + else { + if (regCCTL1 & SCCI) { // sampled bit value from receive latch + rx_bits.b.data|=rx_bits.b.mask; // if latch is high, then set the bit using the sliding mask + } + + if (!(rx_bits.b.mask <<= 1)) { // Are all bits received? Use the mask to end loop + store_rxchar(rx_bits.b.data); // Store the bits into the rx_buffer + TA0CCTL1 = regCCTL1 | CAP; // Switch back to capture mode and wait for next start bit (HI->LOW) + } + } +} diff --git a/lib/msp430/TimerSerial.h b/lib/msp430/TimerSerial.h new file mode 100644 index 0000000..58dc660 --- /dev/null +++ b/lib/msp430/TimerSerial.h @@ -0,0 +1,78 @@ +/* + TimerSerial.h - Timer based serial library for MSP430 + Copyright (c) 2012 Robert Wessels. All right reserved. + Modeled after Nicholas Zambetti's HardwareSerial. + and + msp430softserial by Rick Kimball + https://github.com/RickKimball/msp430softserial/ + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef TimerSerial_h +#define TimerSerial_h + +#include +#include + +#define TX_PIN BIT1 // TXD on P1.1 +#define RX_PIN BIT2 // RXD on P1.2 + +// running at < 3MHz requires a lower baud rate +#ifndef TIMERSERIAL_BAUD +#if F_CPU > 1000000 + #define TIMERSERIAL_BAUD 9600 +#else + #define TIMERSERIAL_BAUD 4800 +#endif +#endif + +#if defined(__MSP430G2231__) + #define NEEDS_BUFF_PTR 1 // sadly, the g2231 seems to have a problem if we don't use the original structure + struct ring_buffer_ts; // forward declaration +#else + #define NEEDS_BUFF_PTR 0 // everything else is happy to run fully optimized +#endif + +class TimerSerial : public Stream +{ +public: + TimerSerial(void); + + void begin(unsigned long baud = TIMERSERIAL_BAUD); + void end(void); + + virtual size_t write(uint8_t byte); + virtual int read(void); + virtual int available(void); + virtual void flush(void); + virtual int peek(void); + + using Print::write; + +private: + +#if NEEDS_BUFF_PTR + ring_buffer_ts *_rx_buffer; // gcc seems to get confused on the g2231 without this + ring_buffer_ts *_tx_buffer; +#endif + +}; + +#if !defined(__MSP430_HAS_USCI__) && !defined(__MSP430_HAS_EUSCI_A0__) +extern TimerSerial Serial; +#endif +extern void serialEventRun(void) __attribute__((weak)); +#endif diff --git a/lib/msp430/Tone.cpp b/lib/msp430/Tone.cpp new file mode 100755 index 0000000..dd4aaeb --- /dev/null +++ b/lib/msp430/Tone.cpp @@ -0,0 +1,223 @@ +/* Tone.cpp + + A Tone Generator Library - Modified for Energia + Implements up to 3 (software) PWM outputs using TIMERA0 compare registers and IRQ. + Can use any digital output pin for pulse generation + + (c) 2012 - Peter Brier. + + Based on code Originally written by Brett Hagman + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +Version Modified By Date Comments +------- ----------- -------- -------- +0001 B Hagman 09/08/02 Initial coding +0002 B Hagman 09/08/18 Multiple pins +0003 B Hagman 09/08/18 Moved initialization from constructor to begin() +0004 B Hagman 09/09/26 Fixed problems with ATmega8 +0005 B Hagman 09/11/23 Scanned prescalars for best fit on 8 bit timers + 09/11/25 Changed pin toggle method to XOR + 09/11/25 Fixed timer0 from being excluded +0006 D Mellis 09/12/29 Replaced objects with functions +0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register +0008 P Brier 12/05/28 Modified for TI MSP430 processor +0009 P Brier 12/05/29 Fixed problem with re-init of expired tone +*************************************************/ + +#include "wiring_private.h" +#include "pins_energia.h" +#include "Energia.h" + +// local funcions +static void initTimers(); +static void setTimer(uint8_t n, unsigned int frequency, unsigned long duration); +static void stopTimer(uint8_t n); + +// timer clock frequency set to clock/8, at F_CPU = 1MHZ this gives an output freq range of ~[1Hz ..65Khz] and at 16Mhz this is ~[16Hz .. 1MHz] +#define F_TIMER (F_CPU/8L) + +#ifdef __MSP430_HAS_TA3__ +#define AVAILABLE_TONE_PINS 3 +#define SETARRAY(a) a,a,a +#else +#define AVAILABLE_TONE_PINS 2 +#define SETARRAY(a) a,a +#endif + + +// tone_duration: +// > 0 - duration specified +// = 0 - stopped +// < 0 - infinitely (until stop() method called, or new play() called) + +static uint8_t tone_state = 0; // 0==not initialized, 1==timer running +static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { SETARRAY(255) }; +static uint8_t tone_bit[AVAILABLE_TONE_PINS] = { SETARRAY(255) }; +volatile static uint8_t *tone_out[AVAILABLE_TONE_PINS] = { SETARRAY(0) }; +static uint16_t tone_interval[AVAILABLE_TONE_PINS] = { SETARRAY(-1) }; +static int16_t tone_periods[AVAILABLE_TONE_PINS] = { SETARRAY(0) }; + + +/** +*** tone() -- Output a tone (50% Dutycycle PWM signal) on a pin +*** pin: This pin is selected as output +*** frequency: [Hertz] +** duration: [milliseconds], if duration <=0, then we output tone continously, otherwise tone is stopped after this time (output = 0) +**/ +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration) +{ + uint8_t port = digitalPinToPort(_pin); + if (port == NOT_A_PORT) return; + + // find if we are using it at the moment, if so: update it + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) + { + if (tone_pins[i] == _pin) + { + setTimer(i, frequency, duration); + return; // we are done, timer reprogrammed + } + } + + // new tone pin, find empty timer and set it + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) + { + if (tone_pins[i] == 255) + { + tone_pins[i] = _pin; + tone_bit[i] = digitalPinToBitMask(_pin); + tone_out[i] = portOutputRegister(port); + if ( tone_state == 0 ) + initTimers(); + pinMode(_pin, OUTPUT); + setTimer(i, frequency, duration); + return; // we are done, timer set + } + } + // if we exit here, no unused timer was found, nothing is done +} + + +/** +*** noTone() - Stop outputting the tone on a pin +**/ +void noTone(uint8_t _pin) +{ + if ( _pin == 255 ) return; // Should not happen! + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) + { + if (tone_pins[i] == _pin) + { + tone_pins[i] = 255; + stopTimer(i); + } + } +} + + +// Initialize the timers - Set mode and Enable IRQ +static void inline initTimers() +{ + // disable IRQs + TA0CCTL0 = 0; + TA0CCTL1 = 0; +#ifdef __MSP430_HAS_TA3__ + TA0CCTL2 = 0; +#endif + TA0CTL = TACLR + TASSEL_2 + ID_3 + MC_2; // clear counter, source=SMCLK/8, mode=continous count up + tone_state = 1; // init is done +} + + +// Set the timer interval and duration +// frequency in [Hz] and duration in [msec] +// we initialize the timer match value only if the tone was not running already, to prevent glitches when re-programming a running tone +static void setTimer(uint8_t n, unsigned int frequency, unsigned long duration) +{ + if ( frequency <= 0 ) + { + tone_interval[n] = 0; + tone_periods[n] = 0; + return; + } + tone_interval[n] = F_TIMER / (2L*frequency); + if ( duration > 0 ) + tone_periods[n] = (duration * (F_TIMER/2)) / (1000L * tone_interval[n]); + else + tone_periods[n] = -1; + switch( n ) // enable IRQ and set next match time in various timer compare registers (if we where not enabled already) + { + case 0: + if ( ! (TA0CCTL0 & CCIE) ) TA0CCR0 = TA0R + tone_interval[0]; + TA0CCTL0 = CCIE; + break; + case 1: + if ( !(TA0CCTL1 & CCIE) ) TA0CCR1 = TA0R + tone_interval[1]; + TA0CCTL1 = CCIE; + break; +#ifdef __MSP430_HAS_TA3__ + case 2: + if ( !(TA0CCTL2 & CCIE) ) TA0CCR2 = TA0R + tone_interval[2]; + TA0CCTL2 = CCIE; + break; +#endif + } +} + +/* stopTimer() - Disable timer IRQ */ +static void inline stopTimer(uint8_t n) +{ + switch( n ) + { + case 0: TA0CCTL0 = 0; break; + case 1: TA0CCTL1 = 0; break; +#ifdef __MSP430_HAS_TA3__ + case 2: TA0CCTL2 = 0; break; +#endif + } + *tone_out[n] &= ~tone_bit[n]; +} + + +// Peform the isr magic, toggle output, decrease duation if > 0, and stop if duration == 0, continous if duration < 0 +// set new interval - defined as macro to limit ISR overhead (at the expense of some code size) +#define isrTimer(n,ccr) do { \ + *tone_out[n] ^= tone_bit[n]; \ + if ( tone_periods[n] == 0 ) stopTimer(n);\ + else if ( tone_periods[n] > 0) tone_periods[n]--; \ + ccr += tone_interval[n]; \ +} while(0) + + +// TIMERA vector (CCR0) +__attribute__((interrupt(TIMER0_A0_VECTOR))) +void TIMER0_A0_ISR(void) +{ + isrTimer(0, TA0CCR0); +} + +// TAIV vector (CCR1/CCR2) +__attribute__((interrupt(TIMER0_A1_VECTOR))) +void TIMER0_A1_ISR(void) +{ + switch ( TA0IV ) + { + case 0x2: isrTimer(1, TA0CCR1); break; // CCR1 +#ifdef __MSP430_HAS_TA3__ + case 0x4: isrTimer(2, TA0CCR2); break; // CCR2 +#endif + } +} diff --git a/lib/msp430/WCharacter.h b/lib/msp430/WCharacter.h new file mode 100644 index 0000000..074539c --- /dev/null +++ b/lib/msp430/WCharacter.h @@ -0,0 +1,170 @@ +/* + WCharacter.h - Character utility functions for Wiring & Arduino + Copyright (c) 2010 Hernando Barragan. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef Character_h +#define Character_h + +#include + +// WCharacter.h prototypes +inline boolean isAlphaNumeric(int c) __attribute__((always_inline)); +inline boolean isAlpha(int c) __attribute__((always_inline)); +inline boolean isAscii(int c) __attribute__((always_inline)); +inline boolean isWhitespace(int c) __attribute__((always_inline)); +inline boolean isControl(int c) __attribute__((always_inline)); +inline boolean isDigit(int c) __attribute__((always_inline)); +inline boolean isGraph(int c) __attribute__((always_inline)); +inline boolean isLowerCase(int c) __attribute__((always_inline)); +inline boolean isPrintable(int c) __attribute__((always_inline)); +inline boolean isPunct(int c) __attribute__((always_inline)); +inline boolean isSpace(int c) __attribute__((always_inline)); +inline boolean isUpperCase(int c) __attribute__((always_inline)); +inline boolean isHexadecimalDigit(int c) __attribute__((always_inline)); +inline int toAscii(int c) __attribute__((always_inline)); +inline int toLowerCase(int c) __attribute__((always_inline)); +inline int toUpperCase(int c)__attribute__((always_inline)); + + +// Checks for an alphanumeric character. +// It is equivalent to (isalpha(c) || isdigit(c)). +inline boolean isAlphaNumeric(int c) +{ + return ( isalnum(c) == 0 ? false : true); +} + + +// Checks for an alphabetic character. +// It is equivalent to (isupper(c) || islower(c)). +inline boolean isAlpha(int c) +{ + return ( isalpha(c) == 0 ? false : true); +} + + +// Checks whether c is a 7-bit unsigned char value +// that fits into the ASCII character set. +inline boolean isAscii(int c) +{ + return ( isascii (c) == 0 ? false : true); +} + + +// Checks for a blank character, that is, a space or a tab. +inline boolean isWhitespace(int c) +{ + return ( isblank (c) == 0 ? false : true); +} + + +// Checks for a control character. +inline boolean isControl(int c) +{ + return ( iscntrl (c) == 0 ? false : true); +} + + +// Checks for a digit (0 through 9). +inline boolean isDigit(int c) +{ + return ( isdigit (c) == 0 ? false : true); +} + + +//TODO: mspgcc does not seem to have isgraph?!? + +//// Checks for any printable character except space. +//inline boolean isGraph(int c) +//{ +// return ( isgraph (c) == 0 ? false : true); +//} + + +// Checks for a lower-case character. +inline boolean isLowerCase(int c) +{ + return (islower (c) == 0 ? false : true); +} + + +// Checks for any printable character including space. +inline boolean isPrintable(int c) +{ + return ( isprint (c) == 0 ? false : true); +} + + +// Checks for any printable character which is not a space +// or an alphanumeric character. +inline boolean isPunct(int c) +{ + return ( ispunct (c) == 0 ? false : true); +} + + +// Checks for white-space characters. For the avr-libc library, +// these are: space, formfeed ('\f'), newline ('\n'), carriage +// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). +inline boolean isSpace(int c) +{ + return ( isspace (c) == 0 ? false : true); +} + + +// Checks for an uppercase letter. +inline boolean isUpperCase(int c) +{ + return ( isupper (c) == 0 ? false : true); +} + + +// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7 +// 8 9 a b c d e f A B C D E F. +inline boolean isHexadecimalDigit(int c) +{ + return ( isxdigit (c) == 0 ? false : true); +} + + +// Converts c to a 7-bit unsigned char value that fits into the +// ASCII character set, by clearing the high-order bits. +inline int toAscii(int c) +{ + return toascii (c); +} + + +// Warning: +// Many people will be unhappy if you use this function. +// This function will convert accented letters into random +// characters. + +// Converts the letter c to lower case, if possible. +inline int toLowerCase(int c) +{ + return tolower (c); +} + + +// Converts the letter c to upper case, if possible. +inline int toUpperCase(int c) +{ + return toupper (c); +} + +#endif diff --git a/lib/msp430/WInterrupts.c b/lib/msp430/WInterrupts.c new file mode 100644 index 0000000..e0fba17 --- /dev/null +++ b/lib/msp430/WInterrupts.c @@ -0,0 +1,138 @@ +/* + ************************************************************************ + * WInterrupts.c + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + + WInterrupts.c Part of the Wiring project - http://wiring.uniandes.edu.co + + Copyright (c) 2004-05 Hernando Barragan + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + Modified 24 November 2006 by David A. Mellis + Modified 1 August 2010 by Mark Sproul +*/ + +#include +#include + +#include "wiring_private.h" + +#ifndef BV +#define BV(x) (1 << (x)) +#endif + +#define bit_pos(A) ((A) == 1u << 0 ? 0 \ +: (A) == 1u << 1 ? 1 \ +: (A) == 1u << 2 ? 2 \ +: (A) == 1u << 3 ? 3 \ +: (A) == 1u << 4 ? 4 \ +: (A) == 1u << 5 ? 5 \ +: (A) == 1u << 6 ? 6 \ +: (A) == 1u << 7 ? 7 \ +: 0) + +#define NUM_INTS_PER_PORT 8 +static volatile voidFuncPtr intFuncP1[NUM_INTS_PER_PORT]; +#if defined(__MSP430_HAS_PORT2_R__) +static volatile voidFuncPtr intFuncP2[NUM_INTS_PER_PORT]; +#endif + +void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) { + uint8_t bit = digitalPinToBitMask(interruptNum); + uint8_t port = digitalPinToPort(interruptNum); + + + if ((port == NOT_A_PIN) || !((mode == FALLING) || (mode == RISING))) return; + + __dint(); + + switch(port) { + case P1: + P1IE |= bit; + P1IFG &= ~bit; + P1IES = mode ? P1IES | bit : P1IES & ~bit; + intFuncP1[bit_pos(bit)] = userFunc; + break; + #if defined(__MSP430_HAS_PORT2_R__) + case P2: + P2IE |= bit; + P2IFG &= ~bit; + P2IES = mode ? P2IES | bit : P2IES & ~bit; + intFuncP2[bit_pos(bit)] = userFunc; + break; + #endif + default: + break; + } + + __eint(); +} + +void detachInterrupt(uint8_t interruptNum) { + uint8_t bit = digitalPinToBitMask(interruptNum); + uint8_t port = digitalPinToPort(interruptNum); + + if (port == NOT_A_PIN) return; + + switch(port) { + case P1: + P1IE &= ~bit; + intFuncP1[bit_pos(bit)] = 0; + break; + #if defined(__MSP430_HAS_PORT2_R__) + case P2: + P2IE &= ~bit; + intFuncP2[bit_pos(bit)] = 0; + break; + #endif + default: + break; + } +} + + +__attribute__((interrupt(PORT1_VECTOR))) +void Port_1(void) +{ + uint8_t i; + for(i = 0; i < 8; i++) { + if((P1IFG & BV(i)) && intFuncP1[i]) { + intFuncP1[i](); + P1IFG &= ~BV(i); + } + } +} + +#if defined(__MSP430_HAS_PORT2_R__) +__attribute__((interrupt(PORT2_VECTOR))) +void Port_2(void) +{ + uint8_t i; + for(i = 0; i < 8; i++) { + if((P2IFG & BV(i)) && intFuncP2[i]) { + intFuncP2[i](); + P2IFG &= ~BV(i); + } + } +} +#endif diff --git a/lib/msp430/WMath.cpp b/lib/msp430/WMath.cpp new file mode 100644 index 0000000..d754215 --- /dev/null +++ b/lib/msp430/WMath.cpp @@ -0,0 +1,65 @@ +/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */ + +/* + Part of the Wiring project - http://wiring.org.co + Copyright (c) 2004-06 Hernando Barragan + Modified 13 August 2006, David A. Mellis for Arduino - http://www.arduino.cc/ + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id$ +*/ + +extern "C" { + #include "stdlib.h" + /* Using interal random and srandom in file random.c + * until msp430-libc adds supports for random and srandom */ + extern long random(void); + extern void srandom(unsigned long __seed); +} + +void randomSeed(unsigned int seed) +{ + if (seed != 0) { + srandom(seed); + } +} + +long random(long howbig) +{ + if (howbig == 0) { + return 0; + } + return random() % howbig; +} + +long random(long howsmall, long howbig) +{ + if (howsmall >= howbig) { + return howsmall; + } + long diff = howbig - howsmall; + return random(diff) + howsmall; +} + + +long map(long x, long in_min, long in_max, long out_min, long out_max) +{ + return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; +} + +unsigned int makeWord(unsigned int w) { return w; } +unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; } diff --git a/lib/msp430/WString.cpp b/lib/msp430/WString.cpp new file mode 100644 index 0000000..2da6894 --- /dev/null +++ b/lib/msp430/WString.cpp @@ -0,0 +1,649 @@ +/* + WString.cpp - String library for Wiring & Arduino + ...mostly rewritten by Paul Stoffregen... + Copyright (c) 2009-10 Hernando Barragan. All rights reserved. + Copyright 2011, Paul Stoffregen, paul@pjrc.com + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include "WString.h" + + +/*********************************************/ +/* Constructors */ +/*********************************************/ + +String::String(const char *cstr) +{ + init(); + if (cstr) copy(cstr, strlen(cstr)); +} + +String::String(const String &value) +{ + init(); + *this = value; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +String::String(String &&rval) +{ + init(); + move(rval); +} +String::String(StringSumHelper &&rval) +{ + init(); + move(rval); +} +#endif + +String::String(char c) +{ + init(); + char buf[2]; + buf[0] = c; + buf[1] = 0; + *this = buf; +} + +String::String(unsigned char value, unsigned char base) +{ + init(); + char buf[9]; + utoa(value, buf, base); + *this = buf; +} + +String::String(int value, unsigned char base) +{ + init(); + char buf[18]; + itoa(value, buf, base); + *this = buf; +} + +String::String(unsigned int value, unsigned char base) +{ + init(); + char buf[17]; + utoa(value, buf, base); + *this = buf; +} + +String::String(long value, unsigned char base) +{ + init(); + char buf[34]; + ltoa(value, buf, base); + *this = buf; +} + +String::String(unsigned long value, unsigned char base) +{ + init(); + char buf[33]; + ultoa(value, buf, base); + *this = buf; +} + +String::~String() +{ + free(buffer); +} + +/*********************************************/ +/* Memory Management */ +/*********************************************/ + +inline void String::init(void) +{ + buffer = NULL; + capacity = 0; + len = 0; + flags = 0; +} + +void String::invalidate(void) +{ + if (buffer) free(buffer); + buffer = NULL; + capacity = len = 0; +} + +unsigned char String::reserve(unsigned int size) +{ + if (buffer && capacity >= size) return 1; + if (changeBuffer(size)) { + if (len == 0) buffer[0] = 0; + return 1; + } + return 0; +} + +unsigned char String::changeBuffer(unsigned int maxStrLen) +{ + //char *newbuffer = (char *)realloc(buffer, maxStrLen + 1); + char *newbuffer = (char *)malloc(maxStrLen + 1); + + if (newbuffer) { + strncpy(newbuffer, buffer, len); + free(buffer); + buffer = newbuffer; + capacity = maxStrLen; + return 1; + } + return 0; +} + +/*********************************************/ +/* Copy and Move */ +/*********************************************/ + +String & String::copy(const char *cstr, unsigned int length) +{ + if (!reserve(length)) { + invalidate(); + return *this; + } + len = length; + strcpy(buffer, cstr); + return *this; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +void String::move(String &rhs) +{ + if (buffer) { + if (capacity >= rhs.len) { + strcpy(buffer, rhs.buffer); + len = rhs.len; + rhs.len = 0; + return; + } else { + free(buffer); + } + } + buffer = rhs.buffer; + capacity = rhs.capacity; + len = rhs.len; + rhs.buffer = NULL; + rhs.capacity = 0; + rhs.len = 0; +} +#endif + +String & String::operator = (const String &rhs) +{ + if (this == &rhs) return *this; + + if (rhs.buffer) copy(rhs.buffer, rhs.len); + else invalidate(); + + return *this; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +String & String::operator = (String &&rval) +{ + if (this != &rval) move(rval); + return *this; +} + +String & String::operator = (StringSumHelper &&rval) +{ + if (this != &rval) move(rval); + return *this; +} +#endif + +String & String::operator = (const char *cstr) +{ + if (cstr) copy(cstr, strlen(cstr)); + else invalidate(); + + return *this; +} + +/*********************************************/ +/* concat */ +/*********************************************/ + +unsigned char String::concat(const String &s) +{ + return concat(s.buffer, s.len); +} + +unsigned char String::concat(const char *cstr, unsigned int length) +{ + unsigned int newlen = len + length; + if (!cstr) return 0; + if (length == 0) return 1; + if (!reserve(newlen)) return 0; + strcpy(buffer + len, cstr); + len = newlen; + return 1; +} + +unsigned char String::concat(const char *cstr) +{ + if (!cstr) return 0; + return concat(cstr, strlen(cstr)); +} + +unsigned char String::concat(char c) +{ + char buf[2]; + buf[0] = c; + buf[1] = 0; + return concat(buf, 1); +} + +unsigned char String::concat(unsigned char num) +{ + char buf[4]; + itoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(int num) +{ + char buf[7]; + itoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(unsigned int num) +{ + char buf[6]; + utoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(long num) +{ + char buf[12]; + ltoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(unsigned long num) +{ + char buf[11]; + ultoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +/*********************************************/ +/* Concatenate */ +/*********************************************/ + +StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(rhs.buffer, rhs.len)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr) +{ + StringSumHelper &a = const_cast(lhs); + if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, char c) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(c)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +/*********************************************/ +/* Comparison */ +/*********************************************/ + +int String::compareTo(const String &s) const +{ + if (!buffer || !s.buffer) { + if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer; + if (buffer && len > 0) return *(unsigned char *)buffer; + return 0; + } + return strcmp(buffer, s.buffer); +} + +unsigned char String::equals(const String &s2) const +{ + return (len == s2.len && compareTo(s2) == 0); +} + +unsigned char String::equals(const char *cstr) const +{ + if (len == 0) return (cstr == NULL || *cstr == 0); + if (cstr == NULL) return buffer[0] == 0; + return strcmp(buffer, cstr) == 0; +} + +unsigned char String::operator<(const String &rhs) const +{ + return compareTo(rhs) < 0; +} + +unsigned char String::operator>(const String &rhs) const +{ + return compareTo(rhs) > 0; +} + +unsigned char String::operator<=(const String &rhs) const +{ + return compareTo(rhs) <= 0; +} + +unsigned char String::operator>=(const String &rhs) const +{ + return compareTo(rhs) >= 0; +} + +unsigned char String::equalsIgnoreCase( const String &s2 ) const +{ + if (this == &s2) return 1; + if (len != s2.len) return 0; + if (len == 0) return 1; + const char *p1 = buffer; + const char *p2 = s2.buffer; + while (*p1) { + if (tolower(*p1++) != tolower(*p2++)) return 0; + } + return 1; +} + +unsigned char String::startsWith( const String &s2 ) const +{ + if (len < s2.len) return 0; + return startsWith(s2, 0); +} + +unsigned char String::startsWith( const String &s2, unsigned int offset ) const +{ + if (offset > len - s2.len || !buffer || !s2.buffer) return 0; + return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0; +} + +unsigned char String::endsWith( const String &s2 ) const +{ + if ( len < s2.len || !buffer || !s2.buffer) return 0; + return strcmp(&buffer[len - s2.len], s2.buffer) == 0; +} + +/*********************************************/ +/* Character Access */ +/*********************************************/ + +char String::charAt(unsigned int loc) const +{ + return operator[](loc); +} + +void String::setCharAt(unsigned int loc, char c) +{ + if (loc < len) buffer[loc] = c; +} + +char & String::operator[](unsigned int index) +{ + static char dummy_writable_char; + if (index >= len || !buffer) { + dummy_writable_char = 0; + return dummy_writable_char; + } + return buffer[index]; +} + +char String::operator[]( unsigned int index ) const +{ + if (index >= len || !buffer) return 0; + return buffer[index]; +} + +void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const +{ + if (!bufsize || !buf) return; + if (index >= len) { + buf[0] = 0; + return; + } + unsigned int n = bufsize - 1; + if (n > len - index) n = len - index; + strncpy((char *)buf, buffer + index, n); + buf[n] = 0; +} + +/*********************************************/ +/* Search */ +/*********************************************/ + +int String::indexOf(char c) const +{ + return indexOf(c, 0); +} + +int String::indexOf( char ch, unsigned int fromIndex ) const +{ + if (fromIndex >= len) return -1; + const char* temp = strchr(buffer + fromIndex, ch); + if (temp == NULL) return -1; + return temp - buffer; +} + +int String::indexOf(const String &s2) const +{ + return indexOf(s2, 0); +} + +int String::indexOf(const String &s2, unsigned int fromIndex) const +{ + if (fromIndex >= len) return -1; + const char *found = strstr(buffer + fromIndex, s2.buffer); + if (found == NULL) return -1; + return found - buffer; +} + +int String::lastIndexOf( char theChar ) const +{ + return lastIndexOf(theChar, len - 1); +} + +int String::lastIndexOf(char ch, unsigned int fromIndex) const +{ + if (fromIndex >= len) return -1; + char tempchar = buffer[fromIndex + 1]; + buffer[fromIndex + 1] = '\0'; + char* temp = strrchr( buffer, ch ); + buffer[fromIndex + 1] = tempchar; + if (temp == NULL) return -1; + return temp - buffer; +} + +int String::lastIndexOf(const String &s2) const +{ + return lastIndexOf(s2, len - s2.len); +} + +int String::lastIndexOf(const String &s2, unsigned int fromIndex) const +{ + if (s2.len == 0 || len == 0 || s2.len > len) return -1; + if (fromIndex >= len) fromIndex = len - 1; + int found = -1; + for (char *p = buffer; p <= buffer + fromIndex; p++) { + p = strstr(p, s2.buffer); + if (!p) break; + if ((unsigned int)(p - buffer) <= fromIndex) found = p - buffer; + } + return found; +} + +String String::substring( unsigned int left ) const +{ + return substring(left, len); +} + +String String::substring(unsigned int left, unsigned int right) const +{ + if (left > right) { + unsigned int temp = right; + right = left; + left = temp; + } + String out; + if (left > len) return out; + if (right > len) right = len; + char temp = buffer[right]; // save the replaced character + buffer[right] = '\0'; + out = buffer + left; // pointer arithmetic + buffer[right] = temp; //restore character + return out; +} + +/*********************************************/ +/* Modification */ +/*********************************************/ + +void String::replace(char find, char replace) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + if (*p == find) *p = replace; + } +} + +void String::replace(const String& find, const String& replace) +{ + if (len == 0 || find.len == 0) return; + int diff = replace.len - find.len; + char *readFrom = buffer; + char *foundAt; + if (diff == 0) { + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + memcpy(foundAt, replace.buffer, replace.len); + readFrom = foundAt + replace.len; + } + } else if (diff < 0) { + char *writeTo = buffer; + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + unsigned int n = foundAt - readFrom; + memcpy(writeTo, readFrom, n); + writeTo += n; + memcpy(writeTo, replace.buffer, replace.len); + writeTo += replace.len; + readFrom = foundAt + find.len; + len += diff; + } + strcpy(writeTo, readFrom); + } else { + unsigned int size = len; // compute size needed for result + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + readFrom = foundAt + find.len; + size += diff; + } + if (size == len) return; + if (size > capacity && !changeBuffer(size)) return; // XXX: tell user! + int index = len - 1; + while (index >= 0 && (index = lastIndexOf(find, index)) >= 0) { + readFrom = buffer + index + find.len; + memmove(readFrom + diff, readFrom, len - (readFrom - buffer)); + len += diff; + buffer[len] = 0; + memcpy(buffer + index, replace.buffer, replace.len); + index--; + } + } +} + +void String::toLowerCase(void) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + *p = tolower(*p); + } +} + +void String::toUpperCase(void) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + *p = toupper(*p); + } +} + +void String::trim(void) +{ + if (!buffer || len == 0) return; + char *begin = buffer; + while (isspace(*begin)) begin++; + char *end = buffer + len - 1; + while (isspace(*end) && end >= begin) end--; + len = end + 1 - begin; + if (begin > buffer) memcpy(buffer, begin, len); + buffer[len] = 0; +} + +/*********************************************/ +/* Parsing / Conversion */ +/*********************************************/ + +long String::toInt(void) const +{ + if (buffer) return atol(buffer); + return 0; +} + + diff --git a/lib/msp430/WString.h b/lib/msp430/WString.h new file mode 100644 index 0000000..73d1213 --- /dev/null +++ b/lib/msp430/WString.h @@ -0,0 +1,204 @@ +/* + WString.h - String library for Wiring & Arduino + ...mostly rewritten by Paul Stoffregen... + Copyright (c) 2009-10 Hernando Barragan. All right reserved. + Copyright 2011, Paul Stoffregen, paul@pjrc.com + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef String_class_h +#define String_class_h +#ifdef __cplusplus + +#include +#include +#include + +// When compiling programs with this class, the following gcc parameters +// dramatically increase performance and memory (RAM) efficiency, typically +// with little or no increase in code size. +// -felide-constructors +// -std=c++0x + +//class __FlashStringHelper; +//#define F(string_literal) (reinterpret_cast<__FlashStringHelper *>(PSTR(string_literal))) + +// An inherited class for holding the result of a concatenation. These +// result objects are assumed to be writable by subsequent concatenations. +class StringSumHelper; + +// The string class +class String +{ + // use a function pointer to allow for "if (s)" without the + // complications of an operator bool(). for more information, see: + // http://www.artima.com/cppsource/safebool.html + typedef void (String::*StringIfHelperType)() const; + void StringIfHelper() const {} + +public: + // constructors + // creates a copy of the initial value. + // if the initial value is null or invalid, or if memory allocation + // fails, the string will be marked as invalid (i.e. "if (s)" will + // be false). + String(const char *cstr = ""); + String(const String &str); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + String(String &&rval); + String(StringSumHelper &&rval); + #endif + explicit String(char c); + explicit String(unsigned char, unsigned char base=10); + explicit String(int, unsigned char base=10); + explicit String(unsigned int, unsigned char base=10); + explicit String(long, unsigned char base=10); + explicit String(unsigned long, unsigned char base=10); + ~String(void); + + // memory management + // return true on success, false on failure (in which case, the string + // is left unchanged). reserve(0), if successful, will validate an + // invalid string (i.e., "if (s)" will be true afterwards) + unsigned char reserve(unsigned int size); + inline unsigned int length(void) const {return len;} + + // creates a copy of the assigned value. if the value is null or + // invalid, or if the memory allocation fails, the string will be + // marked as invalid ("if (s)" will be false). + String & operator = (const String &rhs); + String & operator = (const char *cstr); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + String & operator = (String &&rval); + String & operator = (StringSumHelper &&rval); + #endif + + // concatenate (works w/ built-in types) + + // returns true on success, false on failure (in which case, the string + // is left unchanged). if the argument is null or invalid, the + // concatenation is considered unsucessful. + unsigned char concat(const String &str); + unsigned char concat(const char *cstr); + unsigned char concat(char c); + unsigned char concat(unsigned char c); + unsigned char concat(int num); + unsigned char concat(unsigned int num); + unsigned char concat(long num); + unsigned char concat(unsigned long num); + + // if there's not enough memory for the concatenated value, the string + // will be left unchanged (but this isn't signalled in any way) + String & operator += (const String &rhs) {concat(rhs); return (*this);} + String & operator += (const char *cstr) {concat(cstr); return (*this);} + String & operator += (char c) {concat(c); return (*this);} + String & operator += (unsigned char num) {concat(num); return (*this);} + String & operator += (int num) {concat(num); return (*this);} + String & operator += (unsigned int num) {concat(num); return (*this);} + String & operator += (long num) {concat(num); return (*this);} + String & operator += (unsigned long num) {concat(num); return (*this);} + + friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs); + friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr); + friend StringSumHelper & operator + (const StringSumHelper &lhs, char c); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, int num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, long num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num); + + // comparison (only works w/ Strings and "strings") + operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; } + int compareTo(const String &s) const; + unsigned char equals(const String &s) const; + unsigned char equals(const char *cstr) const; + unsigned char operator == (const String &rhs) const {return equals(rhs);} + unsigned char operator == (const char *cstr) const {return equals(cstr);} + unsigned char operator != (const String &rhs) const {return !equals(rhs);} + unsigned char operator != (const char *cstr) const {return !equals(cstr);} + unsigned char operator < (const String &rhs) const; + unsigned char operator > (const String &rhs) const; + unsigned char operator <= (const String &rhs) const; + unsigned char operator >= (const String &rhs) const; + unsigned char equalsIgnoreCase(const String &s) const; + unsigned char startsWith( const String &prefix) const; + unsigned char startsWith(const String &prefix, unsigned int offset) const; + unsigned char endsWith(const String &suffix) const; + + // character acccess + char charAt(unsigned int index) const; + void setCharAt(unsigned int index, char c); + char operator [] (unsigned int index) const; + char& operator [] (unsigned int index); + void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const; + void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const + {getBytes((unsigned char *)buf, bufsize, index);} + + // search + int indexOf( char ch ) const; + int indexOf( char ch, unsigned int fromIndex ) const; + int indexOf( const String &str ) const; + int indexOf( const String &str, unsigned int fromIndex ) const; + int lastIndexOf( char ch ) const; + int lastIndexOf( char ch, unsigned int fromIndex ) const; + int lastIndexOf( const String &str ) const; + int lastIndexOf( const String &str, unsigned int fromIndex ) const; + String substring( unsigned int beginIndex ) const; + String substring( unsigned int beginIndex, unsigned int endIndex ) const; + + // modification + void replace(char find, char replace); + void replace(const String& find, const String& replace); + void toLowerCase(void); + void toUpperCase(void); + void trim(void); + + // parsing/conversion + long toInt(void) const; + +protected: + char *buffer; // the actual char array + unsigned int capacity; // the array length minus one (for the '\0') + unsigned int len; // the String length (not counting the '\0') + unsigned char flags; // unused, for future features +protected: + void init(void); + void invalidate(void); + unsigned char changeBuffer(unsigned int maxStrLen); + unsigned char concat(const char *cstr, unsigned int length); + + // copy and move + String & copy(const char *cstr, unsigned int length); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void move(String &rhs); + #endif +}; + +class StringSumHelper : public String +{ +public: + StringSumHelper(const String &s) : String(s) {} + StringSumHelper(const char *p) : String(p) {} + StringSumHelper(char c) : String(c) {} + StringSumHelper(unsigned char num) : String(num) {} + StringSumHelper(int num) : String(num) {} + StringSumHelper(unsigned int num) : String(num) {} + StringSumHelper(long num) : String(num) {} + StringSumHelper(unsigned long num) : String(num) {} +}; + +#endif // __cplusplus +#endif // String_class_h diff --git a/lib/msp430/Wire.cpp b/lib/msp430/Wire.cpp new file mode 100644 index 0000000..d7d74a6 --- /dev/null +++ b/lib/msp430/Wire.cpp @@ -0,0 +1,307 @@ +/* + ************************************************************************ + * Wire.cpp + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + TwoWire.cpp - TWI/I2C library for Wiring & Arduino + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts +*/ + +extern "C" { + #include + #include + #include + #include "twi.h" +} + +#include "Wire.h" + +// Initialize Class Variables ////////////////////////////////////////////////// + +uint8_t TwoWire::rxBuffer[BUFFER_LENGTH]; +uint8_t TwoWire::rxBufferIndex = 0; +uint8_t TwoWire::rxBufferLength = 0; + +uint8_t TwoWire::txAddress = 0; +uint8_t TwoWire::txBuffer[BUFFER_LENGTH]; +uint8_t TwoWire::txBufferIndex = 0; +uint8_t TwoWire::txBufferLength = 0; + +uint8_t TwoWire::transmitting = 0; +void (*TwoWire::user_onRequest)(void); +void (*TwoWire::user_onReceive)(int); + +// Constructors //////////////////////////////////////////////////////////////// + +TwoWire::TwoWire() +{ +} + +// Public Methods ////////////////////////////////////////////////////////////// + +void TwoWire::begin(void) +{ + rxBufferIndex = 0; + rxBufferLength = 0; + + txBufferIndex = 0; + txBufferLength = 0; + + twi_init(); +} + +void TwoWire::begin(uint8_t address) +{ + twi_setAddress(address); + twi_attachSlaveTxEvent(onRequestService); + twi_attachSlaveRxEvent(onReceiveService); + begin(); +} + +void TwoWire::begin(int address) +{ + begin((uint8_t)address); +} + +uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop) +{ + // clamp to buffer length + if(quantity > BUFFER_LENGTH){ + quantity = BUFFER_LENGTH; + } + // perform blocking read into buffer + uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop); + // set rx buffer iterator vars + rxBufferIndex = 0; + rxBufferLength = read; + + return read; +} + +uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity) +{ + return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true); +} + +uint8_t TwoWire::requestFrom(int address, int quantity) +{ + return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true); +} + +uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop) +{ + return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)sendStop); +} + +void TwoWire::beginTransmission(uint8_t address) +{ + // indicate that we are transmitting + transmitting = 1; + // set address of targeted slave + txAddress = address; + // reset tx buffer iterator vars + txBufferIndex = 0; + txBufferLength = 0; +} + +void TwoWire::beginTransmission(int address) +{ + beginTransmission((uint8_t)address); +} + +// +// Originally, 'endTransmission' was an f(void) function. +// It has been modified to take one parameter indicating +// whether or not a STOP should be performed on the bus. +// Calling endTransmission(false) allows a sketch to +// perform a repeated start. +// +// WARNING: Nothing in the library keeps track of whether +// the bus tenure has been properly ended with a STOP. It +// is very possible to leave the bus in a hung state if +// no call to endTransmission(true) is made. Some I2C +// devices will behave oddly if they do not see a STOP. +// +uint8_t TwoWire::endTransmission(uint8_t sendStop) +{ + // transmit buffer (blocking) + int8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, 1, sendStop); + // reset tx buffer iterator vars + txBufferIndex = 0; + txBufferLength = 0; + // indicate that we are done transmitting + transmitting = 0; + return ret; +} + +// This provides backwards compatibility with the original +// definition, and expected behaviour, of endTransmission +// +uint8_t TwoWire::endTransmission(void) +{ + return endTransmission(true); +} + +// must be called in: +// slave tx event callback +// or after beginTransmission(address) +size_t TwoWire::write(uint8_t data) +{ + if(transmitting){ + // in master transmitter mode + // don't bother if buffer is full + if(txBufferLength >= BUFFER_LENGTH){ + setWriteError(); + return 0; + } + // put byte in tx buffer + txBuffer[txBufferIndex] = data; + ++txBufferIndex; + // update amount in buffer + txBufferLength = txBufferIndex; + }else{ + // in slave send mode + // reply to master + twi_transmit(&data, 1); + } + return 1; +} + +// must be called in: +// slave tx event callback +// or after beginTransmission(address) +size_t TwoWire::write(const uint8_t *data, size_t quantity) +{ + if(transmitting){ + // in master transmitter mode + for(size_t i = 0; i < quantity; ++i){ + write(data[i]); + } + }else{ + // in slave send mode + // reply to master + twi_transmit(data, quantity); + } + return quantity; +} + +// must be called in: +// slave rx event callback +// or after requestFrom(address, numBytes) +int TwoWire::available(void) +{ + return rxBufferLength - rxBufferIndex; +} + +// must be called in: +// slave rx event callback +// or after requestFrom(address, numBytes) +int TwoWire::read(void) +{ + int value = -1; + + // get each successive byte on each call + if(rxBufferIndex < rxBufferLength){ + value = rxBuffer[rxBufferIndex]; + ++rxBufferIndex; + } + + return value; +} + +// must be called in: +// slave rx event callback +// or after requestFrom(address, numBytes) +int TwoWire::peek(void) +{ + int value = -1; + + if(rxBufferIndex < rxBufferLength){ + value = rxBuffer[rxBufferIndex]; + } + + return value; +} + +void TwoWire::flush(void) +{ + // XXX: to be implemented. +} + +// behind the scenes function that is called when data is received +void TwoWire::onReceiveService(uint8_t* inBytes, int numBytes) +{ + // don't bother if user hasn't registered a callback + if(!user_onReceive){ + return; + } + // don't bother if rx buffer is in use by a master requestFrom() op + // i know this drops data, but it allows for slight stupidity + // meaning, they may not have read all the master requestFrom() data yet + if(rxBufferIndex < rxBufferLength){ + return; + } + // copy twi rx buffer into local read buffer + // this enables new reads to happen in parallel + for(uint8_t i = 0; i < numBytes; ++i){ + rxBuffer[i] = inBytes[i]; + } + // set rx iterator vars + rxBufferIndex = 0; + rxBufferLength = numBytes; + // alert user program + user_onReceive(numBytes); +} + +// behind the scenes function that is called when data is requested +void TwoWire::onRequestService(void) +{ + // don't bother if user hasn't registered a callback + if(!user_onRequest){ + return; + } + // reset tx buffer iterator vars + // !!! this will kill any pending pre-master sendTo() activity + txBufferIndex = 0; + txBufferLength = 0; + // alert user program + user_onRequest(); +} + +// sets function called on slave write +void TwoWire::onReceive( void (*function)(int) ) +{ + user_onReceive = function; +} + +// sets function called on slave read +void TwoWire::onRequest( void (*function)(void) ) +{ + user_onRequest = function; +} + +// Preinstantiate Objects ////////////////////////////////////////////////////// + +TwoWire Wire = TwoWire(); + diff --git a/lib/msp430/Wire.h b/lib/msp430/Wire.h new file mode 100644 index 0000000..3f633c4 --- /dev/null +++ b/lib/msp430/Wire.h @@ -0,0 +1,94 @@ +/* + ************************************************************************ + * Wire.h + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + TwoWire.h - TWI/I2C library for Arduino & Wiring + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts +*/ + +#ifndef TwoWire_h +#define TwoWire_h + +#include +#include "Stream.h" + +#define BUFFER_LENGTH 16 + +class TwoWire : public Stream +{ + private: + static uint8_t rxBuffer[]; + static uint8_t rxBufferIndex; + static uint8_t rxBufferLength; + + static uint8_t txAddress; + static uint8_t txBuffer[]; + static uint8_t txBufferIndex; + static uint8_t txBufferLength; + + static uint8_t transmitting; + static void (*user_onRequest)(void); + static void (*user_onReceive)(int); + static void onRequestService(void); + static void onReceiveService(uint8_t*, int); + public: + TwoWire(); + void begin(); + void begin(uint8_t); + void begin(int); + void beginTransmission(uint8_t); + void beginTransmission(int); + uint8_t endTransmission(void); + uint8_t endTransmission(uint8_t); + uint8_t requestFrom(uint8_t, uint8_t); + uint8_t requestFrom(uint8_t, uint8_t, uint8_t); + uint8_t requestFrom(int, int); + uint8_t requestFrom(int, int, int); + virtual size_t write(uint8_t); + virtual size_t write(const uint8_t *, size_t); + virtual int available(void); + virtual int read(void); + virtual int peek(void); + virtual void flush(void); +#define USCI_ERROR "\n*********\nI2C Slave is not implemented for this MSP430. \nConsider using using a MSP430 with USCI peripheral e.g. MSP430G2553.\n*********\n" +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) + void onReceive( void (*)(int) ); + void onRequest( void (*)(void) ); +#else + void onReceive( void (*)(int) ) __attribute__ ((error(USCI_ERROR))); + void onRequest( void (*)(void) ) __attribute__ ((error(USCI_ERROR))); +#endif + + 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; +}; + +extern TwoWire Wire; + +#endif + diff --git a/lib/msp430/binary.h b/lib/msp430/binary.h new file mode 100644 index 0000000..af14980 --- /dev/null +++ b/lib/msp430/binary.h @@ -0,0 +1,515 @@ +#ifndef Binary_h +#define Binary_h + +#define B0 0 +#define B00 0 +#define B000 0 +#define B0000 0 +#define B00000 0 +#define B000000 0 +#define B0000000 0 +#define B00000000 0 +#define B1 1 +#define B01 1 +#define B001 1 +#define B0001 1 +#define B00001 1 +#define B000001 1 +#define B0000001 1 +#define B00000001 1 +#define B10 2 +#define B010 2 +#define B0010 2 +#define B00010 2 +#define B000010 2 +#define B0000010 2 +#define B00000010 2 +#define B11 3 +#define B011 3 +#define B0011 3 +#define B00011 3 +#define B000011 3 +#define B0000011 3 +#define B00000011 3 +#define B100 4 +#define B0100 4 +#define B00100 4 +#define B000100 4 +#define B0000100 4 +#define B00000100 4 +#define B101 5 +#define B0101 5 +#define B00101 5 +#define B000101 5 +#define B0000101 5 +#define B00000101 5 +#define B110 6 +#define B0110 6 +#define B00110 6 +#define B000110 6 +#define B0000110 6 +#define B00000110 6 +#define B111 7 +#define B0111 7 +#define B00111 7 +#define B000111 7 +#define B0000111 7 +#define B00000111 7 +#define B1000 8 +#define B01000 8 +#define B001000 8 +#define B0001000 8 +#define B00001000 8 +#define B1001 9 +#define B01001 9 +#define B001001 9 +#define B0001001 9 +#define B00001001 9 +#define B1010 10 +#define B01010 10 +#define B001010 10 +#define B0001010 10 +#define B00001010 10 +#define B1011 11 +#define B01011 11 +#define B001011 11 +#define B0001011 11 +#define B00001011 11 +#define B1100 12 +#define B01100 12 +#define B001100 12 +#define B0001100 12 +#define B00001100 12 +#define B1101 13 +#define B01101 13 +#define B001101 13 +#define B0001101 13 +#define B00001101 13 +#define B1110 14 +#define B01110 14 +#define B001110 14 +#define B0001110 14 +#define B00001110 14 +#define B1111 15 +#define B01111 15 +#define B001111 15 +#define B0001111 15 +#define B00001111 15 +#define B10000 16 +#define B010000 16 +#define B0010000 16 +#define B00010000 16 +#define B10001 17 +#define B010001 17 +#define B0010001 17 +#define B00010001 17 +#define B10010 18 +#define B010010 18 +#define B0010010 18 +#define B00010010 18 +#define B10011 19 +#define B010011 19 +#define B0010011 19 +#define B00010011 19 +#define B10100 20 +#define B010100 20 +#define B0010100 20 +#define B00010100 20 +#define B10101 21 +#define B010101 21 +#define B0010101 21 +#define B00010101 21 +#define B10110 22 +#define B010110 22 +#define B0010110 22 +#define B00010110 22 +#define B10111 23 +#define B010111 23 +#define B0010111 23 +#define B00010111 23 +#define B11000 24 +#define B011000 24 +#define B0011000 24 +#define B00011000 24 +#define B11001 25 +#define B011001 25 +#define B0011001 25 +#define B00011001 25 +#define B11010 26 +#define B011010 26 +#define B0011010 26 +#define B00011010 26 +#define B11011 27 +#define B011011 27 +#define B0011011 27 +#define B00011011 27 +#define B11100 28 +#define B011100 28 +#define B0011100 28 +#define B00011100 28 +#define B11101 29 +#define B011101 29 +#define B0011101 29 +#define B00011101 29 +#define B11110 30 +#define B011110 30 +#define B0011110 30 +#define B00011110 30 +#define B11111 31 +#define B011111 31 +#define B0011111 31 +#define B00011111 31 +#define B100000 32 +#define B0100000 32 +#define B00100000 32 +#define B100001 33 +#define B0100001 33 +#define B00100001 33 +#define B100010 34 +#define B0100010 34 +#define B00100010 34 +#define B100011 35 +#define B0100011 35 +#define B00100011 35 +#define B100100 36 +#define B0100100 36 +#define B00100100 36 +#define B100101 37 +#define B0100101 37 +#define B00100101 37 +#define B100110 38 +#define B0100110 38 +#define B00100110 38 +#define B100111 39 +#define B0100111 39 +#define B00100111 39 +#define B101000 40 +#define B0101000 40 +#define B00101000 40 +#define B101001 41 +#define B0101001 41 +#define B00101001 41 +#define B101010 42 +#define B0101010 42 +#define B00101010 42 +#define B101011 43 +#define B0101011 43 +#define B00101011 43 +#define B101100 44 +#define B0101100 44 +#define B00101100 44 +#define B101101 45 +#define B0101101 45 +#define B00101101 45 +#define B101110 46 +#define B0101110 46 +#define B00101110 46 +#define B101111 47 +#define B0101111 47 +#define B00101111 47 +#define B110000 48 +#define B0110000 48 +#define B00110000 48 +#define B110001 49 +#define B0110001 49 +#define B00110001 49 +#define B110010 50 +#define B0110010 50 +#define B00110010 50 +#define B110011 51 +#define B0110011 51 +#define B00110011 51 +#define B110100 52 +#define B0110100 52 +#define B00110100 52 +#define B110101 53 +#define B0110101 53 +#define B00110101 53 +#define B110110 54 +#define B0110110 54 +#define B00110110 54 +#define B110111 55 +#define B0110111 55 +#define B00110111 55 +#define B111000 56 +#define B0111000 56 +#define B00111000 56 +#define B111001 57 +#define B0111001 57 +#define B00111001 57 +#define B111010 58 +#define B0111010 58 +#define B00111010 58 +#define B111011 59 +#define B0111011 59 +#define B00111011 59 +#define B111100 60 +#define B0111100 60 +#define B00111100 60 +#define B111101 61 +#define B0111101 61 +#define B00111101 61 +#define B111110 62 +#define B0111110 62 +#define B00111110 62 +#define B111111 63 +#define B0111111 63 +#define B00111111 63 +#define B1000000 64 +#define B01000000 64 +#define B1000001 65 +#define B01000001 65 +#define B1000010 66 +#define B01000010 66 +#define B1000011 67 +#define B01000011 67 +#define B1000100 68 +#define B01000100 68 +#define B1000101 69 +#define B01000101 69 +#define B1000110 70 +#define B01000110 70 +#define B1000111 71 +#define B01000111 71 +#define B1001000 72 +#define B01001000 72 +#define B1001001 73 +#define B01001001 73 +#define B1001010 74 +#define B01001010 74 +#define B1001011 75 +#define B01001011 75 +#define B1001100 76 +#define B01001100 76 +#define B1001101 77 +#define B01001101 77 +#define B1001110 78 +#define B01001110 78 +#define B1001111 79 +#define B01001111 79 +#define B1010000 80 +#define B01010000 80 +#define B1010001 81 +#define B01010001 81 +#define B1010010 82 +#define B01010010 82 +#define B1010011 83 +#define B01010011 83 +#define B1010100 84 +#define B01010100 84 +#define B1010101 85 +#define B01010101 85 +#define B1010110 86 +#define B01010110 86 +#define B1010111 87 +#define B01010111 87 +#define B1011000 88 +#define B01011000 88 +#define B1011001 89 +#define B01011001 89 +#define B1011010 90 +#define B01011010 90 +#define B1011011 91 +#define B01011011 91 +#define B1011100 92 +#define B01011100 92 +#define B1011101 93 +#define B01011101 93 +#define B1011110 94 +#define B01011110 94 +#define B1011111 95 +#define B01011111 95 +#define B1100000 96 +#define B01100000 96 +#define B1100001 97 +#define B01100001 97 +#define B1100010 98 +#define B01100010 98 +#define B1100011 99 +#define B01100011 99 +#define B1100100 100 +#define B01100100 100 +#define B1100101 101 +#define B01100101 101 +#define B1100110 102 +#define B01100110 102 +#define B1100111 103 +#define B01100111 103 +#define B1101000 104 +#define B01101000 104 +#define B1101001 105 +#define B01101001 105 +#define B1101010 106 +#define B01101010 106 +#define B1101011 107 +#define B01101011 107 +#define B1101100 108 +#define B01101100 108 +#define B1101101 109 +#define B01101101 109 +#define B1101110 110 +#define B01101110 110 +#define B1101111 111 +#define B01101111 111 +#define B1110000 112 +#define B01110000 112 +#define B1110001 113 +#define B01110001 113 +#define B1110010 114 +#define B01110010 114 +#define B1110011 115 +#define B01110011 115 +#define B1110100 116 +#define B01110100 116 +#define B1110101 117 +#define B01110101 117 +#define B1110110 118 +#define B01110110 118 +#define B1110111 119 +#define B01110111 119 +#define B1111000 120 +#define B01111000 120 +#define B1111001 121 +#define B01111001 121 +#define B1111010 122 +#define B01111010 122 +#define B1111011 123 +#define B01111011 123 +#define B1111100 124 +#define B01111100 124 +#define B1111101 125 +#define B01111101 125 +#define B1111110 126 +#define B01111110 126 +#define B1111111 127 +#define B01111111 127 +#define B10000000 128 +#define B10000001 129 +#define B10000010 130 +#define B10000011 131 +#define B10000100 132 +#define B10000101 133 +#define B10000110 134 +#define B10000111 135 +#define B10001000 136 +#define B10001001 137 +#define B10001010 138 +#define B10001011 139 +#define B10001100 140 +#define B10001101 141 +#define B10001110 142 +#define B10001111 143 +#define B10010000 144 +#define B10010001 145 +#define B10010010 146 +#define B10010011 147 +#define B10010100 148 +#define B10010101 149 +#define B10010110 150 +#define B10010111 151 +#define B10011000 152 +#define B10011001 153 +#define B10011010 154 +#define B10011011 155 +#define B10011100 156 +#define B10011101 157 +#define B10011110 158 +#define B10011111 159 +#define B10100000 160 +#define B10100001 161 +#define B10100010 162 +#define B10100011 163 +#define B10100100 164 +#define B10100101 165 +#define B10100110 166 +#define B10100111 167 +#define B10101000 168 +#define B10101001 169 +#define B10101010 170 +#define B10101011 171 +#define B10101100 172 +#define B10101101 173 +#define B10101110 174 +#define B10101111 175 +#define B10110000 176 +#define B10110001 177 +#define B10110010 178 +#define B10110011 179 +#define B10110100 180 +#define B10110101 181 +#define B10110110 182 +#define B10110111 183 +#define B10111000 184 +#define B10111001 185 +#define B10111010 186 +#define B10111011 187 +#define B10111100 188 +#define B10111101 189 +#define B10111110 190 +#define B10111111 191 +#define B11000000 192 +#define B11000001 193 +#define B11000010 194 +#define B11000011 195 +#define B11000100 196 +#define B11000101 197 +#define B11000110 198 +#define B11000111 199 +#define B11001000 200 +#define B11001001 201 +#define B11001010 202 +#define B11001011 203 +#define B11001100 204 +#define B11001101 205 +#define B11001110 206 +#define B11001111 207 +#define B11010000 208 +#define B11010001 209 +#define B11010010 210 +#define B11010011 211 +#define B11010100 212 +#define B11010101 213 +#define B11010110 214 +#define B11010111 215 +#define B11011000 216 +#define B11011001 217 +#define B11011010 218 +#define B11011011 219 +#define B11011100 220 +#define B11011101 221 +#define B11011110 222 +#define B11011111 223 +#define B11100000 224 +#define B11100001 225 +#define B11100010 226 +#define B11100011 227 +#define B11100100 228 +#define B11100101 229 +#define B11100110 230 +#define B11100111 231 +#define B11101000 232 +#define B11101001 233 +#define B11101010 234 +#define B11101011 235 +#define B11101100 236 +#define B11101101 237 +#define B11101110 238 +#define B11101111 239 +#define B11110000 240 +#define B11110001 241 +#define B11110010 242 +#define B11110011 243 +#define B11110100 244 +#define B11110101 245 +#define B11110110 246 +#define B11110111 247 +#define B11111000 248 +#define B11111001 249 +#define B11111010 250 +#define B11111011 251 +#define B11111100 252 +#define B11111101 253 +#define B11111110 254 +#define B11111111 255 + +#endif diff --git a/lib/msp430/main.cpp b/lib/msp430/main.cpp new file mode 100644 index 0000000..138cc10 --- /dev/null +++ b/lib/msp430/main.cpp @@ -0,0 +1,16 @@ +#include + +int main(void) +{ + init(); + + setup(); + + for (;;) { + loop(); + if (serialEventRun) serialEventRun(); + } + + return 0; +} + diff --git a/lib/msp430/new.cpp b/lib/msp430/new.cpp new file mode 100644 index 0000000..0f6d422 --- /dev/null +++ b/lib/msp430/new.cpp @@ -0,0 +1,18 @@ +#include + +void * operator new(size_t size) +{ + return malloc(size); +} + +void operator delete(void * ptr) +{ + free(ptr); +} + +int __cxa_guard_acquire(__guard *g) {return !*(char *)(g);}; +void __cxa_guard_release (__guard *g) {*(char *)g = 1;}; +void __cxa_guard_abort (__guard *) {}; + +void __cxa_pure_virtual(void) {}; + diff --git a/lib/msp430/new.h b/lib/msp430/new.h new file mode 100644 index 0000000..cd940ce --- /dev/null +++ b/lib/msp430/new.h @@ -0,0 +1,22 @@ +/* Header to define new/delete operators as they aren't provided by avr-gcc by default + Taken from http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59453 + */ + +#ifndef NEW_H +#define NEW_H + +#include + +void * operator new(size_t size); +void operator delete(void * ptr); + +__extension__ typedef int __guard __attribute__((mode (__DI__))); + +extern "C" int __cxa_guard_acquire(__guard *); +extern "C" void __cxa_guard_release (__guard *); +extern "C" void __cxa_guard_abort (__guard *); + +extern "C" void __cxa_pure_virtual(void); + +#endif + diff --git a/lib/msp430/random.c b/lib/msp430/random.c new file mode 100644 index 0000000..6b46d5e --- /dev/null +++ b/lib/msp430/random.c @@ -0,0 +1,90 @@ +/*- + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Posix rand_r function added May 1999 by Wes Peters . + * + * $Id$ + */ + +/* + * From: +static char sccsid[] = "@(#)rand.c 8.1 (Berkeley) 6/14/93"; +*/ +#ifndef RANDOM_MAX +#define RANDOM_MAX 0x7FFFFFFF +#endif + +#include + +static long +do_random(unsigned long *ctx) +{ + /* + * Compute x = (7^5 * x) mod (2^31 - 1) + * wihout overflowing 31 bits: + * (2^31 - 1) = 127773 * (7^5) + 2836 + * From "Random number generators: good ones are hard to find", + * Park and Miller, Communications of the ACM, vol. 31, no. 10, + * October 1988, p. 1195. + */ + long hi, lo, x; + + x = *ctx; + /* Can't be initialized with 0, so use another value. */ + if (x == 0) + x = 123459876L; + hi = x / 127773L; + lo = x % 127773L; + x = 16807L * lo - 2836L * hi; + if (x < 0) + x += 0x7fffffffL; + return ((*ctx = x) % ((unsigned long)RANDOM_MAX + 1)); +} + + +long +random_r(unsigned long *ctx) +{ + return do_random(ctx); +} + + +static unsigned long next = 1; + +long +random(void) +{ + return do_random(&next); +} + +void +srandom(unsigned long seed) +{ + next = seed; +} + diff --git a/lib/msp430/twi.c b/lib/msp430/twi.c new file mode 100644 index 0000000..b92a6fe --- /dev/null +++ b/lib/msp430/twi.c @@ -0,0 +1,850 @@ +/* + ************************************************************************ + * twi.c + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + twi.c - TWI/I2C library for Wiring & Arduino + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include +#include +#include "Energia.h" // for digitalWrite + +#ifndef cbi +#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) +#endif + +#ifndef sbi +#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) +#endif + +#include "wiring_private.h" +#include "pins_energia.h" +#include "twi.h" +#include "usci_isr_handler.h" + +static volatile uint8_t twi_state; +static volatile uint8_t twi_sendStop; // should the transaction end with a stop +static volatile uint8_t twi_inRepStart; // in the middle of a repeated start + +static void (*twi_onSlaveTransmit)(void); +static void (*twi_onSlaveReceive)(uint8_t*, int); + +static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_masterBufferIndex; +static uint8_t twi_masterBufferLength; + +static uint8_t twi_txBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_txBufferIndex; +static volatile uint8_t twi_txBufferLength; +#if (defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_B0__)) +static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_rxBufferIndex; +#endif + +static volatile uint8_t twi_error; + +#ifdef __MSP430_HAS_USI__ +static uint8_t twi_slarw; +static uint8_t twi_my_addr; + +#endif + +#ifdef __MSP430_HAS_USCI__ +#endif + +#ifdef __MSP430_HAS_EUSCI_B0__ +#endif + +/* + * Function twi_init + * Desc readys twi pins and sets twi bitrate + * Input none + * Output none + */ +void twi_init(void) +{ + // initialize state + twi_state = TWI_IDLE; + twi_sendStop = true; // default value + twi_inRepStart = false; + +#ifdef __MSP430_HAS_USI__ + + /* 100 KHz for all */ +#if (F_CPU >= 16000000L) || (F_CPU >= 12000000L) + USICKCTL = USIDIV_7; +#elif defined(CALBC1_8MHZ_) && (F_CPU >= 8000000L) + USICKCTL = USIDIV_6; +#elif defined(CALBC1_1MHZ_) && (F_CPU >= 1000000L) + USICKCTL = USIDIV_3; +#endif + /* Enable USI I2C mode. */ + USICTL1 = USII2C; + /* SDA/SCL port enable and hold in reset */ + USICTL0 = (USIPE6 | USIPE7 | USISWRST); + /* SMCLK and SCL inactive state is high */ + USICKCTL |= (USISSEL_2 | USICKPL); + /* Disable automatic clear control */ + USICNT |= USIIFGCC; + /* Enable USI */ + USICTL0 &= ~USISWRST; + /* Counter interrupt enable */ + USICTL1 |= USIIE; +#endif + +#ifdef __MSP430_HAS_USCI__ + /* Calling this dummy function prevents the linker + * from stripping the USCI interupt vectors.*/ + usci_isr_install(); + + P1SEL |= BIT6 + BIT7; // Assign I2C pins to USCI_B0 + P1SEL2|= BIT6 + BIT7; // Assign I2C pins to USCI_B0 + + //Disable the USCI module and clears the other bits of control register + UCB0CTL1 = UCSWRST; + + /* + * Configure as I2C Slave. + * UCMODE_3 = I2C mode + * UCSYNC = Synchronous mode + * UCCLK = SMCLK + */ + UCB0CTL0 = UCMODE_3 | UCSYNC; + /* + * Compute the clock divider that achieves less than or + * equal to 100kHz. The numerator is biased to favor a larger + * clock divider so that the resulting clock is always less than or equal + * to the desired clock, never greater. + */ + UCB0BR0 = (unsigned char)((F_CPU / TWI_FREQ) & 0xFF); + UCB0BR1 = (unsigned char)((F_CPU / TWI_FREQ) >> 8); + + UCB0CTL1 &= ~(UCSWRST); + + /* Set I2C state change interrupt mask */ + UCB0I2CIE |= (UCALIE|UCNACKIE|UCSTTIE|UCSTPIE); + /* Enable state change and TX/RX interrupts */ + UC0IE |= UCB0RXIE | UCB0TXIE; +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + + P1SEL1 |= BIT6 + BIT7; // Pin init + + //Disable the USCI module and clears the other bits of control register + UCB0CTLW0 = UCSWRST; + + //Configure Automatic STOP condition generation + UCB0CTLW1 &= ~UCASTP_3; + //UCB0CTLW1 |= autoSTOPGeneration; + + //Byte Count Threshold + //UCB0TBCNT = byteCounterThreshold; + /* + * Configure as I2C master mode. + * UCMST = Master mode + * UCMODE_3 = I2C mode + * UCSYNC = Synchronous mode + * UCCLK = SMCLK + */ + UCB0CTLW0 = UCMODE_3 | UCSSEL__SMCLK | UCSYNC | UCSWRST; + + /* + * Compute the clock divider that achieves the fastest speed less than or + * equal to the desired speed. The numerator is biased to favor a larger + * clock divider so that the resulting clock is always less than or equal + * to the desired clock, never greater. + */ + UCB0BRW = (unsigned short)(F_CPU / 400000); + UCB0CTLW0 &= ~(UCSWRST); + UCB0IE |= (UCRXIE0|UCTXIE0|UCSTTIE|UCSTPIE); // Enable I2C interrupts +#endif +} + +/* + * Function twi_setAddress + * Desc sets slave address and enables interrupt + * Input none + * Output none + */ +void twi_setAddress(uint8_t address) +{ +#ifdef __MSP430_HAS_USI__ + twi_my_addr = address << 1; +#endif +#ifdef __MSP430_HAS_USCI__ + /* UCGCEN = respond to general Call */ + UCB0I2COA = (address | UCGCEN); +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + /* UCGCEN = respond to general Call */ + UCB0I2COA0 = (address | UCOAEN | UCGCEN); +#endif +} + +/* + * Function twi_readFrom + * Desc attempts to become twi bus master and read a + * series of bytes from a device on the bus + * Input address: 7bit i2c device address + * data: pointer to byte array + * length: number of bytes to read into array + * Output number of bytes read + */ +uint8_t twi_readFrom(uint8_t address, uint8_t* data, uint8_t length, uint8_t sendStop) +{ + uint8_t i; + +#ifdef __MSP430_HAS_USI__ + /* Disable START condition interrupt */ + USICTL1 &= ~USISTTIE; + /* I2C master mode */ + USICTL0 |= USIMST; +#endif +#ifdef __MSP430_HAS_USCI__ + UCB0CTL1 = UCSWRST; // Enable SW reset + UCB0CTL1 |= (UCSSEL_2); // I2C Master, synchronous mode + UCB0CTL0 |= (UCMST | UCMODE_3 | UCSYNC); // I2C Master, synchronous mode + UCB0CTL1 &= ~(UCTR); // Configure in receive mode + UCB0I2CSA = address; // Set Slave Address + UCB0CTL1 &= ~UCSWRST; // Clear SW reset, resume operation + UCB0I2CIE |= (UCALIE|UCNACKIE|UCSTPIE); // Enable I2C interrupts + UC0IE |= (UCB0RXIE | UCB0TXIE); // Enable I2C interrupts +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + UCB0CTLW0 = UCSWRST; // Enable SW reset + UCB0CTLW0 |= (UCMST | UCMODE_3 | UCSYNC | UCSSEL__SMCLK); // I2C Master, synchronous mode + UCB0CTLW0 &= ~(UCTR); // Configure in receive mode + UCB0I2CSA = address; // Set Slave Address + UCB0CTLW0 &= ~UCSWRST; // Clear SW reset, resume operation + UCB0IE |= (UCRXIE0|UCALIE|UCNACKIFG|UCSTTIFG|UCSTPIFG); // Enable I2C interrupts +#endif + // ensure data will fit into buffer + if(TWI_BUFFER_LENGTH < length){ + return 0; + } + + // initialize buffer iteration vars + twi_masterBufferIndex = 0; + twi_masterBufferLength = length-1; // This is not intuitive, read on... + // On receive, the previously configured ACK/NACK setting is transmitted in + // response to the received byte before the interrupt is signalled. + // Therefor we must actually set NACK when the _next_ to last byte is + // received, causing that NACK to be sent in response to receiving the last + // expected byte of data. + +#ifdef __MSP430_HAS_USI__ + /* build sla+w, slave device address + w bit */ + twi_slarw = 1; + twi_slarw |= address << 1; + + // send start condition + twi_state = TWI_SND_START; + // this will trigger an interrupt kicking off the state machine in the isr + USICTL1 |= USIIFG; +#endif +#ifdef __MSP430_HAS_USCI__ + twi_state = TWI_MRX; // Master receive mode + UCB0CTL1 |= UCTXSTT; // I2C start condition +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + twi_state = TWI_MRX; // Master receive mode + while (UCB0CTLW0 & UCTXSTP); // Ensure stop condition got sent + UCB0CTLW0 |= UCTXSTT; // I2C start condition +#endif + + /* Wait in low power mode for read operation to complete */ + while(twi_state != TWI_IDLE){ + __bis_SR_register(LPM0_bits); + } + + if (twi_masterBufferIndex < length) + length = twi_masterBufferIndex; + + for(i = 0; i < length; ++i){ + data[i] = twi_masterBuffer[i]; + } + +#ifdef __MSP430_HAS_USCI__ + /* Ensure stop condition got sent before we exit. */ + while (UCB0CTL1 & UCTXSTP); +#endif + return length; +} + +/* + * Function twi_writeTo + * Desc attempts to become twi bus master and write a + * series of bytes to a device on the bus + * Input address: 7bit i2c device address + * data: pointer to byte array + * length: number of bytes in array + * wait: boolean indicating to wait for write or not + * Output 0 .. success + * 1 .. length to long for buffer + * 2 .. address send, NACK received + * 3 .. data send, NACK received + * 4 .. other twi error (lost bus arbitration, bus error, ..) + */ +uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop) +{ + uint8_t i; + twi_error = TWI_ERRROR_NO_ERROR; + twi_sendStop = sendStop; + +#ifdef __MSP430_HAS_USI__ + /* Disable START condition interrupt */ + USICTL1 &= ~USISTTIE; + /* I2C master mode */ + USICTL0 |= USIMST; +#endif +#ifdef __MSP430_HAS_USCI__ + UCB0CTL1 = UCSWRST; // Enable SW reset + UCB0CTL1 |= UCSSEL_2; // SMCLK + UCB0CTL0 |= (UCMST | UCMODE_3 | UCSYNC); // I2C Master, synchronous mode + UCB0CTL1 |= UCTR; // Configure in transmit mode + UCB0I2CSA = address; // Set Slave Address + UCB0CTL1 &= ~UCSWRST; // Clear SW reset, resume operation + UCB0I2CIE |= (UCALIE|UCNACKIE|UCSTPIE); // Enable I2C interrupts + UC0IE |= UCB0TXIE; // Enable I2C interrupts +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + UCB0CTLW0 = UCSWRST; // Enable SW reset + UCB0CTLW0 |= (UCMST | UCMODE_3 | UCSSEL__SMCLK | UCSYNC); // I2C Master, synchronous mode + UCB0CTLW0 |= UCTR; // Configure in transmit mode + UCB0I2CSA = address; // Set Slave Address + UCB0CTLW0 &= ~UCSWRST; // Clear SW reset, resume operation + UCB0IE |= (UCTXIE0|UCALIE|UCNACKIE|UCSTPIE); // Enable I2C interrupts +#endif + if(length == 0) { + return 0; + } + + /* Ensure data will fit into buffer */ + if(length > TWI_BUFFER_LENGTH){ + return TWI_ERROR_BUF_TO_LONG; + } + + + /* initialize buffer iteration vars */ + twi_masterBufferIndex = 0; + twi_masterBufferLength = length; + + for(i = 0; i < length; ++i){ + twi_masterBuffer[i] = data[i]; + } + +#ifdef __MSP430_HAS_USI__ + /* build sla+w, slave device address + w bit */ + twi_slarw = 0; + twi_slarw |= address << 1; + + twi_state = TWI_SND_START; + /* This will trigger an interrupt kicking off the state machine in the isr */ + USICTL1 |= USIIFG; +#endif +#ifdef __MSP430_HAS_USCI__ + twi_state = TWI_MTX; // Master Transmit mode + UCB0CTL1 |= UCTXSTT; // I2C start condition +#endif +#ifdef __MSP430_HAS_EUSCI_B0__ + twi_state = TWI_MTX; // Master Transmit mode + while (UCB0CTLW0 & UCTXSTP); // Ensure stop condition got sent + UCB0CTLW0 |= UCTXSTT; // I2C start condition +#endif + + /* Wait for the transaction to complete */ + while(twi_state != TWI_IDLE) { + __bis_SR_register(LPM0_bits); + } + +#ifdef __MSP430_HAS_USCI__ + /* Ensure stop condition got sent before we exit. */ + while (UCB0CTL1 & UCTXSTP); +#endif + + return twi_error; +} + +/* + * Function twi_transmit + * Desc fills slave tx buffer with data + * must be called in slave tx event callback + * Input data: pointer to byte array + * length: number of bytes in array + * Output 1 length too long for buffer + * 2 not slave transmitter + * 0 ok + */ +uint8_t twi_transmit(const uint8_t* data, uint8_t length) +{ + uint8_t i; + + twi_state = TWI_STX; // Slave transmit mode + + // ensure data will fit into buffer + if(TWI_BUFFER_LENGTH < length){ + return 1; + } + // set length and copy data into tx buffer + twi_txBufferLength = length; + for(i = 0; i < length; ++i){ + twi_txBuffer[i] = data[i]; + } + + return 0; +} + +/* + * Function twi_attachSlaveRxEvent + * Desc sets function called before a slave read operation + * Input function: callback function to use + * Output none + */ +void twi_attachSlaveRxEvent( void (*function)(uint8_t*, int) ) +{ + twi_onSlaveReceive = function; +} + +/* + * Function twi_attachSlaveTxEvent + * Desc sets function called before a slave write operation + * Input function: callback function to use + * Output none + */ +void twi_attachSlaveTxEvent( void (*function)(void) ) +{ + twi_onSlaveTransmit = function; +} + +void send_start() +{ +#ifdef __MSP430_HAS_USI__ + USISRL = 0x00; + USICTL0 |= USIGE+USIOE; + USICTL0 &= ~USIGE; + USISRL = twi_slarw; + USICNT = (USICNT & 0xE0) + 0x08; +#endif +} + +#ifdef __MSP430_HAS_USI__ +__attribute__((interrupt(USI_VECTOR))) +void USI_ISR(void) +{ + if (!(USICTL0 & USIMST) && (USICTL1 & USISTTIFG)) { + twi_state = TWI_SL_START; + } + + switch(twi_state){ + /* Master transmit / receive */ + case TWI_SND_START: + send_start(); + twi_state = TWI_PREP_SLA_ADDR_ACK; + break; + case TWI_PREP_SLA_ADDR_ACK: // reveive (N)ACK + USICTL0 &= ~USIOE; // SDA = input + USICNT |= 0x01; // Bit counter=1 + twi_state = TWI_MT_PROC_ADDR_ACK; + break; + case TWI_MT_PROC_ADDR_ACK: + if (USISRL & 0x01) { + twi_error = TWI_ERROR_ADDR_NACK; + USICTL0 |= USIOE; + USISRL = 0x00; + USICNT |= 0x01; + twi_state = TWI_EXIT; + break; + } + + if(twi_slarw & 1) + goto mtre; + else + goto mtpd; + + break; + /* Prepare to receive data (N)ACK */ + case TWI_MT_PREP_DATA_ACK: + /* SDA = input */ + USICTL0 &= ~USIOE; + /* Bit counter = 1 */ + USICNT |= 0x01; + twi_state = TWI_MT_PROC_DATA_ACK; + break; + case TWI_MT_PROC_DATA_ACK: +mtpd: + if (USISRL & 0x01) { + twi_error = TWI_ERROR_DATA_NACK; + USICTL0 |= USIOE; + USISRL = 0x00; + USICNT |= 0x01; + twi_state = TWI_EXIT; + break; + } + + if(twi_masterBufferIndex == twi_masterBufferLength) { + USICTL0 |= USIOE; + USISRL = 0x00; + USICNT |= 0x01; + twi_state = TWI_EXIT; + break; + } + + USICTL0 |= USIOE; + USISRL = twi_masterBuffer[twi_masterBufferIndex++]; + USICNT |= 0x08; + twi_state = TWI_MT_PREP_DATA_ACK; + break; + // Master receiver +mtre: + case TWI_MR_PREP_DATA_RECV: + /* SDA input */ + USICTL0 &= ~USIOE; + /* bit counter = 8 */ + USICNT |= 0x08; + twi_state = TWI_MR_PROC_DATA_RECV; + break; + case TWI_MR_PROC_DATA_RECV: + /* SDA output */ + USICTL0 |= USIOE; + + twi_masterBuffer[twi_masterBufferIndex++] = USISRL; + if(twi_masterBufferIndex > twi_masterBufferLength ) { + USISRL = 0xFF; // that was the last byte send NACK + twi_state = TWI_MR_PREP_STOP; + } else { + USISRL = 0x00; // keep on receiving and send ACK + twi_state = TWI_MR_PREP_DATA_RECV; + } + + USICNT |= 0x01; + break; + case TWI_MR_PREP_STOP: + USICTL0 |= USIOE; + USISRL = 0x00; + USICNT |= 0x01; + twi_state = TWI_EXIT; + break; + /* All */ + case TWI_EXIT: + /* Load FF into output shift register */ + USISRL = 0x0FF; + /* Output latch transparant. MSB of USISR to the SDO pin. */ + USICTL0 |= USIGE; + /* Latch disabled and make SDA input */ + USICTL0 &= ~(USIGE+USIOE); + twi_state = TWI_IDLE; + break; + case TWI_IDLE: + /* Nothing to do. Fall thru and clear interrupt flag. */ + default: + break; + } + + /* Clear counter interrupt */ + USICTL1 &= ~USIIFG; + +} +#endif /* __MSP430_HAS_USI__ */ + +#ifdef __MSP430_HAS_USCI__ +void i2c_txrx_isr(void) // RX/TX Service +{ + /* USCI I2C mode. USCI_B0 receive interrupt flag. + * UCB0RXIFG is set when UCB0RXBUF has received a complete character. */ + if (UC0IFG & UCB0RXIFG){ + /* Master receive mode. */ + if (twi_state == TWI_MRX) { + twi_masterBuffer[twi_masterBufferIndex++] = UCB0RXBUF; + if(twi_masterBufferIndex == twi_masterBufferLength ) + /* Only one byte left. Generate STOP condition. + * In master mode a STOP is preceded by a NACK */ + UCB0CTL1 |= UCTXSTP; + if(twi_masterBufferIndex > twi_masterBufferLength ) { + /* All bytes received. We are idle*/ + __bic_SR_register(LPM0_bits); + twi_state = TWI_IDLE; + } + /* Slave receive mode. (twi_state = TWI_SRX) */ + } else { + // if there is still room in the rx buffer + if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){ + // put byte in buffer and ack + twi_rxBuffer[twi_rxBufferIndex++] = UCB0RXBUF; + }else{ + // otherwise nack + UCB0CTL1 |= UCTXNACK; // Generate NACK condition + } + } + } + /* USCI I2C mode. USCI_B0 transmit interrupt flag. + * UCB0TXIFG is set when UCB0TXBUF is empty.*/ + if (UC0IFG & UCB0TXIFG){ + /* Master transmit mode */ + if (twi_state == TWI_MTX) { + // if there is data to send, send it, otherwise stop + if(twi_masterBufferIndex < twi_masterBufferLength){ + // Copy data to output register and ack. + UCB0TXBUF = twi_masterBuffer[twi_masterBufferIndex++]; + }else{ + if (twi_sendStop) { + /* All done. Generate STOP condition and IDLE */ + UCB0CTL1 |= UCTXSTP; + twi_state = TWI_IDLE; + __bic_SR_register(LPM0_bits); + } else { + twi_inRepStart = true; // we're gonna send the START + // don't enable the interrupt. We'll generate the start, but we + // avoid handling the interrupt until we're in the next transaction, + // at the point where we would normally issue the start. + UCB0CTL1 |= UCTXSTT; + twi_state = TWI_IDLE; + __bic_SR_register(LPM0_bits); + } + } + /* Slave transmit mode (twi_state = TWI_STX) */ + } else { + // copy data to output register + UCB0TXBUF = twi_txBuffer[twi_txBufferIndex++]; + // if there is more to send, ack, otherwise nack + if(twi_txBufferIndex < twi_txBufferLength){ + }else{ + UCB0CTL1 |= UCTXNACK; // Generate NACK condition + } + } + } +} + +void i2c_state_isr(void) // I2C Service +{ + /* Arbitration lost interrupt flag */ + if (UCB0STAT & UCALIFG) { + UCB0STAT &= ~UCALIFG; + /* TODO: Handle bus arbitration lost */ + } + /* Not-acknowledge received interrupt flag. + * UCNACKIFG is automatically cleared when a START condition is received.*/ + if (UCB0STAT & UCNACKIFG) { + UCB0STAT &= ~UCNACKIFG; + UCB0CTL1 |= UCTXSTP; + twi_state = TWI_IDLE; + /* TODO: This can just as well be an address NACK. + * Figure out a way to distinguish between ANACK and DNACK */ + twi_error = TWI_ERROR_DATA_NACK; + __bic_SR_register(LPM0_bits); + } + /* Start condition interrupt flag. + * UCSTTIFG is automatically cleared if a STOP condition is received. */ + if (UCB0STAT & UCSTTIFG) { + UCB0STAT &= ~UCSTTIFG; + /* UCTR is automagically set by the USCI module upon a START condition. */ + if (UCB0CTL1 & UCTR) { + /* Slave TX mode. */ + twi_state = TWI_STX; + /* Ready the tx buffer index for iteration. */ + twi_txBufferIndex = 0; + /* Set tx buffer length to be zero, to verify if user changes it. */ + twi_txBufferLength = 0; + /* Request for txBuffer to be filled and length to be set. */ + /* note: user must call twi_transmit(bytes, length) to do this */ + twi_onSlaveTransmit(); + /* If they didn't change buffer & length, initialize it + * TODO: Is this right? Shouldn't we reply with a NACK if there is no data to send? */ + if (0 == twi_txBufferLength) { + twi_txBufferLength = 1; + twi_txBuffer[0] = 0x00; + } + } else { + /* Slave receive mode. */ + twi_state = TWI_SRX; + /* Indicate that rx buffer can be overwritten and ACK */ + twi_rxBufferIndex = 0; + } + } + /* Stop condition interrupt flag. + * UCSTPIFG is automatically cleared when a START condition is received. */ + if (UCB0STAT & UCSTPIFG) { + UCB0STAT &= ~UCSTPIFG; + if (twi_state == TWI_SRX) { + /* Callback to user defined callback */ + twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex); + } + twi_state = TWI_IDLE; + } +} +#endif + +#ifdef __MSP430_HAS_EUSCI_B0__ +__attribute__((interrupt(USCI_B0_VECTOR))) +void USCI_B0_ISR(void) +{ +// switch(twi_state){ + switch(UCB0IV){ + case USCI_NONE: // No Interrupt pending + break; + case USCI_I2C_UCALIFG: // USCI I2C Mode: UCALIFG + // enter slave transmitter mode + twi_state = TWI_STX; + // ready the tx buffer index for iteration + twi_txBufferIndex = 0; + // set tx buffer length to be zero, to verify if user changes it + twi_txBufferLength = 0; + // request for txBuffer to be filled and length to be set + // note: user must call twi_transmit(bytes, length) to do this + twi_onSlaveTransmit(); + // if they didn't change buffer & length, initialize it + if(0 == twi_txBufferLength){ + twi_txBufferLength = 1; + twi_txBuffer[0] = 0x00; + } + // transmit first byte from buffer, fall + // copy data to output register + UCB0TXBUF = twi_txBuffer[twi_txBufferIndex++]; + // if there is more to send, ack, otherwise nack + if(twi_txBufferIndex < twi_txBufferLength){ + //twi_reply(1); + }else{ + UCB0CTLW0 |= UCTXNACK; // Generate NACK condition + } + // leave slave receiver state + twi_state = TWI_IDLE; + + break; + case USCI_I2C_UCNACKIFG: // USCI I2C Mode: UCNACKIFG + // leave slave receiver state + twi_state = TWI_IDLE; + twi_error = TWI_ERROR_DATA_NACK; + __bic_SR_register_on_exit(CPUOFF); // Exit LPM0 + break; + case USCI_I2C_UCSTTIFG: // USCI I2C Mode: UCSTTIFG + UCB0IFG &= ~UCSTTIFG; + if (twi_state == TWI_IDLE){ + if (UCB0CTLW0 & UCTR){ + twi_state = TWI_STX; // Slave Transmit mode + // ready the tx buffer index for iteration + twi_txBufferIndex = 0; + // set tx buffer length to be zero, to verify if user changes it + twi_txBufferLength = 0; + // request for txBuffer to be filled and length to be set + // note: user must call twi_transmit(bytes, length) to do this + twi_onSlaveTransmit(); + // if they didn't change buffer & length, initialize it + if(0 == twi_txBufferLength){ + twi_txBufferLength = 1; + twi_txBuffer[0] = 0x00; + } + }else{ + twi_state = TWI_SRX; // Slave receive mode + // indicate that rx buffer can be overwritten and ack + twi_rxBufferIndex = 0; + } + } + break; + case USCI_I2C_UCSTPIFG: // USCI I2C Mode: UCSTPIFG + UCB0IFG &= ~UCSTPIFG; + if (twi_state == TWI_SRX){ + // callback to user defined callback + twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex); + } + twi_state = TWI_IDLE; // IDLE mode + /* Work around for: + * If the master does a read and then a write the START interrupt occurs + * but the RX interrupt never fires. Clearing bit 4 and 5 of UCB0CTLW0 solves this. + * bit 4 and 5 are however marked as reserved in the datasheet. + */ + UCB0CTLW0 &= ~0x18; + + __bic_SR_register_on_exit(CPUOFF); // Exit LPM0 + break; + case USCI_I2C_UCRXIFG3: // USCI I2C Mode: UCRXIFG3 + break; + case USCI_I2C_UCTXIFG3: // USCI I2C Mode: UCTXIFG3 + break; + case USCI_I2C_UCRXIFG2: // USCI I2C Mode: UCRXIFG2 + break; + case USCI_I2C_UCTXIFG2: // USCI I2C Mode: UCTXIFG2 + break; + case USCI_I2C_UCRXIFG1: // USCI I2C Mode: UCRXIFG1 + break; + case USCI_I2C_UCTXIFG1: // USCI I2C Mode: UCTXIFG1 + break; + case USCI_I2C_UCRXIFG0: // USCI I2C Mode: UCRXIFG0 + UCB0IFG &= ~UCRXIFG; // Clear USCI_B0 TX int flag + if (twi_state == TWI_MRX) { // Master receive mode + twi_masterBuffer[twi_masterBufferIndex++] = UCB0RXBUF; // Get RX data + if(twi_masterBufferIndex == twi_masterBufferLength ) + UCB0CTLW0 |= UCTXSTP; // Generate I2C stop condition + if(twi_masterBufferIndex > twi_masterBufferLength ) { + twi_state = TWI_IDLE; //Idle + } else { + } + } else { + // if there is still room in the rx buffer + if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){ + // put byte in buffer and ack + twi_rxBuffer[twi_rxBufferIndex++] = UCB0RXBUF; + }else{ + // otherwise nack + UCB0CTLW0 |= UCTXNACK; // Generate NACK condition + } + } + break; + case USCI_I2C_UCTXIFG0: // USCI I2C Mode: UCTXIFG0 + UCB0IFG &= ~UCTXIFG; // Clear USCI_B0 TX int flag + if (twi_state == TWI_MTX) { // Master receive mode + // if there is data to send, send it, otherwise stop + if(twi_masterBufferIndex < twi_masterBufferLength){ + // copy data to output register and ack + UCB0TXBUF = twi_masterBuffer[twi_masterBufferIndex++]; // Transmit data at address PTxData + }else{ + if (twi_sendStop) + UCB0CTLW0 |= UCTXSTP; // Generate I2C stop condition + else { + twi_inRepStart = true; // we're gonna send the START + // don't enable the interrupt. We'll generate the start, but we + // avoid handling the interrupt until we're in the next transaction, + // at the point where we would normally issue the start. + UCB0CTLW0 |= UCTXSTT; + twi_state = TWI_IDLE; + } + } + } else { + // copy data to output register + UCB0TXBUF = twi_txBuffer[twi_txBufferIndex++]; + // if there is more to send, ack, otherwise nack + if(twi_txBufferIndex < twi_txBufferLength){ + }else{ + UCB0CTLW0 |= UCTXNACK; // Generate NACK condition + } + } + break; + case USCI_I2C_UCBCNTIFG: // USCI I2C Mode: UCBCNTIFG + break; + case USCI_I2C_UCCLTOIFG: // USCI I2C Mode: UCCLTOIFG/ + break; + case USCI_I2C_UCBIT9IFG: // USCI I2C Mode: UCBIT9IFG + break; + } +} +#endif + diff --git a/lib/msp430/twi.h b/lib/msp430/twi.h new file mode 100644 index 0000000..ea383b6 --- /dev/null +++ b/lib/msp430/twi.h @@ -0,0 +1,104 @@ +/* + ************************************************************************ + * twi.h + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + twi.h - TWI/I2C library for Wiring & Arduino + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library 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 library 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 library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef twi_h +#define twi_h + +#include + +#if !defined (__MSP430_HAS_USI__) && !defined (__MSP430_HAS_USCI__) && !defined (__MSP430_HAS_EUSCI_B0__) +#ifndef __MSP430_HAS_USI__ +#error "********** USI not available" +#endif + +#if !defined (__MSP430_HAS_USCI__) && !defined (__MSP430_HAS_EUSCI_B0__) +#error "********** USCI not available" +#endif +#endif + + +#include + +#ifndef TWI_FREQ +#define TWI_FREQ 100000L +#endif + +#ifndef TWI_BUFFER_LENGTH +#define TWI_BUFFER_LENGTH 16 +#endif + + +#define TWI_READY 0 +#define TWI_MRX 1 +#define TWI_MTX 2 +#define TWI_SRX 3 +#define TWI_STX 4 + + +#define TWI_SND_START 0 +#define TWI_PREP_SLA_ADDR_ACK 1 +#define TWI_MT_PROC_ADDR_ACK 2 +#define TWI_MT_PREP_DATA_ACK 3 +#define TWI_MT_PROC_DATA_ACK 4 +#define TWI_MR_PREP_DATA_RECV 5 +#define TWI_MR_PROC_DATA_RECV 6 +#define TWI_MR_PREP_STOP 7 + +#define TWI_SL_START 8 +#define TWI_SL_PROC_ADDR 9 +#define TWI_SL_SEND_BYTE 10 +#define TWI_SL_PREP_DATA_ACK 11 +#define TWI_SL_PROC_DATA_ACK 12 +#define TWI_SL_RECV_BYTE 13 +#define TWI_SL_PROC_BYTE 14 +#define TWI_SL_RESET 15 +#define TWI_EXIT 16 +#define TWI_IDLE 17 + + +#define TWI_ERRROR_NO_ERROR 0 +#define TWI_ERROR_BUF_TO_LONG 1 +#define TWI_ERROR_ADDR_NACK 2 +#define TWI_ERROR_DATA_NACK 3 +#define TWI_ERROR_OTHER 4 + + + +void twi_init(void); +void twi_setAddress(uint8_t); +uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t, uint8_t); +uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t, uint8_t); +uint8_t twi_transmit(const uint8_t*, uint8_t); +void twi_attachSlaveRxEvent( void (*)(uint8_t*, int) ); +void twi_attachSlaveTxEvent( void (*)(void) ); +void twi_reply(uint8_t); +void twi_stop(void); +void twi_releaseBus(void); + +#endif + diff --git a/lib/msp430/usci_isr_handler.c b/lib/msp430/usci_isr_handler.c new file mode 100644 index 0000000..a112ce7 --- /dev/null +++ b/lib/msp430/usci_isr_handler.c @@ -0,0 +1,59 @@ +#include "Energia.h" +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) +#include "usci_isr_handler.h" + +/* This dummy function ensures that, when called from any module that + * is interested in having the USCIAB0TX_VECTOR and USCIAB0TX_VECTOR + * installed, the linker won't strip the vectors.*/ +void usci_isr_install(){} + + + +#if defined(__MSP430_HAS_EUSCI_A0__) +__attribute__((interrupt(USCI_A0_VECTOR))) +void USCIA0_ISR(void) +{ + switch ( UCA0IV ) + { + case USCI_UART_UCRXIFG: uart_rx_isr(); break; + case USCI_UART_UCTXIFG: uart_tx_isr(); break; + } +} + +#else // #if defined(__MSP430_HAS_EUSCI_A0__) +/* USCI_Ax and USCI_Bx share the same TX interrupt vector. + * UART: + * USCIAB0TX_VECTOR services the UCA0TXIFG set in UC0IFG. + * USCIAB0RX_VECTOR services the UCA0RXIFG set in UC0IFG. + * I2C: + * USCIAB0TX_VECTOR services both UCB0TXIFG and UCB0RXIFG + * set in UC0IFG. + * USCIAB0RX_VECTOR services the state change interrupts + * UCSTTIFG, UCSTPIFG, UCIFG, UCALIFG set in UCB0STAT.*/ + +__attribute__((interrupt(USCIAB0TX_VECTOR))) +void USCIAB0TX_ISR(void) +{ + /* USCI_A0 UART interrupt? */ + if (UC0IFG & UCA0TXIFG) + uart_tx_isr(); + + /* USCI_B0 I2C TX RX interrupt. */ + if ((UC0IFG & (UCB0TXIFG | UCB0RXIFG)) != 0) + i2c_txrx_isr(); + +} + +__attribute__((interrupt(USCIAB0RX_VECTOR))) +void USCIAB0RX_ISR(void) +{ + /* USCI_A0 UART interrupt? */ + if (UC0IFG & UCA0RXIFG) + uart_rx_isr(); + + /* USCI_B0 I2C state change interrupt. */ + if ((UCB0STAT & (UCALIFG | UCNACKIFG | UCSTTIFG | UCSTPIFG)) != 0) + i2c_state_isr(); +} +#endif // #if defined(__MSP430_HAS_EUSCI_A0__) +#endif // if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) diff --git a/lib/msp430/usci_isr_handler.h b/lib/msp430/usci_isr_handler.h new file mode 100644 index 0000000..19f427d --- /dev/null +++ b/lib/msp430/usci_isr_handler.h @@ -0,0 +1,18 @@ +#ifndef usci_isr_handler_h +#define usci_isr_handler_h + +#if defined(__MSP430_HAS_USCI__) || defined(__MSP430_HAS_EUSCI_A0__) + +#ifdef __cplusplus +extern "C" { +#endif +void uart_tx_isr(void); +void uart_rx_isr(void); +void i2c_txrx_isr(void); +void i2c_state_isr(void); +void usci_isr_install(void); +#ifdef __cplusplus +} +#endif +#endif /* __MSP430_HAS_USCI__ */ +#endif /* usci_isr_handler_h */ diff --git a/lib/msp430/wiring.c b/lib/msp430/wiring.c new file mode 100644 index 0000000..058b2ac --- /dev/null +++ b/lib/msp430/wiring.c @@ -0,0 +1,223 @@ +/* + ************************************************************************ + * wiring.c + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring.c - Partial implementation of the Wiring API for the ATmega8. + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA +*/ +#include "Energia.h" + +void initClocks(void); +void enableWatchDogIntervalMode(void); + +void init() +{ + disableWatchDog(); + initClocks(); + enableWatchDogIntervalMode(); + /* Clear P2.6 and P2.7 bits to default to GPIO */ +#ifdef P2SEL2_ + P2SEL &= ~(BIT6|BIT7); +#endif + __eint(); +} + +void disableWatchDog() +{ + /* Diable watchdog timer */ + WDTCTL = WDTPW | WDTHOLD; +} + +void enableWatchDog() +{ + enableWatchDogIntervalMode(); +} + +/* WDT_TICKS_PER_MILISECOND = (F_CPU / WDT_DIVIDER) / 1000 + * WDT_TICKS_PER_MILISECONDS = 1.953125 = 2 */ +#define SMCLK_FREQUENCY F_CPU +#define WDT_TICKS_PER_MILISECOND (2*SMCLK_FREQUENCY/1000000) +#define WDT_DIV_BITS WDT_MDLY_0_5 + +void enableWatchDogIntervalMode(void) +{ + /* WDT Password + WDT interval mode + Watchdog clock source /512 + source from SMCLK + * Note that we WDT is running in interval mode. WDT will not trigger a reset on expire in this mode. */ + WDTCTL = WDTPW | WDTTMSEL | WDTCNTCL | WDT_DIV_BITS; + + /* WDT interrupt enable */ +#ifdef __MSP430_HAS_SFR__ + SFRIE1 |= WDTIE; +#else + IE1 |= WDTIE; +#endif +} + +void initClocks(void) +{ +#ifdef __MSP430_HAS_BC2__ +#if defined(CALBC1_16MHZ_) && F_CPU >= 16000000L + BCSCTL1 = CALBC1_16MHZ; + DCOCTL = CALDCO_16MHZ; +#elif defined(CALBC1_12MHZ_) && (F_CPU >= 12000000L) + BCSCTL1 = CALBC1_12MHZ; + DCOCTL = CALDCO_12MHZ; +#elif defined(CALBC1_8MHZ_) && (F_CPU >= 8000000L) + BCSCTL1 = CALBC1_8MHZ; + DCOCTL = CALDCO_8MHZ; +#elif defined(CALBC1_1MHZ_) && (F_CPU >= 1000000L) + BCSCTL1 = CALBC1_1MHZ; + DCOCTL = CALDCO_1MHZ; +#else + #warning No Suitable Frequency found! +#endif + /* SMCLK = DCO / DIVS = nMHz */ + BCSCTL2 &= ~(DIVS_0); + /* ACLK = VLO = ~ 12 KHz */ + BCSCTL3 |= LFXT1S_2; +#endif + +#ifdef __MSP430_HAS_CS__ + CSCTL0 = CSKEY; // Enable Access to CS Registers + + CSCTL2 &= ~SELM_7; // Clear selected Main CLK Source + CSCTL2 |= SELM__DCOCLK; // Use DCO as Main Clock Source + CSCTL3 &= ~(DIVM_3 | DIVS_3); // clear DIVM Bits +#if F_CPU >= 24000000L + CSCTL1 = DCOFSEL0 | DCOFSEL1 | DCORSEL; //Level 2 / Range 1 : 24.0MHz +#elif F_CPU >= 16000000L + CSCTL1 = DCORSEL; //Level 0 / Range 1 : 16.0MHz +#elif F_CPU >= 12000000L + CSCTL1 = DCOFSEL0 | DCOFSEL1 | DCORSEL; //Level 2 / Range 1 : 24.0MHz + CSCTL3 |= DIVM_1; // Div = 2 +#elif F_CPU >= 8000000L + CSCTL1 = DCOFSEL0 | DCOFSEL1; //Level 2 / Range 0 : 8.0MHz +#elif F_CPU >= 1000000L + CSCTL1 = DCOFSEL0 | DCOFSEL1; //Level 2 / Range 0 : 8.0MHz + CSCTL3 |= DIVM_3; // Div = 8 +#else + #warning No Suitable Frequency found! +#endif +// CSCTL0 = 0; // Disable Access to CS Registers +#endif // __MSP430_HAS_CS__ + +} +volatile uint32_t wdtCounter = 0; + +unsigned long micros() +{ + return (1000 * wdtCounter) / WDT_TICKS_PER_MILISECOND; +} + +unsigned long millis() +{ + return wdtCounter / WDT_TICKS_PER_MILISECOND; +} + +/* Delay for the given number of microseconds. Assumes a 1, 8 or 16 MHz clock. */ +void delayMicroseconds(unsigned int us) +{ +#if F_CPU >= 20000000L + /* For a one-microsecond delay, simply wait 2 cycle and return. The overhead + * of the function call yields a delay of exactly one microsecond. */ + __asm__ __volatile__ ( + "nop" "\n\t" + "nop"); + if (--us == 0) + return; + + /* The following loop takes a 1/5 of a microsecond (4 cycles) + * per iteration, so execute it five times for each microsecond of + * delay requested. */ + us = (us<<2) + us; // x5 us + + /* Account for the time taken in the preceeding commands. */ + us -= 2; + +#elif F_CPU >= 16000000L + /* For the 16 MHz clock on most boards */ + + /* For a one-microsecond delay, simply return. the overhead + * of the function call yields a delay of approximately 1 1/8 us. */ + if (--us == 0) + return; + + /* The following loop takes a quarter of a microsecond (4 cycles) + * per iteration, so execute it four times for each microsecond of + * delay requested. */ + us <<= 2; + + /* Account for the time taken in the preceeding commands. */ + us -= 2; +#else + /* For the 1 MHz */ + + /* For a one- or two-microsecond delay, simply return. the overhead of + * the function calls takes more than two microseconds. can't just + * subtract two, since us is unsigned; we'd overflow. */ + if (--us == 0) + return; + if (--us == 0) + return; + + /* The following loop takes 4 microsecond (4 cycles) + * per iteration, so execute it ones for each 4 microsecond of + * delay requested. */ + us >>= 2; + + /* Partially compensate for the time taken by the preceeding commands. + * we can't subtract any more than this or we'd overflow w/ small delays. */ + us--; +#endif + + /* Busy wait */ + __asm__ __volatile__ ( + /* even steven */ + "L1: nop \n\t" + /* 1 instruction */ + "dec.w %[us] \n\t" + /* 2 instructions */ + "jnz L1 \n\t" + : [us] "=r" (us) : "[us]" (us) + ); +} + +/* (ab)use the WDT */ +void delay(uint32_t milliseconds) +{ + uint32_t wakeTime = wdtCounter + (milliseconds * WDT_TICKS_PER_MILISECOND); + while(wdtCounter < wakeTime) + /* Wait for WDT interrupt in LMP0 */ + __bis_status_register(LPM0_bits+GIE); +} + +__attribute__((interrupt(WDT_VECTOR))) +void watchdog_isr (void) +{ + wdtCounter++; + /* Exit from LMP3 on reti (this includes LMP0) */ + __bic_status_register_on_exit(LPM3_bits); +} diff --git a/lib/msp430/wiring_analog.c b/lib/msp430/wiring_analog.c new file mode 100644 index 0000000..1451ad7 --- /dev/null +++ b/lib/msp430/wiring_analog.c @@ -0,0 +1,297 @@ +/* + ************************************************************************ + * wiring_analog.c + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring_analog.c - analog input and output + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA +*/ + +#include "wiring_private.h" +#include "pins_energia.h" + +#if defined(__MSP430_HAS_ADC10__) && !defined(ADC10ENC) +#define ADC10ENC ENC +#endif +#if defined(__MSP430_HAS_ADC10__) && !defined(ADC10MEM0) +#define ADC10MEM0 ADC10MEM +#endif +#if defined(__MSP430_HAS_ADC10_B__) +#define REFV_MASK 0x70 +#define REF_MASK 0x31; +#endif + +#if defined(__MSP430_HAS_ADC10__) || defined(__MSP430_HAS_ADC10_B__) +uint16_t analog_reference = DEFAULT, analog_period = F_CPU/490, analog_div = 0, analog_res=255; // devide clock with 0, 2, 4, 8 +#endif + +void analogReference(uint16_t mode) +{ + // can't actually set the register here because the default setting + // will connect AVCC and the AREF pin, which would cause a short if + // there's something connected to AREF. + analog_reference = mode; +} + +//TODO: Can be a lot more efficiant. +// - lower clock rated / input devider to conserve Energia. +// - pin configuration logic. + +// Note set frequency before sending analog value +// Lowest fequency is defined by clock frequency F_CPU, and max counter value 2^16-1 +// fmin = F_CPU / 2^16 +void analogFrequency(uint32_t freq) +{ + if ( freq <= F_CPU/(4*65334L) ) { analog_div = ID_3; freq *=8; } + else if ( freq <= F_CPU/(2*65334L) ) { analog_div = ID_2; freq *=4; } + else if ( freq <= F_CPU/(4*65334L) ) { analog_div = ID_1; freq *=2; } + analog_period = F_CPU/freq; +} + +// Set the resulution (nr of counts for 100%), default = 255, large values may not work at all frequencies +void analogResolution(uint16_t res) +{ + analog_res = res; +} + +//Arduino specifies ~490 Hz for analog out PWM so we follow suit. +#define PWM_PERIOD analog_period // F_CPU/490 +#define PWM_DUTY(x) ( (unsigned long)x*PWM_PERIOD / (unsigned long)analog_res ) +void analogWrite(uint8_t pin, int val) +{ + pinMode(pin, OUTPUT); // pin as output + + if (val == 0) + { + digitalWrite(pin, LOW); // set pin to LOW when duty cycle is 0 + // digitalWrite will take care of invalid pins + } + else if (val == analog_res) + { + digitalWrite(pin, HIGH); // set pin HIGH when duty cycle is 255 + // digitalWrite will take care of invalid pins + } + else + { + + uint8_t bit = digitalPinToBitMask(pin); // get pin bit + uint8_t port = digitalPinToPort(pin); // get pin port + volatile uint8_t *sel; + + if (port == NOT_A_PORT) return; // pin on timer? + + sel = portSelRegister(port); // get the port function select register address + *sel |= bit; // set bit in pin function select register + + switch(digitalPinToTimer(pin)) { // which timer and CCR? + //case: T0A0 // CCR0 used as period register + case T0A1: // TimerA0 / CCR1 + TA0CCR0 = PWM_PERIOD; // PWM Period + TA0CCTL1 = OUTMOD_7; // reset/set + TA0CCR1 = PWM_DUTY(val); // PWM duty cycle + TA0CTL = TASSEL_2 + MC_1 + analog_div; // SMCLK, up mode + break; +#if defined(__MSP430_HAS_TA3__) || defined(__MSP430_HAS_T0A3__) + case T0A2: // TimerA0 / CCR2 + TA0CCR0 = PWM_PERIOD; // PWM Period + TA0CCTL2 = OUTMOD_7; // reset/set + TA0CCR2 = PWM_DUTY(val); // PWM duty cycle + TA0CTL = TASSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif +#if defined(__MSP430_HAS_T1A3__) + //case: T1A0 // CCR0 used as period register + case T1A1: // TimerA1 / CCR1 + TA1CCR0 = PWM_PERIOD; // PWM Period + TA1CCTL1 = OUTMOD_7; // reset/set + TA1CCR1 = PWM_DUTY(val); // PWM duty cycle + TA1CTL = TASSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; + case T1A2: // TimerA1 / CCR2 + TA1CCR0 = PWM_PERIOD; // PWM Period + TA1CCTL2 = OUTMOD_7; // reset/set + TA1CCR2 = PWM_DUTY(val); // PWM duty cycle + TA1CTL = TASSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif +#if defined(__MSP430_HAS_T2A3__) + //case: T2A0 // CCR0 used as period register + case T2A1: // TimerA2 / CCR1 + TA2CCR0 = PWM_PERIOD; // PWM Period + TA2CCTL1 = OUTMOD_7; // reset/set + TA2CCR1 = PWM_DUTY(val); // PWM duty cycle + TA2CTL = TASSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; + case T2A2: // TimerA2 / CCR2 + TA2CCR0 = PWM_PERIOD; // PWM Period + TA2CCTL2 = OUTMOD_7; // reset/set + TA2CCR2 = PWM_DUTY(val); // PWM duty cycle + TA2CTL = TASSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif +#if defined(__MSP430_HAS_T0B3__) + //case: T0B0 // CCR0 used as period register + case T0B1: // TimerB0 / CCR1 + TB0CCR0 = PWM_PERIOD; // PWM Period + TB0CCTL1 = OUTMOD_7; // reset/set + TB0CCR1 = PWM_DUTY(val); // PWM duty cycle + TB0CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; + case T0B2: // TimerB0 / CCR1 + TB0CCR0 = PWM_PERIOD; // PWM Period + TB0CCTL2 = OUTMOD_7; // reset/set + TB0CCR2 = PWM_DUTY(val); // PWM duty cycle + TB0CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif +#if defined(__MSP430_HAS_T1B3__) + //case: T1B0 // CCR0 used as period register + case T1B1: // TimerB0 / CCR1 + TB1CCR0 = PWM_PERIOD; // PWM Period + TB1CCTL1 = OUTMOD_7; // reset/set + TB1CCR1 = PWM_DUTY(val); // PWM duty cycle + TB1CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; + case T1B2: // TimerB0 / CCR1 + TB1CCR0 = PWM_PERIOD; // PWM Period + TB1CCTL2 = OUTMOD_7; // reset/set + TB1CCR2 = PWM_DUTY(val); // PWM duty cycle + TB1CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif +#if defined(__MSP430_HAS_T2B3__) + //case: T1B0 // CCR0 used as period register + case T2B1: // TimerB0 / CCR1 + TB2CCR0 = PWM_PERIOD; // PWM Period + TB2CCTL1 = OUTMOD_7; // reset/set + TB2CCR1 = PWM_DUTY(val); // PWM duty cycle + TB2CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; + case T2B2: // TimerB0 / CCR1 + TB2CCR0 = PWM_PERIOD; // PWM Period + TB2CCTL2 = OUTMOD_7; // reset/set + TB2CCR2 = PWM_DUTY(val); // PWM duty cycle + TB2CTL = TBSSEL_2 + MC_1+ analog_div; // SMCLK, up mode + break; +#endif + + case NOT_ON_TIMER: // not on a timer output pin + default: // or TxA0 pin + if (val <= (analog_res >> 1)) { + digitalWrite(pin, LOW); // + } else { + digitalWrite(pin, HIGH); + } + } + } +} + +uint16_t analogRead(uint8_t pin) +{ +// make sure we have an ADC +#if defined(__MSP430_HAS_ADC10__) || defined(__MSP430_HAS_ADC10_B__) + // 0000 A0 + // 0001 A1 + // 0010 A2 + // 0011 A3 + // 0100 A4 + // 0101 A5 + // 0110 A6 + // 0111 A7 + // 1010 Internal temperature sensor + + //TODO: Only int. temp. sensor requires Tsample > 30us. + // The below ADC configuration applies this rule to all channels right now. + // ADC10CLK = 5MHz / 5 = 1Mhz + // Tsample = S&H / ADC10CLK = 64 / 1 MHz = 64 us + // Tconvert = 13 / ADC10CLK = 13 / 1 MHz = 13 us + // Total time per sample = Tconvert + Tsample = 64 + 13 = 67 us = ~15k samples / sec + + ADC10CTL0 &= ~ADC10ENC; // disable ADC + ADC10CTL1 = ADC10SSEL_0 | ADC10DIV_5; // ADC10OSC as ADC10CLK (~5MHz) / 5 +#if defined(__MSP430_HAS_ADC10__) + ADC10CTL0 = analog_reference | // set analog reference + ADC10ON | ADC10SHT_3 | ADC10IE; // turn ADC ON; sample + hold @ 64 × ADC10CLKs; Enable interrupts + ADC10CTL1 |= (pin << 12); // select channel + ADC10AE0 = (1 << pin); // Disable input/output buffer on pin +#endif +#if defined(__MSP430_HAS_ADC10_B__) + while(REFCTL0 & REFGENBUSY); // If ref generator busy, WAIT + REFCTL0 |= analog_reference & REF_MASK; // Set reference using masking off the SREF bits. See Energia.h. + ADC10MCTL0 = pin | (analog_reference & REFV_MASK); // set channel and reference + ADC10CTL0 = ADC10ON | ADC10SHT_4; // turn ADC ON; sample + hold @ 64 × ADC10CLKs + ADC10CTL1 |= ADC10SHP; // ADCCLK = MODOSC; sampling timer + ADC10CTL2 |= ADC10RES; // 10-bit resolution + ADC10IFG = 0; // Clear Flags + ADC10IE |= ADC10IE0; // Enable interrupts +#endif + __delay_cycles(128); // Delay to allow Ref to settle + ADC10CTL0 |= ADC10ENC | ADC10SC; // enable ADC and start conversion + while (ADC10CTL1 & ADC10BUSY) { // sleep and wait for completion + __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled + } + +#if defined(__MSP430_HAS_ADC10__) + /* POWER: Turn ADC and reference voltage off to conserve power */ + ADC10CTL0 &= ~(ADC10ON | REFON); +#endif + +#if defined(__MSP430_HAS_ADC10_B__) + /* POWER: Turn ADC and reference voltage off to conserve power */ + ADC10CTL0 &= ~(ADC10ON); + REFCTL0 &= ~REFON; +#endif + return ADC10MEM0; // return sampled value after returning to active mode in ADC10_ISR +#else + // no ADC + return 0; +#endif +} + +__attribute__((interrupt(ADC10_VECTOR))) +void ADC10_ISR(void) +{ +#if defined(__MSP430_HAS_ADC10) + __bic_SR_register_on_exit(CPUOFF); // return to active mode +#endif + +#if defined(__MSP430_HAS_ADC10_B__) + + switch(ADC10IV,12) { + case 0: break; // No interrupt + case 2: break; // conversion result overflow + case 4: break; // conversion time overflow + case 6: break; // ADC10HI + case 8: break; // ADC10LO + case 10: break; // ADC10IN + case 12: + __bic_SR_register_on_exit(CPUOFF); // return to active mode + break; // Clear CPUOFF bit from 0(SR) + default: break; + } + + ADC10IFG = 0; // Clear Flags +#endif +} diff --git a/lib/msp430/wiring_digital.c b/lib/msp430/wiring_digital.c new file mode 100644 index 0000000..cf851b3 --- /dev/null +++ b/lib/msp430/wiring_digital.c @@ -0,0 +1,181 @@ +/* + ************************************************************************ + * HardwareSerial.cpp + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring_digital.c - digital input and output functions + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA +*/ + +#define ARDUINO_MAIN +#include "wiring_private.h" +#include "pins_energia.h" + +void pinMode(uint8_t pin, uint8_t mode) +{ + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + + volatile uint8_t *dir; + volatile uint8_t *ren; + volatile uint8_t *out; + + if (port == NOT_A_PORT) return; + + dir = portDirRegister(port); + ren = portRenRegister(port); + out = portOutputRegister(port); + + if (mode == INPUT) { + *dir &= ~bit; + } else if (mode == INPUT_PULLUP) { + *dir &= ~bit; + *out |= bit; + *ren |= bit; + } else if (mode == INPUT_PULLDOWN) { + *dir &= ~bit; + *out &= ~bit; + *ren |= bit; + } else { + *dir |= bit; + } +} + +void pinMode_int(uint8_t pin, uint8_t mode) +{ + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + + volatile uint8_t *dir; + volatile uint8_t *ren; + volatile uint8_t *out; + volatile uint8_t *sel; + + if (port == NOT_A_PORT) return; + + dir = portDirRegister(port); + ren = portRenRegister(port); + out = portOutputRegister(port); + + if (mode & OUTPUT) { + *dir |= bit; + } else { + *dir &= ~bit; + if (mode & INPUT_PULLUP) { + *out |= bit; + *ren |= bit; + } else if (mode & INPUT_PULLDOWN) { + *out &= ~bit; + *ren |= bit; + } + } + + #if (defined(P1SEL_) || defined(P1SEL)) + sel = portSel0Register(port); /* get the port function select register address */ + if (mode & PORT_SELECTION0) { + *sel |= bit; + } else { + *sel &= ~bit; + } + #if (defined(P1SEL2_) || defined(P1SEL2)) + sel = portSel2Register(port); /* get the port function select register address */ + if (mode & PORT_SELECTION1) { + *sel |= bit; + } else { + *sel &= ~bit; + } + #endif + #endif + + #if (defined(P1SEL0_) || defined(P1SEL0)) + sel = portSel0Register(port); /* get the port function select register address */ + if (mode & PORT_SELECTION0) { + *sel |= bit; + } else { + *sel &= ~bit; + } + #if (defined(P1SEL1_) || defined(P1SEL1)) + sel = portSel1Register(port); /* get the port function select register address */ + if (mode & PORT_SELECTION1) { + *sel |= bit; + } else { + *sel &= ~bit; + } + #endif + #endif + +} + +int digitalRead(uint8_t pin) +{ + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + + if (port == NOT_A_PORT) return LOW; + + if (*portInputRegister(port) & bit) return HIGH; + return LOW; +} + +void digitalWrite(uint8_t pin, uint8_t val) +{ + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + volatile uint8_t *out; + volatile uint8_t *sel; + + if (port == NOT_A_PORT) return; + + /* + * Clear bit in PxSEL register to select GPIO function. Other functions like analogWrite(...) + * will set this bit so need to clear it. + */ + #if (defined(P1SEL_) || defined(P1SEL)) + sel = portSel0Register(port); /* get the port function select register address */ + *sel &= ~bit; /* clear bit in pin function select register */ + #if (defined(P1SEL2_) || defined(P1SEL2)) + sel = portSel2Register(port); /* get the port function select register address */ + *sel &= ~bit; /* clear bit in pin function select register */ + #endif + #endif + + #if (defined(P1SEL0_) || defined(P1SEL0)) + sel = portSel0Register(port); /* get the port function select register address */ + *sel &= ~bit; /* clear bit in pin function select register */ + #if (defined(P1SEL1_) || defined(P1SEL1)) + sel = portSel1Register(port); /* get the port function select register address */ + *sel &= ~bit; /* clear bit in pin function select register */ + #endif + #endif + + + out = portOutputRegister(port); + + if (val == LOW) { + *out &= ~bit; + } else { + *out |= bit; + } +} diff --git a/lib/msp430/wiring_private.h b/lib/msp430/wiring_private.h new file mode 100644 index 0000000..9ed8c6f --- /dev/null +++ b/lib/msp430/wiring_private.h @@ -0,0 +1,60 @@ +/* + ************************************************************************ + * wiring_private.h + * + * Arduino core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring_private.h - Internal header file. + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id: wiring.h 239 2007-01-12 17:58:39Z mellis $ +*/ + +#ifndef WiringPrivate_h +#define WiringPrivate_h + +#include "Energia.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +// TODO: This is a hack and needs cleaning up. Not all pins are available on the board +//.Change this to a more intelligent number of interrupt selection + +#if defined(__MSP430_HAS_PORT1_R__) +#define EXTERNAL_NUM_INTERRUPTS 8 +#elif defined(__MSP430_HAS_PORT2_R__) +#define EXTERNAL_NUM_INTERRUPTS 16 +#else +#define EXTERNAL_NUM_INTERRUPTS 8 +#endif + +typedef void (*voidFuncPtr)(void); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/lib/msp430/wiring_pulse.c b/lib/msp430/wiring_pulse.c new file mode 100755 index 0000000..6375717 --- /dev/null +++ b/lib/msp430/wiring_pulse.c @@ -0,0 +1,76 @@ +/* + ************************************************************************ + * wiring_pulse.c + * + * Energia core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring_pulse.c - pulseIn() function + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA +*/ + +#include "wiring_private.h" +#include "pins_energia.h" + +/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH + * or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds + * to 3 minutes in length, but must be called at least a few dozen microseconds + * before the start of the pulse. */ +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout) +{ + // cache the port and bit of the pin in order to speed up the + // pulse width measuring loop and achieve finer resolution. calling + // digitalRead() instead yields much coarser resolution. + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + uint8_t stateMask = (state ? bit : 0); + unsigned long width = 0; // keep initialization out of time critical area + + // convert the timeout from microseconds to a number of times through + // the initial loop; it takes 11 clock cycles per iteration. + unsigned long numloops = 0; + unsigned long maxloops = microsecondsToClockCycles(timeout) / 11; + + // wait for any previous pulse to end + while ((*portInputRegister(port) & bit) == stateMask) + if (numloops++ == maxloops) + return 0; + + // wait for the pulse to start + while ((*portInputRegister(port) & bit) != stateMask) + if (numloops++ == maxloops) + return 0; + + // wait for the pulse to stop + while ((*portInputRegister(port) & bit) == stateMask) { + if (numloops++ == maxloops) + return 0; + width++; + } + + // convert the reading to microseconds. The loop has been determined + // to be 13 clock cycles long and have about 11 clocks between the edge + // and the start of the loop. There will be some error introduced by + // the interrupt handlers. + return clockCyclesToMicroseconds(width * 13 + 11); +} diff --git a/lib/msp430/wiring_shift.c b/lib/msp430/wiring_shift.c new file mode 100755 index 0000000..30d2b56 --- /dev/null +++ b/lib/msp430/wiring_shift.c @@ -0,0 +1,63 @@ +/* + ************************************************************************ + * wiring_shift.c + * + * Energia core files for MSP430 + * Copyright (c) 2012 Robert Wessels. All right reserved. + * + * + *********************************************************************** + Derived from: + wiring_shift.c - shiftOut() function + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library 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 library 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 library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + +*/ + +#include "wiring_private.h" + +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) { + uint8_t value = 0; + uint8_t i; + + for (i = 0; i < 8; ++i) { + digitalWrite(clockPin, HIGH); + if (bitOrder == LSBFIRST) + value |= digitalRead(dataPin) << i; + else + value |= digitalRead(dataPin) << (7 - i); + digitalWrite(clockPin, LOW); + } + return value; +} + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val) +{ + uint8_t i; + + for (i = 0; i < 8; i++) { + if (bitOrder == LSBFIRST) + digitalWrite(dataPin, !!(val & (1 << i))); + else + digitalWrite(dataPin, !!(val & (1 << (7 - i)))); + + digitalWrite(clockPin, HIGH); + digitalWrite(clockPin, LOW); + } +} -- cgit v1.2.3-24-g4f1b