Skip to content

Instantly share code, notes, and snippets.

/SIMPLEX_1.ino

Created March 6, 2016 19:31
Show Gist options
  • Save anonymous/a2c5381c466760008a65 to your computer and use it in GitHub Desktop.
Save anonymous/a2c5381c466760008a65 to your computer and use it in GitHub Desktop.
Download ZIP
SIMPL Interpreter for MSP430 Launchpad with external 32Kx8 SPI RAM - inspired by an original idea by Ward Cunningham & Rick Kimball
Raw
SIMPLEX_1.ino
// SIMPLEX 1
// SIMPL Interpreter for MSP430 Launchpad - inspired by an original idea by Ward Cunningham
// A minimal 868 byte Txtzyme for MSP430 Launchpad with MSP430G2533
// Add in SIMPL framework - to allow construction and use of user defined words - increases to 1084 bytes
// This version adds 23K256 32Kx8 external SPI RAM, plus hex-dump utlity - codesize is now 3000 bytes
// An on going Neo-Retro Computing Mission!
// Ken Boak 2013 - 2016
// This version for entry level MSP430 with MSP430G2553 compiled using Energia
// Note - serial uart on P1.1 and P1.2 is running at odd-baud of 100,000 bits/s - to be investigated
#define RXD BIT1 // Receive Data (RXD) at P1.1
#define TXD BIT2 // Transmit Data (TXD) at P1.2
#define RED 0x20 // Red LED is on Bit 6
#define GREEN 0x01 // Green LED is on Bit 0
#define POWER_PIN BIT0 // we power the 23K256 chip from one of our GPIO pins
#define SS_PIN BIT4 // CS , active low
#define DEBUG_PIN BIT0 // toggle on and off marking time to write
#define DUMMY_BYTE 0xFF // byte we send when we just want to read slave data
#define bufRead(addr) (*(unsigned char *)(addr))
#define bufWrite(addr, b) (*(unsigned char *)(addr) = (b))
#define bit0 0x01 // 1
#define bit1 0x02 // 2
#define bit2 0x04 // 4
#define bit3 0x08 // 8
#define bit4 0x10 // 16
#define bit5 0x20 // 32
#define bit6 0x40 // 64
#define bit7 0x80 // 128
static inline uint8_t RWData(uint8_t value);
void loop();
#define powerOn P1OUT |= POWER_PIN
#define powerOff P1OUT &= ~POWER_PIN
#define ssSelect P1OUT &= ~SS_PIN
#define ssDeselect P1OUT |= SS_PIN
#define delay_1ms __delay_cycles(16000)
#define SR_WRITE_STATUS 0x01
#define SR_WRITE 0x02
#define SR_READ 0x03
#define SR_READ_STATUS 0x05
#define BYTES_TO_STREAM 1024 // should be less <= 32768
#define PATTERN_BYTE_VALUE 65
int spi_rx_data = 0 ;
//--------------------------------------------------------------------------------
// 23K256 Serial Ram functions
uint8_t SR_getMode(void) { // Read the Mode of the 23K256
ssSelect; // select
RWData(SR_READ_STATUS); // 0x05
uint8_t mode = RWData(DUMMY_BYTE);
ssDeselect; // de-select
return mode;
}
void SR_setMode(uint8_t mode) { // Write Mode to 23K256
ssSelect;
RWData(SR_WRITE_STATUS); // 0x01
RWData(mode);
ssDeselect;
}
static inline void SR_writestream(uint16_t addr) { // Write a stream to 23K256
ssDeselect; // deselect if we are active
ssSelect;
RWData(0x02); // Send command
RWData(addr >> 8); // Send upper address
RWData(addr); // Send lower address
}
static inline void SR_readstream(uint16_t addr) { // Read a stream from 23K256
ssDeselect;
ssSelect;
RWData(0x03); // Send command
RWData(addr >> 8); // Send upper address
RWData(addr); // Send lower address
}
//-----------------------------------------------------------------
// SPI Send / Receive
static inline uint8_t RWData(uint8_t value)
{
UCB0TXBUF = value;
while (!(IFG2 & UCB0TXIFG)); // wait for buffer ready
{ }
while (!(IFG2 & UCB0RXIFG)); // USCI_A0 RX Received?
spi_rx_data = UCB0RXBUF; // Store received data
return spi_rx_data;
}
//-----------------------------------------------------------------
// This character array is used to hold the User's words
char array[4][48]; // Allocate a storage array in memory
/*
= { // Define a 26 x 48 array for the colon definitions
{"6d40{h1106ul1106u}"}, // Musical tones A - G
{"6d45{h986ul986u}"},
{"6d51{h929ul929u}"},
{"6d57{h825ul825u}"},
{"6d64{h733ul733u}"},
{"6d72{h690ul691u}"},
{"6d81{h613ul613u}"},
{"_Hello World, and welcome to SIMPL_"},
{"5{ABC}"},
{""},
{""},
{""},
{"_This is a test message - about 48 characters_"}
};
*/
int a = 0; // integer variables a,b,c,d
int b = 0;
int c = 0;
int d = 6; // d is used to denote the digital port pin for I/O operations
unsigned long x = 0; // Three gen purpose variables for stack & math operations
unsigned long y = 0;
unsigned int z = 0;
unsigned int ADC_value=0;
int hex_value = 0;
int dec_value = 0;
int decimal_value = 0;
char ha = 0;
char hex_char;
unsigned char in_byte;
int len = 32; // the max length of a User word
int length = 0; // number of bytes to red/write to SRAM
int address = 0 ; // starting address of RAM R/W streamms
int RAM_byte =0; // contents of RAM at given location
long old_millis=0;
long new_millis=0;
char name;
char* parray;
char buf[64];
char* addr;
unsigned int num = 0;
unsigned int num_val = 0;
int j;
char num_buf[11]; // long enough to hold a 32 bit long
char block_array[33];
int decade = 0;
char digit = 0;
//------------------------------------------------------------------------------------
// UART Routines
void uart_init(void)
{
P1SEL = RXD + TXD;
P1SEL2 = RXD + TXD;
UCA0CTL1 |= UCSSEL_2; // SMCLK
UCA0BR0 = 156; // 1MHz 9600
UCA0BR1 = 0; // 1MHz 9600
UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1
UCA0CTL1 &= ~UCSWRST; // Initialize USCI state machine
}
void spi_init(void)
{
//----------------------------------------------------------------------------
// Configure the Clock for 16 MHz
BCSCTL1 = CALBC1_16MHZ;
DCOCTL = CALDCO_16MHZ;
//---------------------------------------------------------------------
// recommended procedure: set UCSWRST, configure USCI, configure ports, activate
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// Set UCSWRST
UCB0CTL1 = UCSWRST;
//---------------------------------------------------------------------
// Configure USCI B0
UCB0CTL0 |= UCCKPH + UCMSB + UCMST + UCSYNC; // 3-pin, 8-bit SPI master
UCB0CTL1 |= UCSSEL_2; // SMCLK
UCB0BR0 |= 2; // 8 MHz SPI-CLK
UCB0BR1 = 0;
//UCB0MCTL = 0;
//---------------------------------------------------------------------
// Configure Ports
P1SEL |= BIT5 + BIT6 + BIT7;
P1SEL2 |= BIT5 + BIT6 + BIT7;
P1DIR |= BIT0 + BIT4 + BIT5 | BIT7;
//---------------------------------------------------------------------
// activate
UCB0CTL1 &= ~UCSWRST;
}
unsigned char uart_getc()
{
while (!(IFG2&UCA0RXIFG)); // USCI_A0 RX buffer ready?
return UCA0RXBUF;
}
void uart_putc(unsigned char c)
{
while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready?
UCA0TXBUF = c; // TX
}
void uart_puts(const char *str) // Output a string
{
while(*str) uart_putc(*str++);
}
// Print a 16 bit long int number
static void printlong(unsigned long num)
{
if (num / (unsigned short)10 != 0) printlong(num / (unsigned short)10);
uart_putc((char)(num % (unsigned short)10) + '0');
return;
}
// Print a CR-LF
void crlf(void) // send a crlf
{
uart_putc(10);
uart_putc(13);
}
//-------------------------------------------------------------------------------------
// ADC Configuration
// Function containing ADC set-up
void ConfigureAdc(void)
{
ADC10CTL1 = INCH_3 + ADC10DIV_3 ; // Channel 3, ADC10CLK/3
ADC10CTL0 = SREF_0 + ADC10SHT_3 + ADC10ON + ADC10IE; // Vcc & Vss as reference, Sample and hold for 64 Clock cycles, ADC on, ADC interrupt enable
ADC10AE0 |= BIT3; // ADC input enable P1.3
}
int ADC_Read(void)
{
ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start
ADC_value = ADC10MEM;
return ADC_value;
}
//-------------------------------------------------------------------------------------
void delay_mS(int j){
volatile unsigned long i;
while(j)
{
i = 42; // Delay
do (i--);
while (i != 0); // busy waiting (bad)
j--;
}
}
//---------------------------------------------------------------------------------
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
// BCSCTL1 = CALBC1_1MHZ; // Set DCO
// DCOCTL = CALDCO_1MHZ;
P1DIR = BIT0 + BIT6; // P1.0 and P1.6 are the red+green LEDs
P1OUT = BIT0 + BIT6; // All LEDs off
uart_init(); // Initialise the UART for 96000 baud
spi_init();
uart_puts((char *)"MSP430 SIMPLEX\n\r"); // send banner message
spi_check(); // Make sure SPI RAM is connected and in the correct streaming mode
P1SEL |= BIT3; // ADC input pin P1.3
ConfigureAdc();
parray = &array[0][0]; // parray is the pointer to the first element
//-------------------------------------------------------------------------------
while(1)
{
textRead(buf, 64); // This is the endless while loop which implements the interpreter - just 3 simple functions
textChk(buf); // check if it is a : character for beginning a colon definition
textEval(buf);
//----------------------------------------------------------------------------
}
} // End of main
//-------------------------------------------------------------------------------
// Language Functions - Words
// ------------------------------------------------------------------------------
// Read the character into the buffer
void textRead (char *p, byte n) {
byte i = 0;
while (i < (n-1)) {
char ch = uart_getc();
if (ch == '\r' || ch == '\n') break;
if (ch >= ' ' && ch <= '~') {
*p++ = ch;
i++;
}
}
*p = 0;
}
// ---------------------------------------------------------------------------------------------------------
void textChk (char *buf) // Check if the text starts with a colon and if so store in user's word RAM array parray[]
{
if (*buf == ':') {
char ch;
int i =0;
while ((ch = *buf++)){
if (ch == ':') {
uart_putc(*buf); // get the name from the first character
uart_putc(10);
uart_putc(13);
name = *buf ;
buf++;
}
bufWrite((parray + (len*(name-65) +i)),*buf);
i++;
}
x = 1;
}
}
// ---------------------------------------------------------------------------------------------------------
void textEval (char *buf) {
char *loop;
char *start;
char ch;
unsigned long k = 0;
while ((ch = *buf++)) { // Is it a number?
switch (ch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
x = ch - '0';
while (*buf >= '0' && *buf <= '9') {
x = x*10 + (*buf++ - '0'); // If a number store it in "x"
}
break;
//-------------------------------------------------------------------------------
// User Words (A-H hijacked for SPI RAM extensions)
case 'I': // Point the interpreter to the array containing the words
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
textEval(parray + (len*(ch-65))); // Evaluate and execute the User's expression fo RAM
break;
//---------------------------------------------------------------------------------
// Primitive and User vocabulary defined in this section
// (A-H hijacked for SPI RAM extensions - SIMPLE!)
case 'A': // Address
break;
case 'B': // Block
break;
case 'C': // Compile
hex_print_2(x);
break;
case 'D': // Dump
dump(y,x); // dump y bytes starting at address x
break;
case 'E': // Execute
break;
case 'F': // File // fill y bytes starting at address x with test data
spi_fill(y,x);
print_ok();
break;
case 'G': // Go
break;
case 'H': // HEX Dump - dump x bytes starting at address y
hex_dump(y,x);
print_ok();
break;
//--------------------------------------------------------------------------------
// Timing & Printing Group
case 'p':
printlong(x);
break;
case 'q': // print integer with crlf
printlong(x);
crlf();
break;
case 'b':
// printlong(millis());
crlf();
break;
case 'c':
// printlong(micros());
crlf();
break;
case 'd':
d = x;
break;
case '_': // Print the string enclosed between underscores _Hello_
while ((ch = *buf++) && ch != '_') {
uart_putc(ch);
}
uart_putc(10);
break;
//----------------------------------------------------------
// Arithmetic Group
case '+':
x = x+y;
break;
case '-':
x = x-y;
break;
case '*':
// x = x*y;
break;
case '/':
// x = x/y;
break;
case '%':
// x = x%y;
break;
case 'x':
x = x + 1;
break;
case 'y':
y = y + 1;
break;
//--------------------------------------------------------------------
// Logical Group - provides bitwise logical function between x and y
case '&':
x = x&y; // Logical AND
break;
case '|':
x = x|y; // Logical OR
break;
case '^':
x = x^y; // Logical XOR
break;
case '~':
x = !x; // Complement x
break;
case ' ': // Transfer x into second variable y
k=y; // Transfer loop counter into k
y= x;
break;
case '#': // Load x with the ASCII value of the next character i.e. 5 = 35H or 53 decimal
x=*(buf-2);
break;
case '$':
if(x<=255) {hex_print_2(x); break;}
hex_print_4(x);
break;
// ----------------------------------------------------------------------
// Memory Group
case '!': // store
y = x;
break;
case '@': // Fetch
x = y;
break;
/*
case 'r': // read a byte from RAM
bite = bufRead(x); // x = address
x = bite;
uart_putc(x); // print the character
break;
case 'q': // read a block of x bytes of RAM at address y
for (int i=0; i<x; i++) {
bite = bufRead(y+i); // read the array
uart_putc(bite); // print the character to the serial port
}
break;
case 'w': // write a byte to RAM address in y, data in x
bufWrite(y,x);
break;
*/
//--------------------------------------------------------------------
// Comparison Test and conditional Group
case '<':
if(x<y){x=1;} // If x<y x= 1 - can be combined with jump j
else x=0;
break;
case '>':
if(x>y){x=1;} // If x>y x= 1 - can be combined with jump j
else x=0;
break;
case 'j': // test if x = 1 and jump next instruction
if(x==1){*buf++;}
break;
//----------------------------------------------------------------------------------
// Print out the current word list
case '?': // Print out all the RAM
parray = &array[0][0]; // reset parray to the pointer to the first element
for (int j = 0; j<26; j++) {
uart_putc(j+65); // print the caps word name
uart_putc(32); // space
for (int i=0; i<len; i++) {
in_byte = bufRead( parray + (j *len )+i); // read the array
uart_putc(in_byte); // print the character to the serial port
}
crlf();
}
for(int i = 0; i <11; i++) // add some spaces to make it more legible on the page
{
crlf();
}
break;
//----------------------------------------------------------------------------------------------------
// Conditional Code branch
case '[': // The start of a condition test
k = x;
start = buf; // remember the start position of the test
while ((ch = *buf++) && ch != ']') { // get the next character into ch and increment the buffer pointer *buf - evaluate the code
}
case ']':
if (x) { // if x is positive - go around again
buf = start;
}
break;
//--------------------------------------------------------------------------
// Case Statement Selection
// Select some code from a list separated by commas
//5(0p,1p,2p,3p,4p,5p,6p) should select 5 and print it
case '(':
k = x; // copy x to use as the "phrase counter"
// decrement k to see whether to interpret or not
while (k)
{
ch = *buf++;
if (ch == ',')
{ k--;}
}
break;
case ',':
k--; //
while (k<0) // k < 0 so skip the remaining entries in the list
{
ch = *buf++; // skip the remaining characters
if (ch == ')') {break;}
}
break;
//-----------------------------------------------------------------------------------------------------------------------------------------------
// Analogue and Digital Input and Output Group - these add heavily to total - need to be converted to MSP430
case 's':
x = ADC_Read(); // Adds 38 bytes
break;
/*
case 'a':
analogWrite(d,x); // adds 340 bytes
break;
case 'i':
x = digitalRead(d); // adds 100 bytes
break;
case 'o':
digitalWrite(d, x%2); // adds 18 bytes
break;
*/
//-------------------------------------------------------------------
// Delays Group
case 'm':
delay_mS(x);
break;
case 'u':
// delayMicroseconds(x);
break;
//---------------------------------------------------------------------
case '{':
k = x;
loop = buf;
while ((ch = *buf++) && ch != '}') {
}
case '}':
if (k) {
k--;
buf = loop;
}
break;
case 'k':
x = k;
break;
// -----------------------------------------------------------------------------
// Launchpad LED group support for red and green LEDs on entry level LaunchPad
case 'w':
{
P1OUT |= BIT0;
}
break;
case 'r':
{
P1OUT &= ~BIT0;
}
break;
case 'h':
{
P1OUT |= BIT6;
}
break;
case 'l':
{
P1OUT &= ~BIT6;
}
break;
// ----------------------------------------------------------------------
}
}
}
//-----------------------------------------------------------------------------
// SPI RAM Extensions to SIMPL Test routines etc
//---------------------------------------------------------------------
char RAM_stream_mode()
{
ssDeselect;
delay_1ms;
uint8_t chipMode;
chipMode = SR_getMode(); // check status register for sequential mode
if (chipMode != 0x41) {
SR_setMode(0x41);
return 0;
}
return 1;
}
int spi_check()
{
// toggle the power for the 23K256
// powerOn;
ssDeselect;
delay_1ms;
uint8_t chipMode;
// make sure there is a 23K256 chip and that
// is wired properly and in sequential mode
chipMode = SR_getMode();
if (chipMode != 0x41) {
SR_setMode(0x41);
uart_puts((char *)"SPI RAM not found\n\r");
}
else
{
uart_puts((char *)"SPI RAM Connected!\n\r");
}
}
// -----------------------------------------------------------------------------
//spi_fill()- fill the RAM from address with length characters
// -----------------------------------------------------------------------------
void spi_fill(int address, int length ) // fill
{
uint16_t i;
uint8_t storedValue = 0;
RAM_stream_mode();
// P1OUT |= DEBUG_PIN; // mark start of write for measurement with oscope
SR_writestream(address); // start writing at address 0
for (i = 0; i < length; ++i) {
storedValue = (i/64)+65;
// if(i%64 == 0)
// {storedValue = 0x0A;}
RWData(storedValue);
}
}
// -----------------------------------------------------------------------------
// dump the characters from RAM to screen - putting a newline every 64 bytes
// -----------------------------------------------------------------------------
void dump(int address, int length)
{
int i =0;
uart_putc(0x0D); // Start with a newline!
uart_putc(0x0A);
RAM_stream_mode();
SR_readstream(address); // start reading at address 0
for (i = 0; i < length ; ++i)
{
if(i%32 == 0)
{
uart_putc(0x0D); // put a newline every 32 chars
uart_putc(0x0A);
printlong(i+ address); // print the line address followed by four spaces
uart_putc(0x20);
uart_putc(0x20);
uart_putc(0x20);
uart_putc(0x20);
}
RAM_byte = RWData(DUMMY_BYTE);
if(RAM_byte <= 31) {RAM_byte = '.';} // Make it a full stop for unprintable characters
uart_putc(RAM_byte);
}
}
//--------------------------------------------------------------------------------------------
// Generate a familiar hex dump of the RAM area
void hex_dump(int address, int length)
{
uart_putc(0x0D); // Start with a newline!
uart_putc(0x0A);
int i =0;
SR_readstream(address); // start reading at address 0
for (j = address >>5; j <= (address +length)>> 5 ; ++j)
{
for (i = 0; i < 32 ; ++i)
{
if(i== 0)
{
// printlong(j*32); // print the line address followed by four spaces
hex_print_4(j<<5); // print the line address as HEX followed by 2 spaces
uart_putc(0x20);
uart_putc(0x20);
}
RAM_byte = RWData(DUMMY_BYTE); // Now read and print the data as numbers
// printlong(RAM_byte);
hex_print_2(RAM_byte);
block_array[i] = RAM_byte;
uart_putc(0x20); // followed by a space
}
uart_putc(0x20); // Separate columns with 3 spaces
uart_putc(0x20);
uart_putc(0x20);
for (i = 0; i < 32 ; ++i) // start reading back at address 0 so as to print the characters
{
RAM_byte = block_array[i];
if(RAM_byte <= 31 || RAM_byte >= 127) {RAM_byte = '.';} // Make it a full stop for unprintable characters
uart_putc(RAM_byte);
if(i>=31) // put a newline every 32 chars
{
uart_putc(0x0D);
uart_putc(0x0A);
}
}
}
}
//-----------------------------------------------------------------
// Convert a char into a 2 character hex pair
void hex_print_2(int dec_value)
{
ha = dec_value >> 4;
hex_print_char(ha);
ha = dec_value - (ha << 4);
hex_print_char(ha);
}
//-----------------------------------------------------------------
// Convert an into into a 4 character hex pair
// note all binary mults and divs should use shift ops for efficiency
void hex_print_4(unsigned int decimal_value)
{
int div_value = decimal_value >> 8;
hex_print_2(div_value);
/*
ha = dec_value >> 12;
hex_print_char(ha);
dec_value = dec_value - (ha << 12);
ha = dec_value >> 8;
hex_print_char(ha);
dec_value = dec_value - (ha << 8);
*/
dec_value = decimal_value - (ha << 8);
hex_print_2(dec_value);
uart_putc(32); // put a space
}
void hex_print_char(char hex_value)
{
if (ha <=9){hex_char = '0' + ha ;}
if (ha == 10) {hex_char = 'A';}
if (ha == 11) {hex_char = 'B';}
if (ha == 12) {hex_char = 'C';}
if (ha == 13) {hex_char = 'D';}
if (ha == 14) {hex_char = 'E';}
if (ha == 15) {hex_char = 'F';}
uart_putc(hex_char);
}
void print_ok()
{
uart_puts((char *)"OK\n\r");
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment