enrico::garante

Learning VHDL - Basics

noreply@blogger.com (Enrico Garante) — Wed, 18 Jan 2012 00:09:00 +0000

Today I start a new series of tutorials focused of FPGA and VHDL programming.
Since FPGA are becoming more accessible to the hobbyist, learning how to use them can be really useful for certain applications; moreover, engineers that are able to code in VHDL/Verilog are always requested on the job market.

In this tutorial I'll cover the basics of Xilinx ISE and VHDL.
I'll base my code on the Basys2 board from Digilent: it is really cheap (especially for students) and has a lot of features on board.
However, in this tutorial we'll only simulate our code with ISim, for the real applications check back soon!

Digilent's Basys2 board

So, let's start this thing. First I'll explain our test code, then I'll show you how to compile and simulate it in ISE Webpack.

VHDL is the acronym for VHSIC Hardware Description Language (where VHSIC stands for Very High Speed Integrated Circuits). It becomes an IEEE standard in 1987 and it is the most used language (along with Verilog) to describe digital electronic systems.

VHDL seems just like any other computer language, as it uses many common construct like if, then, else. But the main difference is that it is a dataflow language: this means that it describes how several blocks of code are connected and executed at the same time.
Each block of code describes a digital subsystem, with inputs and outputs.

VHDL programming consists of two phases:

ENTITY description: we state how the block is seen from outside (ports, buses, configurations...)
ARCHITECTURE description: we describe how the block works internally.

Enough theory already, let's see some code...
We start referencing the main VHDL library and using the STD_LOGIC_1164.ALL package, that contains several datatypes, logic operations and functions. This should probably be included in every entity you create.
Note that every instruction is terminated with the semicolon. To create a comment just use the # character.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
#This is a comment.

Then we define our "black box" with the "entity" statement followed by its name and the keyword "is".
The next statement "Port" describes how many "wires" are exposed to the outside; the list is composed this way: name : direction type. The last element of the list isn't terminated with the semicolon, but we need to terminate the Port statement.
The STD_LOGIC type is used to represent a digital value. It can assume several values like 0, 1, X (undefined), Z (high impedance) and may others.
Finally we end the definition of our entity with the "end" keyword.

entity AndPort is
    Port ( a : in  STD_LOGIC;
           b : in  STD_LOGIC;
           y : out  STD_LOGIC);
end AndPort;

Now we describe how our component works using the "architecture" statement, followed by its name and specifying to which entity it refers with the keyword "of".
The keyword begin and end will border our architecture statement.

architecture Behavioral of AndPort is

begin

The "process" statement is what actually describes the behavior of our component: it resembles functions from software programming languages.
We declare it this way: name:process(sensitivity list) and is delimited by the usual begin and end keywords.
The sensitivity list is a list of signals that are constantly polled: every change in one of it causes the process to execute.
Inside our process there are our instructions: we assign to the output signal y the result of the logic AND operation between a and b. This is achieved with the <= keyword.

func:process(a,b)
begin
   y<=(a and b);
end process;

end Behavioral;

And that's it! Here's the complete code for reference.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity AndPort is
    Port ( a : in  STD_LOGIC;
           b : in  STD_LOGIC;
           y : out  STD_LOGIC);
end AndPort;

architecture Behavioral of AndPort is

begin

func:process(a,b)
begin
   y<=(a and b);
end process;

end Behavioral;

In the video below I show how to create a new project in ISE Webpack and simulate it with ISim.
Watch it in HD and fullscreen.

I hope this tutorial is clear as we'll deal with more complex topics; if not, don't hesitate to ask!

Syntax Highlighter 3 VHDL Brush

noreply@blogger.com (Enrico Garante) — Mon, 16 Jan 2012 20:43:00 +0000

I've created a simple VHDL for Alex Gorbatchev's Syntax Highlighter 3.

You can download it here.

Enjoy!

MSP430 LaunchPad Tutorial - Bonus- UART Transmission

noreply@blogger.com (Enrico Garante) — Sun, 15 Jan 2012 17:50:00 +0000

Here's a little bonus, as someone requested: I'll just give the code with some basic explanations, so you don't have to deeply understand it but just insert the snippet into your project.

It comes from TI's MSP430F20xx esamples and it has been readjusted to be used with the Launchpad.
This snippet is particularly useful if you need to send data from sensors to a serial bluetooth module.

#include  "msp430g2231.h"

#define     TXD                   BIT1         // TXD on P1.1

//   Conditions for 9600/4=2400 Baud SW UART, SMCLK = 1MHz
#define     Bitime_5              20       // ~ 0.5 bit length + small adjustment
#define     Bitime                52

unsigned char BitCnt;      //Bit Counter
unsigned int  TXByte;      //Data to send

void ConfigureTimerUart(void);
void Transmit(void);

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  BCSCTL1 = CALBC1_1MHZ;                    // Set clock range
  DCOCTL = CALDCO_1MHZ;
  P1SEL |= TXD;                             // Select I/O pins for UART
  P1DIR |= TXD;
  __enable_interrupt();                     

  while(1)
  {
      ConfigureTimerUart();
      TXByte = 0x4B;           //K
      Transmit();
  }
}

void ConfigureTimerUart(void)
{
    CCTL0 = OUT;                               // TXD Idle as Mark
    TACTL = TASSEL_2 + MC_2 + ID_3;            // SMCLK/8, continuous mode
}

// Function Transmits Character from TXByte
void Transmit()
{
  BitCnt = 0xA;                             // Load Bit counter, 8data + ST/SP
  while (CCR0 != TAR)                       // Prevent async capture
    CCR0 = TAR;                             // Current state of TA counter
  CCR0 += Bitime;                          // Some time till first bit
  TXByte |= 0x100;                          // Add mark stop bit to TXByte
  TXByte = TXByte << 1;               // Add space start bit
  CCTL0 =  CCIS0 + OUTMOD0 + CCIE;          // TXD = mark = idle
  while ( CCTL0 & CCIE );               // Wait for TX completion
}

// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
    CCR0 += Bitime;                           // Add Offset to CCR0
    if (CCTL0 & CCIS0)                    // TX on CCI0B?
    {
      if ( BitCnt == 0)
        CCTL0 &= ~ CCIE;                  // All bits TXed, disable interrupt
      else
      {
        CCTL0 |=  OUTMOD2;                    // TX Space
        if (TXByte & 0x01)
        CCTL0 &= ~ OUTMOD2;               // TX Mark
        TXByte = TXByte >> 1;
        BitCnt --;
      }
    }
}

The program transmits the data stored in the TXByte variable on the serial line at 2400 baud.
It's pretty well commented, you shouldn't finda so much trouble understanding it.

Instead of placing the transmission function in the main loop, you could update TXByte and transmit it in a port interrupt for example.

MSP430 LaunchPad Tutorial - Part 3 - ADC

noreply@blogger.com (Enrico Garante) — Sun, 29 May 2011 22:21:00 +0000

Finally, here's the last part of this little tutorial series about LaunchPad.

I'll explain the basics of Analog to Digital Conversion on the MSP430G2231.

EDIT 01-10-12: Multi-channel conversions added!

EDIT 01-23-12:Added "Watch variable" instructions.

Basically we'll write a program that will read an ADC channel and will toggle some leds based on the result of the conversion.

We start as usual with the inclusion of the header file for the MSP430G2231, the leds stuff and with the definition of a variable that will store the result of the conversion. We also declare a function that will initialise the ADC module.

#include  "msp430g2231.h"

#define     LED0                  BIT0
#define     LED1                  BIT6

unsigned int value=0;

With this function we setup the ADC module.
With the ADC10CTL1 register we select the input channl for the ADC and the ADC clock division (from the SBMCLK).
Then we select the internal voltage reference for the ADC module (Vcc) with SREF_0, turn it on (ADC10ON) and enable the ADC10 interrupt (ADC10IE).
Finally we connect P1.5 to the ADC module by setting the ADC10AE0 register accordingly.

void ConfigureAdc(void)
{
  /* Configure ADC  Channel */
  ADC10CTL1 = INCH_5 + ADC10DIV_3 ;         // Channel 5, ADC10CLK/4
  ADC10CTL0 = SREF_0 + ADC10SHT_3 + ADC10ON + ADC10IE;  //Vcc & Vss as reference
  ADC10AE0 |= BIT5;                         //P1.5 ADC option    
}

In the main() we stop as usual the Watchdog timer, set up the clocks and the leds.
Then we select the input pin for the ADC module by setting the P1SEL register. After that, we initialise the ADC with ConfigureAdc() and enable the interrupts, otherwise we won't know when a conversion has been made.

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT  
  BCSCTL1 = CALBC1_1MHZ;                    // Set range
  DCOCTL = CALDCO_1MHZ;
  BCSCTL2 &= ~(DIVS_3);                  // SMCLK = DCO = 1MHz  
  P1DIR |= LED0 + LED1;   
  P1SEL |= BIT5;                             //ADC Input pin P1.5          
  P1OUT &= ~(LED0 + LED1);  
  
  ConfigureAdc();    
  __enable_interrupt();                     // Enable interrupts.

After the init stuff, we wait some cycles to let the ADC voltage reference settle to a stable level and then we start the conversion by setting the ADC10CTL0 register.
Then we enter a low-power mode to save juice: we'll have the result of the conversion directly in our "value" variable from the ADC10MEM register thanks to the ADC10 interrupt.
At last we simply toggle the leds on the LaunchPad according to the number stored into "value" (don't forget that we have a 10-bit ADC module, so the maximum value will be 1023).
You could do some further calculations, maybe averaging the results to get a more precise reading.

while(1)
  {    
    __delay_cycles(1000);                   // Wait for ADC Ref to settle 
    ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
    __bis_SR_register(CPUOFF + GIE);        // LPM0 with interrupts enabled    
    value = ADC10MEM;
    if (value>511)
    {
       P1OUT &= ~(LED0 + LED1);
       P1OUT |= LED0;
    }
    else
    {
       P1OUT &= ~(LED0 + LED1);
       P1OUT |= LED1;}
    }  
}

This is the ADC10 interrupt service routine, as we've seen for the TimerA module.
We simply exit the low-power mode to let the main program make some computations with the result from the ADC.

// ADC10 interrupt service routine
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR (void)
{
  __bic_SR_register_on_exit(CPUOFF);        // Return to active mode
}

And that's it! Pretty simple huh?
This concludes our tutorial series for the LaunchPad, this is all you need to get started with MSP430 MCUs.
I hope you liked this series, for any questions or suggestions don't hesitate to contact me!

Addendum:
As someone requested, here's how you do multiple conversions!

First of all, we define an array that will store the conversion results from each channel

#define     ADC_CHANNELS     5  //We will sample 5 channels
unsigned int samples[ADC_CHANNELS];

