edeca.net » Electronics

Cooking with gas, my first SMD board

David — Mon, 10 May 2010 18:30:29 +0000

My first bunch of boards arrived back from BatchPCB and I’m really impressed. Great printing for the silkscreen and a really professional looking product. One of the boards I ordered was a breakout board for the SMD PIC 18F2321, the first surface mount board I have tried.

The original board was designed and kindly sent to me by 3v0, I tidied up the silkscreen before shipping it off to be produced.

Copper layers

Silkscreen

This board uses 0803 SMD parts, but boy are they tiny. These are some of the larger surface mount components, I definitely would not try the smaller ones. After applying paste by hand to the board (I used this stuff) I carefully placed the components using a pair of tweezers I bought specially.

Most board houses will apply a solder mask to manufactured PCBs, this is a special layer on top of the board that covers up everything except the pads. This means a thin line of paste can be run along all the pins of the chip, there is no need to try and put an individual dot on every pad! As the paste heats up and turns into solder the flux will evaporate and surface tension pulls the solder paste back onto each pad.

The original board, paste and tweezers can be seen in the image below.

SMD board tools

After assembly came the fun bit, cooking time! I kept an old frying pan specially for this, into which I placed the board. Cooking time was no more than a few minutes, it is very visible when the paste starts to reflow and turn into molten solder. As soon as that happened I turned off the gas hob and left it to cool.

Cooking an SMD PCB!

Note that the oven thermometer really doesn’t work, it had barely reached 50°C by the time the board was finished. A non contact IR thermometer apparently works much better and should be considered if you want to roughly follow a specific reflow profile.

The final result is shown below, after the header pins were hand soldered.

The finished SMD PCB

Did it work first time? Well, mostly. The PIC powered up, the LED blinked on and it talked to PICKit2 on the PC. After a little examination I found that two of the pads on the chip were not properly soldered, which played havoc with some code I was writing.

Next time I think I would use more paste, I was quite frugal with the syringe and had to fix the two bad joints by hand. I also probably wouldn’t design all future PCBs as SMD, populating and reflowing the board is easy but the parts are fairly expensive compared to standard “through hole” alternatives.

One more picture now of it in use. This little thing really speeds up prototyping time, no need to connect a pull-up resistor, power and ICSP lines manually. If only writing code was so easy..

SMD breakout in use with a graphic LCD

For more information, watch this useful video on Youtube and read the excellent SMD How To from Sparkfun.

Using the hardware USART with BoostC and a PIC

David — Sun, 11 Apr 2010 17:08:17 +0000

This post looks at what is needed to get a serial connectiong working with BoostC using a PIC with a hardware USART. A later post will cover the BoostC software implementation, when I have finished figuring it out.

By the end of this post there will be a PIC uC talking to Hyperterminal on the PC using less than 50 lines of code.

Pros & cons of using the BoostC library

There main advantage to using this library to implement serial communication is that it sets up all registers and control bits for you (including TRIS for the TX and RX pins). This means limited digging around in the datasheet, you can code without worrying about the underlying hardware.

However it may be a disadvantage too. The limited control over the hardware means that certain things are fixed. For example, 8-bit transmission is the default. It might be possible to change these by modifying the PIC registers directly but I haven’t tried this yet. Leave a comment if you know it works!

Requirements

A few things are necessary to make this work. Firstly a PIC with hardware USART support, in this post I’ll be using the PIC 18F1320 as an example. The hardware USART is listed under “peripherals” in datasheets.

In order to talk to a PC we also need some form of level convertor from logic levels (+5v/0v) to RS-232 (maximum voltage range +12/-12v). I use a MAX232 breakout board that I built myself, but this board or this board from Sparkfun should work just fine.

Connecting it up

The purpose of this post isn’t to discuss connectivity, but briefly the PIC TX and RX pins need to be connected to the level shifter, as do +5v and GND. The serial pins on the PIC can be found in diagrams in the datasheet. Remember which pins they are as they are needed later.

Find the right values

The BoostC library is incredibly easy to use but there are a three values to work out first. Remember the choices so they can be used in the code later.

bit_time

The first value is bit_time, which is the number of CPU instruction cycles per bit (note that the header file says this is used by the software USART, but code will not compile without it so it is included here for reference).

Take the clock speed in hz, divide by four and then divide by your desired bit rate. I recommend starting slow (e.g. 1200 baud) and trying to faster when it works, so for an 8Mhz clock and 1200 baud we get:

bit_time = 8000000 / 4 / 1200
bit_time = 1666

Baud rate generator mode

The second thing to work out is whether we need high or low speed mode and what divisor to use. Fortunately these are fairly simple as they are explained in the datasheet.

If using a slow baud rate with a fast oscillator, the datasheet recommends using the high baud rate generator. The datasheet also suggests that it might help to reduce baud rate error. Enabling this means using a mode of 1.

For this example I used the 8Mhz internal oscillator (fairly low speed) and did not use the high speed generator, so I set mode to 0.

Baud rate generator divisor

Finding the divisor number is as easy as reading the datasheet to find the “SPBRG value”. There are tables with the combinations of oscillator speed and baud rate showing the correct value. Be careful to use the correct table for whether you plan to work with the high or low speed generator!

For 1200 baud at 8Mhz using the low speed generator, the value is 103.

Using the code

Below is example code which shows how to use the information described above. It was adapted from the file serial_test.c which comes with BoostC.

For some reason the BoostC examples use the hexadecimal locations of the correct registers. It is possible to use their names instead, e.g. TRISB/LATB/PORTB as I have below.

In the code below it is necessary to change 4 things:

the ports and pin numbers for TX and RX (e.g. if TX is RA6, use 6)
the bit_time value calculated above
the call to uart_init, which will need the high/low speed flag and the divisor value
the clock frequency, if 8Mhz is not used

Code example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

/********
* Date: 11th April 2010
* Author: David Cannings
*
* Example BoostC code for hardware USART on a PIC18F1320
********/
#pragma CLOCK_FREQ 8000000

#include

// Standard 18F1320 configuration, included to pacify PICkit2
#pragma DATA _CONFIG1H, _IESO_ON_1H & _INTIO2_OSC_1H
#pragma DATA _CONFIG2L, _PWRT_ON_2L & _BOR_OFF_2L
#pragma DATA _CONFIG2H, _WDT_OFF_2H
#pragma DATA _CONFIG3H, _MCLRE_ON_3H
#pragma DATA _CONFIG4L, _DEBUG_OFF_4L
#pragma DATA _CONFIG5L, _CP0_OFF_5L & _CP1_OFF_5L
#pragma DATA _CONFIG5H, _CPB_OFF_5H & _CPD_OFF_5H
#pragma DATA _CONFIG6L, _WRT0_OFF_6L & _WRT1_OFF_6L
#pragma DATA _CONFIG6H, _WRTC_OFF_6H & _WRTB_OFF_6H & _WRTD_OFF_6H
#pragma DATA _CONFIG7L, _EBTR0_OFF_7L & _EBTR1_OFF_7L
#pragma DATA _CONFIG7H, _EBTRB_OFF_7H

// Setup the hardware USART
// TODO: Set the next 6 values to the right ports and pin numbers
#define TX_PORT PORTB
#define TX_TRIS TRISB
#define TX_BIT 1
#define RX_PORT PORTB
#define RX_TRIS TRISB
#define RX_BIT 4

// The following values are for 18F parts, for 16F see rs232_driver.h
#define e_SPBRG 0x0faf
#define e_RCREG 0x0fae
#define e_TXREG 0x0fad
#define e_TXSTA 0x0fac
#define e_RCSTA 0x0fab
#define e_TXIF_PIR 0x0f9e
#define e_RCIF_PIR 0x0f9e
#define e_TXIF_BIT 4
#define e_RCIF_BIT 5
#define MODE (USART_reset_wdt | USART_HW)

// bit_time = FOSC / 4 / baud_rate, so 1200 baud at 8Mhz
// TODO: Set bit_time here
#define bit_time 1666

#include

void main() {
osccon = 0x72; // 8Mhz internal oscillator

adcon0 = 0x00; // Disable internal ADC
adcon1 = 0x7F; // Set all PORTB to digital I/O

// Setup the USART, arguments are baud rate generator mode
// and divisor
// TODO: Set mode and divisor here
// I chose 0 for low speed mode and 103 for 1200 baud at 8Mhz
uart_init(0,103);

// Send some text from the PIC to PC
puts("Hello, world");

while (1)
{
// If a character is received from the PC, send it back
if (kbhit())
{
puts("You pressed: ");
putc(getc());
puts("");
}
}
}

Setting up a PC client

As I mentioned above the settings for serial communication are fixed by the library. You will need to set 1200 bits per second, 8 data bits, no parity, 1 stop bit and Xon/Xoff flow control. This is often shortened to “1200 8-N-1″.

If you use Hyperterminal, all settings are on the properties page for the relevant serial port.

Conclusion

And finally, some proof that it actually works! If you find this post useful, or you need further help, please leave a comment below.

Update

Mike (K8LH) has posted a great little utility on the Microchip forums that can help work out the correct values, if you don’t fancy digging through datasheets.

Eagle components library added

David — Tue, 30 Mar 2010 19:51:15 +0000

A very short note to say that I have (finally) published my Eagle components library on this site. Right now it doesn’t contain many parts, but I will add to it as I make more boards.

DIY pcb making – my first board

David — Tue, 14 Jul 2009 18:58:37 +0000

After getting back into electronics recently, I decided to have a go at making a PCB. A friend pointed me to Pulsar Pro FX, a special toner release paper.

I learned a few things along the way:

use thin board, this makes a huge difference. I found 0.0032″ board at Crownhill in the UK, which seems perfect
let the laminator warm up enough, wait at least 15 minutes after the light comes on
always leave enough of an edge on the paper and board, excess can always be trimmed off later

Failing to do these wastes time, paper and energy and results in lots of cleaning up to do.

Below is a sample of what the finished PCB looks like. The slight roughness round the edges is due to cutting it with scissors and the black tint is because I did not have acetone to clean the toner off with.

First PCB made with Pulsar Pro FX

There is an excellent guide to using the paper which includes step-by-step pictures and the finished result. SMD and double sided boards are perfectly possible, but I haven’t tried yet.