My LCD Boosterpacks will also be sold in the 430h.com store and for some of you it may be a better alternative to buy them there.

It has a very limited list of things to buy right now, but when it’s stocked up, feel free to buy some stuff to support the projects. If you have suggestions to what I can sell, please let me know. This includes also if you have suggestions to 3D-printed objects that could be in the store.

I basically use solder paste in a syringe and manually apply solder paste on each surface mount point.  It would probably have been slightly faster using a surface mount stencil, but using a syringe is also quite quick and not as messy as a stencil.

I then place the surface mount components onto the paste. In my case these are just simple capacitors and resistors, so it’s not very complicated. I used 1206 size originally, but have now started using 0805 size capacitors.

The board is now ready to be fried. There are several ways of doing this. Some people use a reflow oven that surrounds the entire board with heat, but I find that if the surface mount components are only on one side, using a hot plate such as this is the easiest. Not sure what the pros and cons are of each, but Sparkfun have also recommended using hot plates. I use a thermistor to control the heat, but since my hot plate has a thermostat I just use the thermistor to guide me towards the best setting.

Here’s a picture of some of the boards on the hot plate. I can do several at the same time.

The whole process of applying paste, heating them on the hot plate and then manually soldering on the LCD means I use about 1 hour on 10 boards. Of this, just doing the surface mount takes maybe 10-15 minutes for 10 boards. It’s definitely faster than manual soldering.  I might get more efficient as I move along. Right now I’m also soldering on headers on all the boards as it makes it easier to test, but I won’t do that in the long run. I’m shipping 14 boards to the 43oh.com store tomorrow. I will keep a few to sell here on the site. Unfortunately, Arrow have told me the remaining batch of 222 LCDs is delayed until July, so if you want to test a board early, it might be good to get one of this first batch.

Here’s a zoomed in picture of one of the boards, before the solder paste has melted. The picture also shows my silk-screen error (P1.4 is really P2.0). Other than that and a slightly inefficient LED-connection, the first batch of boards seem to be pretty ok (the points that need to be connected to turn on the backlight are a bit far apart, but no big issue). The next version will also have the SMT components on the bottom, as it looks nicer.

And here’s a picture of the LCD connector soldered onto the board. I do this manually, but it’s pretty easy when using flux to ‘guide the solder’. You can barely see the liquid flux on the board around the connector.

The boosterpacks are currently in their first version, and may evolve and be improved from this description. The packs are:

• LCD Touch Boosterpack – a classic boosterpack with the LCD and 4 capacitive touch button areas (the display isn’t touch-enabled, in case you were wondering, just the 4 areas below the screen).
• LCD Button Boosterpack – can be a classic boosterpack to mount onto a Launchpad or it has a place to put a DIP MSP430 onto it, so you can use the Boosterpack without a Launchpad. Also has room to solder on a regulator in case you want to run it off a battery.
• LCD Watch – not really a boosterpack, as it won’t fit onto the Launchpad. It’s smaller in size and is meant to be part of a wrist-watch kit.

There is more info about the boosterpacks on a permanent page here on my blog, including a link to a video.

The picture shows the temperature in a display and in front the Thermistor. These are really tiny glass beads that can handle high temperatures, but be careful with how you mount it.

The circuit is basically

Vcc — 10K resistor — P1.2 — Thermistor — 0V

It’s also good to place a 1uF capacitor across the thermistor to remove noise.

IAR MSP430 code is below. It can easily be adapted to CCS or MSPGCC.

thermistor.c:

/*
* Inspired by http://reprap.org/wiki/Temperature_Sensor_1_0
* No license info from that page, but some may claim it's GPL.
* Not sure if that is relevant for such a short code snippet.
*/

#include
#include "thermistor.h"

// Thermistor B57560G104F http://uk.farnell.com/epcos/b57560g104f/thermistor-ntc/dp/3878697?Ntt=3878697

// r0: 100000
// t0: 25
// r1: 0
// r2: 10000
// beta: 4036
// max adc: 1023
#define NUMTEMPS 20
int temptable[NUMTEMPS][2] = {
   {1, 664}, // 664.64106912 C
   {54, 210}, // 210.439979582 C
   {107, 171}, // 171.052478604 C
   {160, 149}, // 149.564016786 C
   {213, 134}, // 134.640069513 C
   {266, 123}, // 123.039739982 C
   {319, 113}, // 113.394921511 C
   {372, 104}, // 104.997832544 C
   {425, 97}, // 97.4294169841 C
   {478, 90}, // 90.4137427983 C
   {531, 83}, // 83.7503688927 C
   {584, 77}, // 77.2777873564 C
   {637, 70}, // 70.8496463885 C
   {690, 64}, // 64.314518844 C
   {743, 57}, // 57.4917052426 C
   {796, 50}, // 50.1314173911 C
   {849, 41}, // 41.8303323287 C
   {902, 31}, // 31.8031759831 C
   {955, 18}, // 18.0092465547 C
   {995, 0} // 0.112666936696 C
};

void initThermistor()
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  ADC10CTL1 = INCH_2;             // Conversion code singed format, input A1
  ADC10AE0 |= BIT2;                         // P1.2 ADC option select
  ADC10CTL0 = ADC10SHT_2 + ADC10ON + ADC10IE; // ADC10ON, interrupt enabled
}

int rawValueThermistor()
{
    ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
    __bis_SR_register(CPUOFF + GIE);        // LPM0, ADC10_ISR will force exit
    return ADC10MEM;
}

int readTemp()
{
   int rawtemp = rawValueThermistor();
   int current_celsius = 0;

   int i = 0;
   for (i=1;i < NUMTEMPS;i++)    {       if (temptable[i][0] &gt; rawtemp)
      {
         int realtemp  = temptable[i-1][1] + (rawtemp - temptable[i-1][0]) * (temptable[i][1] - temptable[i-1][1]) / (temptable[i][0] - temptable[i-1][0]);

         if (realtemp > 255)
            realtemp = 255; 

         current_celsius = realtemp;

         break;
      }
   }

   // Overflow: We just clamp to 0 degrees celsius
   if (i == NUMTEMPS)  {
      current_celsius = 1000;
   }

   return current_celsius;
}

#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR (void)
{
  __bic_SR_register_on_exit(CPUOFF);        // Clear CPUOFF bit from 0(SR)
}

thermistor.h

void initThermistor();
int rawValueThermistor(void);
int readTemp(void);

First take a receiver module such as this one. Connect it to power and ground, place an 8 cm wire to the antenna and connect the signal to a digital signal oscilloscope. If you don’t have one, you should get one. There are some sub-100 USD ones that work very well. I use Open Logic Sniffer, which is a great tool. Below is a picture showing a sample collected data. This is not the one from my NEXA remote controlled power socket. I didn’t save that one.

Connect it to the PC and you can see digital waveforms, timing etc on the PC. Use the remote that came with the socket to send a signal and read it using the receiver-module and the logic-sniffer. Press a button, and record the waveform. Note the timings etc. Zoom in to see the details. Try to see the timings + recognize specific repeating wave-forms. If you don’t have a logic-sniffer, you can also write a program to capture the timings of the signal using a simple MSP430-program. Then you have a DSO priced at $4.30 . Here is a picture of the Receiver-module.

Then use a transmitter module such as this one to send the same signal. Here’s a picture:

Use an MSP430 Launchpad or an Arduino as your microcontroller-board. Connect GND to ground, VCC to your Launchpad 3.5V and ANT to an 8 mm cable. Connect DATA to P1.0 and write a program to replicate the signal you captured using the DSO. I have one example that works with the above NEXA remote controlled socket in Inventortown on this link. You can take it from Inventortown and use it in your ‘local’ compiler if you prefer. This code is just for MSP430 Launchpad.

You can probably use the same mechanism to replicate many garage door openers also. I’ve used this code and the mentioned devices from Farnell to remote control devices in my house. The good thing about doing this is that you don’t have to worry about playing with higher voltages. The external, certified power socket takes care of all the dangerous voltages, and you just control it remotely. Very safe and nice. Source code is also below the line here.

/*
	Author: Lars Kristian Roland
	License: GPL
	Website: http://lars.roland.bz/ and www.inventortown.com
	This is code to control a NEXA remote controlled power switch, using
	an 433 RF TX board connected at P1.0
*/

#include
#define interrupt(x) void __attribute__((interrupt (x)))

void on1();
void off1();
void on2();
void off2();
void on3();
void off3();

void delay(unsigned int us);
void long_delay();
void pulse(int pulses);
void betweenPulse();

volatile unsigned char pressed;

#define ONE pulse(1)
#define TWO pulse(2)
#define THREE pulse(3)

#define BUTTON BIT3

int main(void)
{
  WDTCTL = WDTPW + WDTHOLD; // disable watchdog

  P1REN |= BUTTON;               // Enable Pull up resistor
  P1OUT |= BUTTON;               // Enable pull up resistor
  P1IES  |= BUTTON;               // Int on falling edge
  P1IFG &= ~(BUTTON);           // Clr flags
  P1IE |= BUTTON;                // Activate interrupt enables

  P1DIR |= BIT0;
  P1OUT &= ~BIT0;

  pressed = 0;

  _BIS_SR(GIE);

  while (1)
  {
      	_BIS_SR(LPM0_bits + GIE);
	on1();on1();on1();on1();
	long_delay();
	on2();on2();on2();on2();
	long_delay();
	on3();on3();on3();on3();
	long_delay();
	off1();off1();off1();off1();
	long_delay();
	off2();off2();off2();off2();
	long_delay();
	off3();off3();off3();off3();
	//long_delay();
  }
}

void preamble()
{
      delay(4000);
      ONE;
      delay(600);
      TWO;
      TWO;
      TWO;
      TWO;
      TWO;
      ONE;
      TWO;
      THREE;
      ONE;
      TWO;
      TWO;
      TWO;
      TWO;
      TWO;
      TWO;
      THREE;
      TWO;
      TWO;
      ONE;
      TWO;
      TWO;
      THREE;
      ONE;
      TWO;
      TWO;
      THREE;
      TWO;
}

void on1()
{
      delay(4000);
      preamble();
      ONE;
      THREE;
      TWO;
      TWO;
      TWO;
      ONE;
}

void off1()
{
      delay(4000);
      preamble();
      TWO;
      TWO;
      TWO;
      TWO;
      TWO;
      ONE;
}

void on2()
{
      delay(4000);
      preamble();
      ONE;
      THREE;
      TWO;
      TWO;
      ONE;
      TWO;
}

void off2()
{
      delay(4000);
      preamble();
      TWO;
      TWO;
      TWO;
      TWO;
      ONE;
      TWO;
}

void on3()
{
      delay(4000);
      preamble();
      ONE;
      THREE;
      TWO;
      ONE;
      THREE;
      ONE;
}

void off3()
{
      delay(4000);
      preamble();
      TWO;
      TWO;
      TWO;
      ONE;
      THREE;
      ONE;
}

void pulse(int pulses)
{
    for (int i = 0; i < pulses; i++)
    {
	P1OUT |= BIT0;
	delay(120);
	P1OUT &= ~BIT0;
	delay(120);
    }
    delay(510);
}

void betweenPulse()
{
	P1OUT &= ~BIT0;
	delay(1050);
}

// Delay function. # of CPU cycles delayed is similar to "cycles". Specifically,
// it's ((cycles-15) % 6) + 15.  Not exact, but gives a sense of the real-time
// delay.  Also, if MCLK ~1MHz, "cycles" is similar to # of useconds delayed.

void long_delay()
{
    for (int i = 0; i < 100;i++) {     	delay(1000);     } } void delay(unsigned int cycles) {   while(cycles>15)                          // 15 cycles consumed by overhead
    cycles = cycles - 6;                    // 6 cycles consumed each iteration
}

// The ISR assumes the interrupt came from a pressed button
interrupt(PORT1_VECTOR) PORT1_ISR()
{
  // If Switch was pressed
  if(P1IFG & BUTTON)
  {
  	//P1OUT |= BIT0;
  	LPM0_EXIT;
  	_NOP();
  	P1IFG &= ~BUTTON;
  }
}

an the schematic:

The display looks similar to the above pictures, but is slightly smaller and I think maybe slightly better quality. It has backlight, and a 9-bit 3-line SPI interface. It’s quite small, so I’ve made another post about the possibility to make a wrist-watch kit from this display.

The display data sheet is here. It is SPI-based, but it uses a 9-bit SPI interface. The first bit is decides whether it’s a write to the display memory or a config-command. As far as I understand, the USCI-chips don’t support 9 bits, while the USI ones do. I’ve made a bitbanging driver for it so far, and it works ok. I guess with an HW-driver it’ll be updating faster. I’ll see if maybe it can be tweaked onto the USCI peripheral by sending 2 bytes.

The features are:

- small (34 x 30 mm physical size. Viewing area 28×19)
- 3-line SPI 9-bit (Driver Sitronix ST7579-G2)
- low power
- backlight
- black and white LCD
- approx 3 USD cost

I made a watch with the earlier LCD display (i2c-version) I was using. Here’s a picture. The SPI-display is slightly smaller, but the display quality is similar (slightly better on the SPI display). I will have 250 of these, so if anyone is interested in this display for projects, let me know. I’m planning on making some packs that are finished soldered and can be sold in the shop, but it’s relatively easy to solder these displays onto a board for your own projects also.

So I’m planning on making a watch-board for the new display. It’ll have the display soldered onto one side. The other side will have space for example for a MSP430G2452. The design will be open source. Any suggestions to peripherals and buttons? I could put an accelerometer there, for example to detect taps on the display. I guess I could also put a radio in it???

A very basic start is here (this one has places for a header in case one wants to use the display as a breakout instead). The board design is a bit strange since I’ve used it to make a single-side test board also. So the ‘breakout’-traces are on the top only.