In the main loop, before the start of conversion, we add

  ADC10CTL0 &= ~ENC;
  while (ADC10CTL1 & BUSY);
  ADC10SA = (unsigned int)samples;

With this line we specify that the conversion results should be automatically stored in the previously created array: in such way, there's no need to access the ADC10MEM register anymore. The data will be immediately ready for calculations.

The ConfigureAdc function becomes

void ConfigureAdc(void)
{
  /* Configure ADC  Channel */
  ADC10CTL1 = INCH_4 + ADC10DIV_0 + CONSEQ_3 + SHS_0;   //Multi-channel repeated conversion starting from channel 5 
  ADC10CTL0 = SREF_0 + ADC10SHT_2 + MSC + ADC10ON + ADC10IE; 
  ADC10AE0 = BIT4 + BIT3 + BIT2 + BIT1 + BIT0; 
  ADC10DTC1 = ADC_CHANNELS;    //ADC_CHANNELS defined to 5   
}

CONSEQ_3 enables multi-channel repeated conversion mode.
With INCH_4 we select the starting channel (in this case we start from channel 5 the sample channel 4 and so on all the way down to channel 0). We enable ADC on those pins with the ADC10AE0 register.
MSC enables multi-channel conversions.
ADC10DTC1 defines how many blocks of data (one for each channel conversion) we transfer into the array adc_channels that we previously created.

Addendum 2:
Here's an image that will explain how to watch variables with CCS while debugging.

I hope that your concerns are resolved, otherwise don't hesitate to ask!

Launchpad Serial Morse TX

noreply@blogger.com (Enrico Garante) — Thu, 10 Feb 2011 15:22:00 +0000

Inspired by this, I decided to build a morse transmitter and add some cool features to it.

This project shows how to build a little morse transmitter using an MSP430G2231 MCU.
The device can transmit in two modes:

serial, receiving the characters from a COM port and translating them into morse code;
manual, using the key switch.

Launchpad Morse TX

In serial mode, one character at a time is read from the COM port and transmitted as morse at 15 WPM. To better understand how morse code works, read this .

Morse keying is achieved toggling an output pin connected to the oscillator power pin, thus getting a pure CW mode.

The device is powered with 2xAA batteries, and the power consumption is kept to a minimum thanks to the Low Power Mode when not transmitting. You may add a second 4xAA supply for the octal buffer in order to increase RF power.

HARDWARE

Here's what you need to build this project:

- 1x MSP430G2231 Texas Instruments MCU
- 1x 74HC240 Octal buffer
- 1x Oscillator (operating frequency should be in the 10/12m CW band (24/28 MHz))
- 2x 220 ohm resistors
- 2x 1 kohm resistors
- 2x LED (different colors are better)
- 2 push-buttons (included in the Launchpad, you may want to use a better switch for morse keying)
- 2 AA batteries (you may want to use a separate 6V (4AA) supply for 74HC240)
- 1m electrical wire (9 AWG)

As you can see from the above schematic, the MCU is used to toggle power to the oscilator, in order to make the ON-OFF modulation needed in morse coding.

The oscillator's output is then fed to the octal buffer; the amplified signal is the transmitted via the long wire antenna.

LED1 will indicate the operation mode (Serial or Manual) , LED2 will indicate whether the device is transmitting or not.

With a first pressure of KEY switch, the device will enter manual mode: further presses will transmit morse code, as a normal morse key.
To get back to serial mode, just press the RST button.

You may build this very easily on a breadboard and use the Lauchpad only to program and host the MCU. As you can see from the photos, I've built a sort of shield for the Lauchpad with male headers, but a future build will surely be on a PCB.

SOFTWARE

The program cycles indefinitely until a character is received on the UART, then encodes it into morse, executes the combinations of dots and dashes on the output pin and finally echoes back the character.

The code is pretty well commented, so you shouldn't find much problems understanding it.

The hard part came when I needed to build a lookup table for the morse code, as there's no known algorithm capable of encoding a character directly into morse. I had to use some defines and combinations of dots and dashes in order to fit the table in the 512 bytes of RAM of the G2231.

Part of this code is based on NJC's "Half Duplex SW UART on Launchpad" tutorial , read it to better understand how serial communications works on the MSP430.

