Merge pull request energia#54 from energia/issue_53

Added flash controller driver library and example. Fix for issue energia#53 (tone)

Author: pbrier

hardware/msp430/cores/msp430/Energia.h

@@ -127,6 +127,7 @@ extern const uint8_t digital_pin_to_bit_mask[];
 extern const uint16_t port_to_sel[];
 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] )

hardware/msp430/cores/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 uint16_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 = TAR + tone_interval[0];  
+      TA0CCTL0 = CCIE;       
+      break;
+    case 1:
+      if ( !(TA0CCTL1 & CCIE) ) TA0CCR1 = TAR + tone_interval[1]; 
+      TA0CCTL1 = CCIE; 
+      break;
+#ifdef __MSP430_HAS_TA3__
+    case 2:
+      if ( !(TA0CCTL2 & CCIE) ) TA0CCR2 = TAR + 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 ( TAIV ) 
+  { 
+    case 0x2: isrTimer(1, TA0CCR1); break; // CCR1
+#ifdef __MSP430_HAS_TA3__
+    case 0x4: isrTimer(2, TA0CCR2); break; // CCR2
+#endif
+  }  
+}

hardware/msp430/libraries/MspFlash/MspFlash.cpp

@@ -0,0 +1,59 @@
+/*
+  MspFlash.h - Read/Write flash memory library for MSP430 Energia 
+  Copyright (c) 2012 Peter Brier.  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 "MspFlash.h"
+#include <msp430.h>
+
+// The Flash clock must be between 200 and 400 kHz to operate correctly
+// TODO: calculate correct devider (0..64) depending on clock frequenct (F_CPU)
+// Now we set F_CPU/64 is 250khz at F_CPU = 16MHz
+
+#define FLASHCLOCK FSSEL1+((F_CPU/400000L) & 63); // SCLK
+
+// erase flash, make sure pointer is in the segment you wish to erase, otherwise you may erase you program or some data
+void MspFlashClass::erase(unsigned char *flash)
+{
+  WDTCTL = WDTPW+WDTHOLD;   // Disable WDT
+  FCTL2 = FWKEY+FLASHCLOCK; // SMCLK/2
+  FCTL3 = FWKEY;            // Clear LOCK
+  FCTL1 = FWKEY+ERASE;      //Enable segment erase
+  *flash = 0;               // Dummy write, erase Segment
+  FCTL3 = FWKEY+LOCK;       // Done, set LOCK
+}
+
+// load from memory, at segment boundary
+void MspFlashClass::read(unsigned char *flash, unsigned char *dest, int len)
+{
+  while(len--)
+   *(dest++) = *(flash++); 
+}
+
+// save in to flash (at segment boundary)
+void MspFlashClass::write(unsigned char *flash, unsigned char *src, int len)
+{
+ WDTCTL = WDTPW+WDTHOLD;   // Disable WDT
+ FCTL2 = FWKEY+FLASHCLOCK; // SMCLK/2 
+ FCTL3 = FWKEY;            // Clear LOCK
+ FCTL1 = FWKEY+WRT;        // Enable write
+ while(len--)      // Copy data
+   *(flash++) = *(src++);
+ FCTL1 = FWKEY;            //Done. Clear WRT
+ FCTL3 = FWKEY+LOCK;       // Set LOCK
+}
+
+MspFlashClass Flash;

hardware/msp430/libraries/MspFlash/MspFlash.h

@@ -0,0 +1,83 @@
+/*
+  MspFlash.h - Read/Write flash memory library for MSP430 Energia 
+  Copyright (c) 2012 Peter Brier.  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
+
+  Provide access to the MSP430 flash memory controller. 
+  All flash memory can be read, erased and written (except SEGMENT_A, the LOCK bits are not in the code, for a good reason).
+  Flash can only be erased per 512 byte segments (except the 4 special information segments, they are 64 bytes in size)
+  
+  The same flash locations can be written multiple times with new values, but flash bits can only be reset (from 1 to 0) and cannot
+  change to a 1 (you need to flash erase the whole segment)
+
+  functions:
+  ~~~~~~~~~~
+  erase():  Erase a flash segment, all bytes in the segment will read 0xFF after an erase
+ 
+  read(): Read flash locations (actually just a proxy for memcpy)
+ 
+  write(): Write flash locations (actually just a proxy for memcpy), the same location can be written multiple times, 
+  but once a bit is reset, you cannot set it with a subsequent write, you need to flash the complete segment to do so.  
+  
+  NOTE: you are flashing the program memory, you can modify EVERYTHING (program and data) this is usually not what you want. 
+  Be carefull when flashing data. You may use SEG_B to SEG_D for normal use, they should not be filled by the compiler with code
+  or static data. If you wish to use main memory without wasting any space, you need to inform the linker NOT to use the required 
+  segments. This is done in the linker script (this is not for the faint of heart). 
+  
+  An alternative approach is to allocate a static variable with a size of AT LEAST 2 SEGMENTS in your program. 
+  This makes sure there is at least ONE COMPLETE SEGMENT in this static variable, so there is no colleteral damage when you flash this
+  area. You need to find the pointer to the start of the next segment. There is a macro define to do this: SEGPTR(x)
+  A example that makes 2 segments available for flashing by allocating 3 segments of constant data:
+  
+  static const unsigned char flash[3*512] = {0};
+  
+  Flash segments:     |...SEGMENT-0...|...SEGMENT-1...|...SEGMENT-2...|...SEGMENT-3...|...SEGMENT-4...|...SEGMENT-5...|
+  Program output:     |Program code.......|flash[3*512***********************************]|Other data.................|
+  Available segments: |-------------------------------|+++++++++++++++|+++++++++++++++|-------------------------------|  
+  
+  
+*/
+
+#ifndef MSP_FLASH_h
+#define MSP_FLASH_h
+
+#define SEGMENT_SIZE 512 // main segment size (smallest flasheable area)
+#define INFO_SIZE 64 // information flah sizes (SEG_A to SEG_D)
+
+// segment addresses of 64 byte segments
+#define SEGMENT_D ((unsigned char*)0x1000)
+#define SEGMENT_C ((unsigned char*)0x1000+64)
+#define SEGMENT_B ((unsigned char*)0x1000+128)
+// #define SEGMENT_A ((unsigned char*)0x1000+192) // NOTE: Contains chip calibarion data, do not change or erase (the protection bit should prevent this happening)
+
+// Segment start addresses of 512 byte segments 0..63 (depending on device flash size)
+#define SEGMENT(x) ( (unsigned char*) 0xFFFF - (x)*SEG_SIZE )
+
+// return segment pointer inside variable. Note: return start of NEXT segment
+#define SEGPTR(x) ( (unsigned char *) (((unsigned short)(&x)+512) & 0xFE00) )
+
+class MspFlashClass
+{
+  public:
+    void erase(unsigned char *flash); 
+    void read(unsigned char *flash, unsigned char *dest, int len);
+    void write(unsigned char *flash, unsigned char *src, int len);
+};
+
+extern MspFlashClass Flash;
+
+#endif // MSP_FLASH_h
+