The MSP430 communicates with the Putty terminal via USB thanks to the serial converter built into the Launchpad.
As you can see I type characters on the serial terminal and they get transmitted as morse code
(I know I'm out of band, but I only had a 24 Mhz oscillator lying around).
There's a little delay between typing and the sound because I'm using Globaltuners as I can't still afford a real radio receiver :) .
I'm at about 2km from the location of the receiver in the video.

There is much to improve in this project.

In a future build i will make a little PCB to fit it in a nice box. Surely I'll change the oscillator with one with a legal frequency. I'll also try to improve the antenna and add an output filter to get a perfect tone.

On the software side, I'll try to add a buffer for the serial communication and improve the bandwidth. Another thing to change is the delay-driven toggling: hopefully with better MSP430 Value Line devices incoming I'll try to add timer interrupts for this.

I hope you enjoy building and testing this project as much as I've done. Good luck and 73s!

UPDATE: check out the post on Hackaday, 43oh and Dangerous Prototypes!

1-Watt FM Transmitter

noreply@blogger.com (Enrico Garante) — Sat, 06 Nov 2010 14:50:00 +0000

This is a simple, portable transmitter operating in the 88-108 MHz FM band.

1 Watt FM Transmitter

You may use it to run your own private neighbourhood radio, just replacing the microphone capsule with a male audio jack connected to your pc or MP3 player. You may also use this as a spy transmitter, but be reasonable in that case! :D

It's rated for 1 Watt @ Vcc=18V, so you can listen to it even from a few kilometers, with a good antenna and not too much obstacles in the way. With a 9-12V Vcc it should generate 200-250 mW of RF power anyway.

FM-TX Schematic

Above you can see the schematic.

Here's how it works: the sound captured by the electret microphone is converted into a electrical signal thanks to the voltage drop on the R8 resistor. The mic is powered by the zener diode that drops Vcc to 5.1V, filtered by C8.

This signal is fed to the R7 trimmer (via the DC-decoupling capacitor C2) that controls volume and avoids overmodulation.

Then the signal is amplified about 30 times by the T1 common-emitter amplifier with feedback. This is needed beacuse the transmitter will work in large environments and it has to capture weak sounds and voices. The signal will be inverted by the amplifier, but this doesn't affect the transmission at all.

The amplified signal is the fed to the T2 Hartley oscillator : C9 (feedback), C3 (compensator, selects the transmission frequency) and L1 determine the working frequency.
The frequency modulation is achieved by varying the T2 bias: the signal from T1 is added to the bias voltage from the R3/R5 divider. This change of the T2 base potential varies the functioning of its junctions and, with them, alters the value of the parasitic capacitance (especially the collector-junction one tha is in parallel with C3) and we have a shift in the working frequency of the RF oscillator.

Finally the signal is directly irradiated by the L1 coil.

Please note that the L1 coil is made wrapping 4 windings of a 1mm copper wire on a 7mm long support, that will be removed before soldering the coil.

If you want, you may add a 70cm long wire as antenna near the first coil of L1 from the T2-collector side, or even better a ground-plane FM antenna with a shielded coaxial cable.

I recommend to build the circuit on a perf-board or better to etch its own board.
Be sure to add an heatsink to the 2N2219 transistor (T2), especially if you use an antenna.

MSPoV430 - POV with Launchpad

noreply@blogger.com (Enrico Garante) — Tue, 12 Oct 2010 12:51:00 +0000

I've used the little MSP430G2231 for my first "Persistence of Vision" project.

PoV with MSP430

As you can see, there's only the MSP430G2231 connected directly to the leds (there's no need for series resistor, the mcu supplies the right current for each led). The other connections are supply power (2 AA batteries) and RST pin to Vcc.

Here's the schematic

I plan to improve it by modifying the shape of the board to a rod, add "string-recognition" and add a button to change the displayed message.

Here's it in action.

Hello World!

This is the complete code. In the "pov" array we store each column of the message to display. Each value is then sent to the output port connected to the leds. This happens at every interrupt from the timer (400 Hz frequency).

#include "msp430g2231.h"

unsigned char i = 0;
unsigned char disp = 0;
unsigned char pov[35]= {
    0xFF,
    0x18,
    0x18,
    0xFF,
    0x00,
    0x00,
    0x00,
    0xFF,
    0x91,
    0x91,
    0x91,
    0x00,
    0x00,
    0x00,
    0xFF,
    0x80,
    0x80,
    0x80,
    0x00,
    0x00,
    0x00,
    0xFF,
    0x80,
    0x80,
    0x80,
    0x00,
    0x00,
    0x00,
    0xFF,
    0x81,
    0x81,
    0xFF,
    0x00,
    0x00,
    0x00    
    }; 

void delay_ms(unsigned int ms )  // MS delay function
{
    unsigned int i;
    for (i = 0; i<= ms; i++)
       __delay_cycles(500);
}

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT  
  CCTL0 = CCIE;                             // CCR0 interrupt enabled
  CCR0 = 313;                                // 400 Hz->313
  TACTL = TASSEL_2 + MC_1 + ID_3;           // SMCLK/8, upmode
  P1DIR |= 0xFF;                             // All P1 pins output
  P1OUT &= 0x00;
  _BIS_SR(CPUOFF + GIE);                    // Enter LPM0 w/ interrupt
  while(1)
  {}
}

// Timer A0 interrupt service routine
// Display a row from the array
#pragma vector=TIMERA0_VECTOR  
__interrupt void Timer_A (void)
{
  disp^=1;
  if(disp!=0)
  {  
      if(i==35) //cycle the array
        i=0;      
      P1OUT|=pov[i];  //Turn on the selected leds
      i++;
  }
  else
    P1OUT&=0x00;
}

MSP430 Launchpad Tutorial - Part 2 - Interrupts and timers

noreply@blogger.com (Enrico Garante) — Tue, 28 Sep 2010 17:49:00 +0000

In this tutorial, you'll learn how to use timers and interrupts with the MSP430 MCUs.

What is an "interrupt"? It is a signal that informs our MCU that a certain event has happened, causing the interruption of the normal flow of the main program and the execution of an "interrupt routine", that handles the event and takes a specified action.

Interrupts are essential to avoid wasting the processor's valuable time in polling loops, waiting for external events (in fact they are used in Real-Time Operating Systems, RTOS).

In the MSP430 architecture, there are several types of interrupts: timer interrupts, port interrupts, ADC interrupts and so on. Each one of them needs to be enabled and configured to work, and there is a separate "service routine" for every interrupt.

In this tutorial we'll see how to use timer and port interrupts to flash some leds, we'll keep the ADC interrupt for the next tutorial.

So, let's write some code!

#include "msp430g2231.h" 
void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT

You should recognize those lines,we used them in the last tutorial to add the definition file for our MCU, declare the main function and stop the watchdog timer.

  CCTL0 = CCIE;                             // CCR0 interrupt enabled
  TACTL = TASSEL_2 + MC_1 + ID_3;           // SMCLK/8, upmode  
  CCR0 =  10000;                             // 125 Hz

Here's some interesting stuff. These lines configure the timer interrupt. We first enable it by setting the CCIE bit in the CCTL0 register.
Then we set the clock for the timer module in the TimerA control register.
If you have a look at the msp430g2231.h file, you can see that:

TASSEL_2 selects the SMCLK (supplied by an internal DCO which runs at about 1 MHz);
MC_1 selects the "UP mode", the timer counts up to the number stored in the CCR0 register;
ID_3 selects an internal 8x divider for the supplied clock (in our case we have SMCLK/8).

Finally, we set the CCR0 register. We configured the TimerA module to count up to the number stored in this register before overflowing and triggering the interrupt.
By setting it at 10000, we get an overflow-frequency of 12,5 Hz. In fact we have (SMCLK/8)/10000 = 12,5 .
You may obtain several frequencies by changing this number (remember that the MSP430 has a 16-bit timer, so the value stored in the CCR0 register must not be higher than 65535), changing the dividers or adding an if-else block with a counter in the interrupt routine.
Let's go ahead.

  P1DIR |= BIT0 + BIT6;                     // All P1 pins output
  P1OUT &= 0x00;                        // Shut. Down. Everything... :)

These lines should be familiar too, we set the P1.0 and P1.6 pins to output direction and set all the pins to 0 logic level.

  P1IE |= BIT3;                             // P1.3 interrupt enabled
  //P1IES |= BIT3;                          // P1.3 Hi/lo edge
  P1IFG &= ~BIT3;                       // P1.3 IFG cleared

With these lines of code, we first tell the MCU to listen to the P1.3 pin for logic-state changes (effectively enabling the interrupt on that particular pin), and then clear the interrupt flag for that pin.
The interrput flag register P1IFG reports when an interrupt is raised, and it should be cleared at the end of the interrupt service routine.
The commented line in the middle is used to change the edge when the interrupt is raised (Hi-Lo or Lo-Hi, remember that the button on the LaunchPad is connected to GND when pushed).

  _BIS_SR(CPUOFF + GIE);                    // Enter LPM0 w/ interrupt   while(1)                                  //Loop forever, we do  everything with interrupts!
  {}
}

With this line, as you remember (do you remember right? :\ ), we shut down the CPU to spare some power while keeping the interrupts enabled. Then we enter a loop to be sure the MCU does nothing else, as we do our dirty job with interrupts.

// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
  P1OUT ^= BIT0;                            // Toggle P1.0
}

This is the TimerA interrupt service routine. Every time the TimerA overflows, the code inserted in this routine (note the special declaration) is executed. As you can see we only toggle the P1.0 pin (red led on LaunchPad), then we return to normal execution.

// Port 1 interrupt service routine
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{    
   P1OUT ^= BIT6;                            // Toggle P1.6   
   P1IFG &=~BIT3;                        // P1.3 IFG cleared    
}

This is the Port1 interrupt service routine. Every time the we push the P1.3 button, the code inserted in this routine (note the special declaration) is executed. As you can see we, toggle the P1.6 pin (greenled on LaunchPad), clear the P1.3 interrupt flag (very important) then we return to normal execution.

Compile and program the LaunchPad, you should see the red led blink, and the green led toggle on and off when you press the P1.3 button.

Here's the full code, enjoy!

#include "msp430g2231.h"  
 
void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT  
  CCTL0 = CCIE;                             // CCR0 interrupt enabled
  TACTL = TASSEL_2 + MC_1 + ID_3;           // SMCLK/8, upmode
  CCR0 =  10000;                             // 125 Hz   
  P1DIR |= BIT0 + BIT6;                     // All P1 pins output
  P1OUT &= 0x00;                        // Shut. Down. Everything... :)
  P1IE |= BIT3;                             // P1.3 interrupt enabled
  //P1IES |= BIT3;                          // P1.3 Hi/lo edge
  P1IFG &= ~BIT3;                       // P1.3 IFG cleared
  _BIS_SR(CPUOFF + GIE);                    // Enter LPM0 w/ interrupt 
  while(1)                                  //Loop forever, we work with interrupts!
  {}
} 
 
// Timer A0 interrupt service routine 
#pragma vector=TIMERA0_VECTOR 
__interrupt void Timer_A (void) 
{   
   P1OUT ^= BIT0;                          // Toggle P1.0 
} 
// Port 1 interrupt service routine
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{    
   P1OUT ^= BIT6;                          // Toggle P1.6
   P1IFG &= ~BIT3;                     // P1.3 IFG cleared 
}

Homebrew Arduino

noreply@blogger.com (Enrico Garante) — Wed, 22 Sep 2010 19:44:00 +0000

This is my homemade Arduino board, I used it for Blindwalk and I'll surely stick with it for my future projects.

Homemade Arduino is fun!

Here's the schematic: as you can see, you need very few extra components are needed (and an FTDI Basic Breakout from Sparkfun).

Schematic

The chip is an ATMega328 with pre-loaded Arduino Bootloader, and of course it is fully compatible with the Arduino IDE.

Sparkfun FTDI Basic Breakout

Arduino BlindWalk

noreply@blogger.com (Enrico Garante) — Tue, 21 Sep 2010 08:10:00 +0000

BlindWalk is a little project I've built to test my homemade Arduino board.

BlindWalk

As you can see, it is a basic ATMega328 board, with a 5V regulator an an FTDI Basic Breakout to add USB connectivity. You can see a tutorial on how to do it (and spare a lot of money too) here.

But let's talk about BlindWalk. BlindWalk, as the name says, allows you to walk in the dark by the only mean of a beeping sound and a blinking led. The beep becomes more frequent as nearer you get to an obstacle.

BlindWalk Schematic

It's not a concentrate of technology, but it does its dirty job. I used a Sharp GP2D12 IR distance sensor, a piezo speaker and a push switch to detect an impact (in fact the GP2D12 is useless under 10 cm). I've thought to put a super bright led, but the fun to walk in the dark would be drastically reduced :)

Below you can see the code.

float distance(int analog)    //returns distance in centimeters, we don't use it for now but is useful
 {
    if (analog < 3)
        return -1; // invalid value
    return (6787.0 /((float)analog - 3.0)) - 0.4;
 } 

 void setup()
 {
    pinMode(8 ,  INPUT);
    pinMode(11, OUTPUT);
    pinMode(13, OUTPUT);
 }

 void loop()
 {
    if (digitalRead(8) == HIGH)  //Check the switch for an impact
    {
       digitalWrite(13,HIGH);
       tone(11,466,100);        //Continuous tone
    }
    else
    {
       digitalWrite(13,HIGH); 
       float analog = analogRead(0);              
       tone(11,466,100);
       digitalWrite(13,LOW);
       delay(750-analog);    //beep according to the distance measured
   }
 }

I'll try to fit all of the hardware in a nice plastic box.
And here's a video of BlindWalk in action.

MSP430G2xx Eagle Library

noreply@blogger.com (Enrico Garante) — Sat, 18 Sep 2010 13:17:00 +0000

Here's an Eagle Library I've made to use MSP430 Value Line devices on our PCBs.

Download here.

Let me know if you find errors...

MSP430 Launchpad Tutorial - Part 1 - Basics

noreply@blogger.com (Enrico Garante) — Wed, 15 Sep 2010 15:33:00 +0000

After a week spent in the bed (I've had a bad flu :\ ) , I'm ready to publish my first MSP430 tutorial!

TI's LaunchPad is a complete MSP430 development environment: all you have to do is download and install CCS IDE (login required), connect your G2231-ready LaunchPad to your computer with the included mini-usb cable, and you are ready to code!

Texas Instrument MSP430 LaunchPad

So, let's see how to start a new project in Code Composer Studio. This IDE is derived from Eclipse, so if you used it before you shouldn't have much problems.

We'll program a simple program that will toggle a led when we press the on-board button.

Go to New->CCS Project

Give a name and a destination folder to your project, then click "Next". Be sure to select "MSP430" in the next window, then go ahead. Don't care about the "Additional Project Settings" window for now, and click "Next". In the "Project Settings" window, be sure to have everything set like this picture.

In the "Device Variant" field, select the correct MCU you have installed on your LaunchPad, then click "Finish".

Now we have to add a "main.c" file to our project. Right-click on your project name (note that it is in bold and has "Active - Debug" tags, meaning it will be the main project that will be compiled and debugged later on). Select "New->Source File".

Call it "main.c" then click finish. Now we are ready to add some real code!

Our first line of code will be this

#include "msp430g2231.h"  //Contains all definitions for registers and built-in functions

With this we include the definitions of registers and built-in functions for the MSP430G2231 e.g. if you used the other chip, the G2211, you had to include"msp430g2211.h" header file.

Next, we have the main routine.

int main(void)  //Main program
{
 WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
 
 P1DIR |= BIT0; // Set P1.0 to output and P1.3 to input direction
 P1OUT &= ~BIT0; // set P1.0 to Off
 P1IE |= BIT3; // P1.3 interrupt enabled
 P1IFG &= ~BIT3; // P1.3 interrupt flag cleared
 
 __bis_SR_register(GIE); // Enable all interrupts
 
 while(1) //Loop forever, we'll do our job in the interrupt routine...
 {}
}

It's quite a mere "setup" routine, as we don't do nothing that involves the led toggleing.

WDTCTL = WDTPW + WDTHOLD;

With this line, we stop the "Watchdog timer": it is typically used to reset the MCU after a certain amount of time, to prevent deadlocks and infinite loops. In most examples, you will see that the watchdog timer is stopped during the first line of code, to avoid unwanted resets.

P1DIR |= BIT0;

With this instruction, we set the P1.0 pin (which is connected to the red led on the LaunchPad) to the output direction. In the MSP430 architecture, P1DIR is a 8-bit register that controls the i/o direction of the Port 1 pins. If you set a bit to 0, it is configured as an input, otherwise it is an output. The BIT0 constant is simply the 0x01 hex number, so you do this :

P1DIR before   00000000+
BIT0               00000001=
P1DIR after      00000001

This way, all the Port1 pins are set to input direction, except for P1.0 which is our led.

P1OUT &= ~BIT0;

Whit this,we resetthe P1.0 output . In fact, the P1OUT register controls all the output pins: if you put a bit to 1 (by or-ing the P1OUT register with the right numeric constant BIT0, BIT1...), the relative output pin is set on HIGH logical level, otherwise (by and-ing the P1OUT register with the inverted numeric constant) it is set on a LOW level.

P1IE |= BIT3; // P1.3 interrupt enabled
P1IFG &= ~BIT3; // P1.3 interrupt flag cleared

With these two instruction, we enable the interrupt on the P1.3 input pin (the on-board button).

What is an interrupt? Well, this is not the rigth time, but for now I'll you only have to know that this two lines of code allows the chip to know when the button has been pressed, even if he is doing other things (like calculations, delays ecc...). The P1IE register is used to enable interrupts on an input pin (it works like the P1DIR e P1OUT registers), and the P1IFG register is used to know if the desired event (in this case the press of the button) has happened (then the relative bit is set to 1) or not (the bit is set to 0).

__bis_SR_register(GIE);

With this built-in function, we enable all the interrupts by setting the GIE (Global Interrupt Enable) bit in the Status Register of the MSP430G2231. This function is also used to enter Low-Power modes, but this will be covered in a future tutorial.

while(1) {}

Finally, we enter an infinite-loop, as we have nothing more to do in the main function.

In fact, we will actually toggle the led in the "Port 1 interrupt service routine". This routine is called every time the state of a interrupt-enabled P1 pin changes from high to low (the button on the LaunchPad is active-low).

#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
    P1OUT ^= BIT0;  // Toggle P1.0
    P1IFG &= ~BIT3; // P1.3 interrupt flag cleared
}

The first line of this function (P1OUT ^= BIT0;) toggles the pin state by xor-ing it. Then the Interrupt flag is set back to 0 in order to listen for another interrupt.

Now we are ready to launch the code on CCS.

Be sure to have the LaunchPad connected to your PC, then press the little green-bug button on the IDE to compile, download the code and enter the debug perspective.

Then press the "Play" button to start execution, the "Stop" button to exit debugging and the "Chip" button to reset the board.

If everything went well, you should see that if you press the on-board button, the red led will turn on and off.

If so, congratulations! You have built your first MSP430 program!

Here's the complete code of this example:

#include "msp430g2231.h"  //Contains all definitions for registers and built-in functions 
int main(void)  //Main program
{
   WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
 
   P1DIR |= BIT0; // Set P1.0 to output and P1.3 to input direction
   P1OUT &= ~BIT0; // set P1.0 to Off
   P1IE |= BIT3; // P1.3 interrupt enabled
   P1IFG &= ~BIT3; // P1.3 interrupt flag cleared
 
   __bis_SR_register(GIE); // Enable all interrupts
 
   while(1) //Loop forever, we'll do our job in the interrupt routine...
   {}
}
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
    P1OUT ^= BIT0;  // Toggle P1.0
    P1IFG &= ~BIT3; // P1.3 interrupt flag cleared
}

That's all for now, if you see any error on this tutorial, please let me know. The next tutorial will focus on Timers and Interrupts.

Happy Coding!

Solarbotics BeetleBot Review

noreply@blogger.com (Enrico Garante) — Sat, 04 Sep 2010 20:42:00 +0000

So here it is: yesterday I received a white package from the cool guys at Solarbotics, and now I'm ready to assemble and review the BeetleBot!

What is a BeetleBot? Well, as they say at Solarbotics, it is "the simplest TRUE robot you can build". And this is true: you only require a screwdriver (included in the kit, wow!) and an hour of your free time to enjoy this clever bot. The BeetleBot goes forward until it hits an obstacle (thanks to the antenna bump-sensors), then he turns around and keeps going in the opposite direction.

So let's open the box! You'll find:

The kit unboxed.

An acrylic baseplate, top shell, switch spacer
2x switches
2x wire antennae
A power switch harness
A switch harness
2x CC Motors
2x aluminium motor brackets
2x Rubber Tires
A piece of double-sided tape
A tail spring
2x AAA battery packs
A bunch of screws
3x 5/8" nylon spacers
6x leg wires
A stickersheet
A screwdriver

and of course the instruction manual.

The instruction booklet is very useful and has detailed pictures to help everyone getting this kit well-assembled. This "screw-only" kit is very easy to mount and it doesn't require dangerous and complex soldering, only basic handskills with a screwdriver! Here is the Beetlebot in the early phases of assembling.

The bottom Side

The Top side

Here's the BeetleBot after connecting all the wires. They are the only "brain" of this minimal bot. The circuit was originally designed by Jerome Demers as a science-fair project. The bumper switches make the motors change the battery pack they use, running forward or backwards. It's all well-explained in the instruction manual.

After about an hour, my evil BeetleBot was ready to run freely and scare everyone who tries to get in his way!

Wow, this bot is really scary. Next time I'll pick the "good" theme of the kit :) .

Sometimes the bot kept spinningaround in circle (at first I liked it), but thanks to the troubleshooting section I fixed it at once (one antenna was stuck and kept the switch closed).

What I really liked of this bot is that it's well-documented (big pictures, clear instructions and a good sense of humour) and it is really, really easy to mount. This kit is perfect to give as a present to a young boy, he will surely enjoy assembling it and understanding how the bot works, giving him a good start in the big world of robotics.

Finally, here's the BeetleBot in action. I've made a little enclosure to avoid it to run all over the house (this thing is amazingly fast!).

For additional info, go to the Solarbotics BeetleBot page.

Holidays

noreply@blogger.com (Enrico Garante) — Sat, 07 Aug 2010 14:37:00 +0000

I will be on holiday for a few weeks, but September will be a great month!

I'll post about:

Solarbotics BeetleBot;
Arduino BlindWalk project;
MSP430 and generic electronics tutorials.

Happy summer, and stay tuned!

Imperial March on TI Launhpad

noreply@blogger.com (Enrico Garante) — Thu, 15 Jul 2010 18:13:00 +0000

UPDATE1: I've been published on TI's Launchpad page! Check it out!

UPDATE2: I've posted the tutorial for this project on TI Launchpad Wiki.

Here it is: my "Hello World" for Texas Instruments' MSP430 Launchpad. The imperial March played on the MSP430G2231!

I'll post some tutorials about it in a while.

Schematic

The circuit is really simple to build. Solder the 1KOhm resistor to the positive lead of the speaker (red wire) and connect it to P1.2 on the Launchpad. Then connect the black wire to the GND pin on the board. You can even remove the R1, but the sound will be very loud and annoying, and the speaker may be damaged. You can add a 1K trimmer instead of the resistor to make the volume adjustable.

Code

Here is the fully commented code for this tutorial. I have ported it to the MSP430G2231 from an Arduino example made by naneau.

#include "msp430g2231.h"

#define c 261
#define d 294
#define e 329
#define f 349
#define g 391
#define gS 415
#define a 440
#define aS 455
#define b 466
#define cH 523
#define cSH 554
#define dH 587
#define dSH 622
#define eH 659
#define fH 698
#define fSH 740
#define gH 784
#define gSH 830
#define aH 880

void delay_ms(unsigned int ms )
{
      unsigned int i;
      for (i = 0; i<= ms; i++)
        __delay_cycles(500);
}

void delay_us(unsigned int us )
{
      unsigned int i;
      for (i = 0; i<= us/2; i++) 
        __delay_cycles(1);
}

void beep(unsigned int note, unsigned int delay )
{ 
 int x;  
 long delayAmount = (long)(10000/note);
 long loopTime = (long)((delay*100)/(delayAmount*2));
 for (x=0;x loopTime;x++) 
    {    
        IO_HIGH(P1, BIT2);
        delay_us(delayAmount);
        IO_LOW(P1, BIT2);
        delay_us(delayAmount);
    }  
    delay_ms(20);
}

void march()
{
 beep(  a, 500);
    beep(  a, 500);
    beep(  a, 500);
    beep(  f, 350);
    beep(  cH, 150);  
    beep(  a, 500);
    beep(  f, 350);
    beep(  cH, 150);
    beep(  a, 650);
    delay_ms(150);
    //first bit   

    beep(  eH, 500);
    beep(  eH, 500);
    beep(  eH, 500);   
    beep(  fH, 350);
    beep(  cH, 150);
    beep(  gS, 500);
    beep(  f, 350);
    beep(  cH, 150);
    beep(  a, 650);
    delay_ms(150);
    //second bit...  

    beep(  aH, 500);
    beep(  a, 300);
    beep(  a, 150);
    beep(  aH, 400);
    beep(  gSH, 200);
    beep(  gH, 200); 
    beep(  fSH, 125);
    beep(  fH, 125);    
    beep(  fSH, 250);
    
    delay_ms(250);

    beep(  aS, 250); 
    beep(  dSH, 400); 
    beep(  dH, 200);  
    beep(  cSH, 200);  

    //start of the interesting bit   

    beep(  cH, 125);  
    beep(  b, 125);  
    beep(  cH, 250);  
     
    delay_ms(250);
    
    beep(  f, 125);  
    beep(  gS, 500);  
    beep(  f, 375);  
    beep(  a, 125);
    beep(  cH, 500);
    beep(  a, 375);  
    beep(  cH, 125);
    beep(  eH, 650);
    
    //more interesting stuff (this doesn't quite get it right somehow)   

    beep(  aH, 500);
    beep(  a, 300);
    beep(  a, 150);
    beep(  aH, 400);
    beep(  gSH, 200);
    beep(  gH, 200);
    beep(  fSH, 125);
    beep(  fH, 125);    
    beep(  fSH, 250);

    delay_ms(250);

    beep(  aS, 250);  
    beep(  dSH, 400);  
    beep(  dH, 200);  
    beep(  cSH, 200);  

    //repeat... repeat   

    beep(  cH, 125);  
    beep(  b, 125);  
    beep(  cH, 250);      

    delay_ms(250);

    beep(  f, 250);  
    beep(  gS, 500);  
    beep(  f, 375);  
    beep(  cH, 125);
    beep(  a, 500);   
    beep(  f, 375);   
    beep(  cH, 125); 
    beep(  a, 650); 
     
}

int main( void )
{
   WDTCTL = WDTPW + WDTHOLD;
        P1DIR |= BIT2; // P1.2 output
 while(1)
 {
  march();
  delay_ms(2000);
 }
}

Theoretical Background

A Pulse Width Modulation (PWM) output can be used to play tones on a piezo speaker. With this, musical scales and simple songs can be played on the piezo speaker.

Piezo speakers operate by the converse piezoelectric effect: when a voltage is applied across the terminals, the piezoelectric material in the speaker deflects in one direction. Applying an alternating voltage, such as a square wave, will cause the material to vibrate and create a sound. A constant voltage will not produce a sound. Also sine, triangle and sawtooth waves can be used to drive a piezo speaker, resulting in different pitches of the notes.

As you can see from the code, the beep() function was used to provide the alternating voltage to drive the speaker. The period (do you remember delay_us() ?) of the sqare wave determines the note that will be played.

You can have some problems about the clock and timings with this project, I'm still figuring out the MSP430 Clock System as it is the first time I use them.

You can modify this project to play sounds from an SD Card, like it has been done here. (I'm working on it, but the sound is really distorced, I'm still wondering why...)