ermicroblog

Integrating Wiznet W5100, WIZ811MJ network module with Atmel AVR Microcontroller

rwb — Sat, 31 Jul 2010 08:59:56 +0000

The rapid penetration of the internet networks into many of today’s modern homes and personal gadgets (e.g. smart phone and smart pads) opening a tremendous useful and interesting embedded system application that could be integrated into our house or known as the intelligent house. For example by putting a small embedded system web server in our house, we could easily monitor such as alarm, temperature or even turn on/off the lamp or the garden’s water sprinkle; eventually from any remote location through the wireless personal gadget; Or perhaps you just want to impress your relative or friend with a very accurate digital clock which automatically synchronized the time through the Network Time Protocol (NTP) over the internet at your home or office.

All of these interesting and challenging embedded system applications could be accomplished by integrating the Ethernet protocol which is formed the basic of the communication protocol used in the internet into the embedded system. Currently there are several approaches for this solution but basically they could be divided into two categories wired e.g. Wiznet W5100, W5300, Microchip ENC28J60 and wireless such as the Microchip ZG2100MC Wi-Fi module (recently is acquired by Microchip from the Zero-G Wireless on Jan 11, 2010).

On this tutorial we are going to build the embedded web server using the Wiznet WIZ811MJ network module which is based on the Wiznet well known W5100 TCP/IP hardwired chip that include the ethernet controller physical layer (PHY). The WIZ811MJ network module comes with the Wiznet W5100 chip, MAG-JACK (RJ45) together with the glued logic needed to communicate with the microcontroller through the SPI or bus interface.

The reason I choose the Wiznet 5100 based chip on this tutorial because this chip has the TCP/IP hardwired on it; therefore it will make developing the TCP/IP protocol stack based application much easier and could be implemented on the small RAM size microcontroller class compared to the firmware TCP/IP protocols stack based implementation approach (you don’t have to know everything about the TCP/IP protocol stack in order to be able to use this chip). The other reason is because the Wiznet 5100 chip has been around for a few years in the market and has already being matured. This chip is used in many commercial applications such as the Arduino framework on their standard Arduino Ethernet shield as shown on this following picture.

Ok, now lets list down the necessary electronics components and supported software for this tutorial and make sure you have the AVR ATMega328 microcontroller datasheet near you:

Resistors: 10K Ohm (1), 1K Ohm (1) and 470 Ohm (2)
Capacitors: 10uF/16v (2) and 0.1uF (2)
LEDS: 3 mm Blue LED (2)
Transistor: 2N3904 (1)
Voltage Regulator IC: LM1086 - 3.3 Volt
One momentary push button
One 30×60 mm Prototype board
Two 10 pins male double header and 5 pins male single header
One 2 pins male single polarized header
AVRJazz Mega328 board and JazzMate 5 Volt voltage regulator board from ermicro
Wiznet WIZ811MJ Network Module
Atmel AVR Studio version 4.17 IDE
WinAVR AVR-GCC 4.3.2; avr-libc 1.6.6 (WinAVR 20090313)
Reference Document: W5100 Datasheet, WIZ811MJ Datasheet, W5100 Porting Guide, Atmel AVR ATMega328 Datasheet.

The Wiznet W5100 Hardwired TCP/IP Protocol Chip

Basically the Wiznet W5100 implements a full-featured of standard IEEE 802.3 (Ethernet physical and data link layer) and powerful TCP/IP stack inside the chip; this make the Wiznet W5100 chip is suitable choice for integrating the embedded system into the internet. Programming the Wiznet W5100 chip is also easier as we just need to write and read to and from the W5100 internal registers in order to use the build-in TCP/IP protocol features.

The Wiznet W5100 chip come with three method of controlling its internal registers; this first two is to use the parallel direct or indirect bus, the last one is to use a well known embedded serial data transfer known as the SPI (serial peripheral interface), on this tutorial we are going to use the SPI to control the Wiznet W5100 chip. You could read more about SPI on my previous posted blog Using Serial Peripheral Interface (SPI) Master and Slave with Atmel AVR Microcontroller. The basic SPI connection between the Wiznet WIZ811MJ network module and Atmel AVR ATMega328 microcontroller is shown on this following picture.

The Wiznet W5100 will act as the SPI slave device controlled by Atmel AVR ATMega328 microcontroller as the SPI Master. The SPI protocol need at least four signal i.e. MOSI (Master Out Serial In), MISO (Master In Serial Out), SCK (signal clock provided by the master) and CS (the SPI slave chip select). Although the AVR ATMega328 microcontroller support all the SPI modes (i.e. 0,1,2 and 3) but the Wiznet W5100 chip support the most SPI common modes (mode 0 and mode 3) where it will sample a data on rising edge clock and outputting on the falling edge clock. The W5100 chip also provides the interrupt pin, but on this tutorial we don’t use the interrupt feature, instead we use a pooling method to control the W5100 operation.

In order to understand of how we control the Wiznet W5100 as the SPI slave device, we are going to create the W5100 initialization program; so it will response to the simple “ping” network command (ICMP protocol). The following is the complete C code called “wiznetping.c” for initializing the Wiznet W5100 chip.

/*****************************************************************************
//  File Name    : wiznetping.c
//  Version      : 1.0
//  Description  : Wiznet W5100
//  Author       : RWB
//  Target       : AVRJazz Mega168 Board
//  Compiler     : AVR-GCC 4.3.2; avr-libc 1.6.6 (WinAVR 20090313)
//  IDE          : Atmel AVR Studio 4.17
//  Programmer   : AVRJazz Mega168 STK500 v2.0 Bootloader
//               : AVR Visual Studio 4.17, STK500 programmer
//  Last Updated : 01 July 2010
*****************************************************************************/
#include 
#include 
#include 
#include 

#define BAUD_RATE 19200

// AVRJazz Mega168/328 SPI I/O
#define SPI_PORT PORTB
#define SPI_DDR  DDRB
#define SPI_CS   PORTB2

// Wiznet W5100 Op Code

#define WIZNET_WRITE_OPCODE 0xF0
#define WIZNET_READ_OPCODE 0x0F

// Wiznet W5100 Register Addresses
#define MR   0x0000   // Mode Register
#define GAR  0x0001   // Gateway Address: 0x0001 to 0x0004
#define SUBR 0x0005   // Subnet mask Address: 0x0005 to 0x0008
#define SAR  0x0009   // Source Hardware Address (MAC): 0x0009 to 0x000E
#define SIPR 0x000F   // Source IP Address: 0x000F to 0x0012
#define RMSR 0x001A   // RX Memory Size Register
#define TMSR 0x001B   // TX Memory Size Register

void uart_init(void)
{
  UBRR0H = (((F_CPU/BAUD_RATE)/16)-1)>>8;	// set baud rate
  UBRR0L = (((F_CPU/BAUD_RATE)/16)-1);
  UCSR0B = (1<
void uart_flush(void)
{
  unsigned char dummy;
  while (UCSR0A & (1<
int uart_putch(char ch,FILE *stream)
{
   if (ch == '\n')
    uart_putch('\r', stream);
   while (!(UCSR0A & (1<
   return 0;
}
int uart_getch(FILE *stream)
{
   unsigned char ch;
   while (!(UCSR0A & (1<
void ansi_cl(void)
{
  // ANSI clear screen: cl=\E[H\E[J
  putchar(27);
  putchar('[');
  putchar('H');
  putchar(27);
  putchar('[');
  putchar('J');
}
void ansi_me(void)
{
  // ANSI turn off all attribute: me=\E[0m
  putchar(27);
  putchar('[');
  putchar('0');
  putchar('m');
}
void SPI_Write(unsigned int addr,unsigned char data)
{
  // Activate the CS pin
  SPI_PORT &= ~(1<
  // Start Wiznet W5100 Write OpCode transmission
  SPDR = WIZNET_WRITE_OPCODE;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address High Bytes transmission
  SPDR = (addr & 0xFF00) >> 8;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address Low Bytes transmission
  SPDR = addr & 0x00FF;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Wait for transmission complete
  while(!(SPSR & (1<
  // CS pin is not active
  SPI_PORT |= (1<
unsigned char SPI_Read(unsigned int addr)
{
  // Activate the CS pin
  SPI_PORT &= ~(1<
  // Start Wiznet W5100 Read OpCode transmission
  SPDR = WIZNET_READ_OPCODE;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address High Bytes transmission
  SPDR = (addr & 0xFF00) >> 8;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address Low Bytes transmission
  SPDR = addr & 0x00FF;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Wait for transmission complete
  while(!(SPSR & (1<
  return(SPDR);
}
void W5100_Init(void)
{
  // Ethernet Setup
  unsigned char mac_addr[] = {0x00,0x16,0x36,0xDE,0x58,0xF6};
  unsigned char ip_addr[] = {192,168,2,10};
  unsigned char sub_mask[] = {255,255,255,0};
  unsigned char gtw_addr[] = {192,168,2,1};
  // Setting the Wiznet W5100 Mode Register: 0x0000
  SPI_Write(MR,0x80);            // MR = 0b10000000;
  _delay_ms(1);
  printf("Reading MR: %d\n\n",SPI_Read(MR));
  // Setting the Wiznet W5100 Gateway Address (GAR): 0x0001 to 0x0004
  printf("Setting Gateway Address %d.%d.%d.%d\n",gtw_addr[0],gtw_addr[1],\
          gtw_addr[2],gtw_addr[3]);
  SPI_Write(GAR + 0,gtw_addr[0]);
  SPI_Write(GAR + 1,gtw_addr[1]);
  SPI_Write(GAR + 2,gtw_addr[2]);
  SPI_Write(GAR + 3,gtw_addr[3]);
  _delay_ms(1);
  printf("Reading GAR: %d.%d.%d.%d\n\n",SPI_Read(GAR + 0),SPI_Read(GAR + 1),\
          SPI_Read(GAR + 2),SPI_Read(GAR + 3));
  // Setting the Wiznet W5100 Source Address Register (SAR): 0x0009 to 0x000E
  printf("Setting Source Address %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",mac_addr[0],mac_addr[1],\
          mac_addr[2],mac_addr[3],mac_addr[4],mac_addr[5]);
  SPI_Write(SAR + 0,mac_addr[0]);
  SPI_Write(SAR + 1,mac_addr[1]);
  SPI_Write(SAR + 2,mac_addr[2]);
  SPI_Write(SAR + 3,mac_addr[3]);
  SPI_Write(SAR + 4,mac_addr[4]);
  SPI_Write(SAR + 5,mac_addr[5]);
  _delay_ms(1);
  printf("Reading SAR: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n\n",SPI_Read(SAR + 0),SPI_Read(SAR + 1),\
          SPI_Read(SAR + 2),SPI_Read(SAR + 3),SPI_Read(SAR + 4),SPI_Read(SAR + 5));
  // Setting the Wiznet W5100 Sub Mask Address (SUBR): 0x0005 to 0x0008
  printf("Setting Sub Mask Address %d.%d.%d.%d\n",sub_mask[0],sub_mask[1],\
          sub_mask[2],sub_mask[3]);
  SPI_Write(SUBR + 0,sub_mask[0]);
  SPI_Write(SUBR + 1,sub_mask[1]);
  SPI_Write(SUBR + 2,sub_mask[2]);
  SPI_Write(SUBR + 3,sub_mask[3]);
  _delay_ms(1);
  printf("Reading SUBR: %d.%d.%d.%d\n\n",SPI_Read(SUBR + 0),SPI_Read(SUBR + 1),\
          SPI_Read(SUBR + 2),SPI_Read(SUBR + 3));
  // Setting the Wiznet W5100 IP Address (SIPR): 0x000F to 0x0012
  printf("Setting IP Address %d.%d.%d.%d\n",ip_addr[0],ip_addr[1],\
          ip_addr[2],ip_addr[3]);
  SPI_Write(SIPR + 0,ip_addr[0]);
  SPI_Write(SIPR + 1,ip_addr[1]);
  SPI_Write(SIPR + 2,ip_addr[2]);
  SPI_Write(SIPR + 3,ip_addr[3]);
  _delay_ms(1);
  printf("Reading SIPR: %d.%d.%d.%d\n\n",SPI_Read(SIPR + 0),SPI_Read(SIPR + 1),\
          SPI_Read(SIPR + 2),SPI_Read(SIPR + 3));

  // Setting the Wiznet W5100 RX and TX Memory Size, we use 2KB for Rx/Tx 4 channels
  printf("Setting Wiznet RMSR and TMSR\n\n");
  SPI_Write(RMSR,0x55);
  SPI_Write(TMSR,0x55);
  printf("Done Wiznet W5100 Initialized!\n");
}
// Assign I/O stream to UART
FILE uart_str = FDEV_SETUP_STREAM(uart_putch, uart_getch, _FDEV_SETUP_RW);
int main(void){
  // Set the PORTD as Output:
  DDRD=0xFF;
  PORTD=0x00;
   // Define Output/Input Stream
  stdout = stdin = &uart_str;
  // Initial UART Peripheral
  uart_init();
  // Clear Screen
  ansi_me();
  ansi_cl();
  ansi_me();
  ansi_cl();
  uart_flush();
  // Initial the AVR ATMega168/328 SPI Peripheral
  // Set MOSI (PORTB3),SCK (PORTB5) and PORTB2 (SS) as output, others as input
  SPI_DDR = (1<
  // CS pin is not active
  SPI_PORT |= (1<
  // Enable SPI, Master Mode 0, set the clock rate fck/2
  SPCR = (1<
  // Initial the Wiznet W5100
  printf("Wiznet W5100 Init\n\n");
  W5100_Init();
  // Loop forever
  for(;;){
  }
  return 0;
}
/* EOF: wiznetping.c */
After compiling and downloading the HEX program into the AVRJazz Mega328 board; connect the RJ45 connector UTP ethernet cable to your hubs/switch or you could connect directly with the cross configuration cable to your computer. Use the serial terminal such as Hyperterminal, puTTY or Tera Term and configure it to accept the serial connection with 19200 baud rate, 8-bit data with No Parity Check.
Now you are ready to test your first embedded Ethernet by using the “ping” command as shown on these following pictures:




Wiznet W5100 SPI Initialization 
To initialize the W5100 chip, we need to write on each of the W5100 common registers named MR (Mode Register), SUBR (Subnet mask Register), SAR (Source Hardware Register), SIPR (Source IP Register), RMSR (Receive Memory Size Register) and TMSR (Transmit Memory Size Register).

All the Wiznet W5100 registers address has 16-bits wide and the register it self is 8-bits wide; because we use 8-bit AVR ATMega328 microcontroller SPI, therefore in order to perform write or read operation we need to pass the first 8-bit MSB (most significant byte) and follow by the 8-bit LSB (least significant byte) of the W5100 register address. The Wiznet W5100 also use two operant commands to differentiate between the WRITE (0xF0) and READ (0×0F) operation. The Wiznet W5100 SPI write and read routine is implemented in the SPI_Write() and SPI_Read() functions on the above C code.
The SAR registers is also known as the MAC (Media Access Control) address, this W5100 register will represent the unique hardware identification in the network. The MAC address is assigned and managed by Institute of Electrical and Electronics Engineers (IEEE) for each NIC (Network Interface Card) manufacturer where the first 3 bytes of 6 bytes MAC address is used to identify the organization that issued the identifier and are known as the OUI (Organizationally Unique Identifier). For example the following are the list of Atmel, Microchip and Wiznet OUI:
00-04-25   (hex)      Atmel Corporation
000425     (base 16)  Atmel Corporation
                      Multimedia & Communications Group
                      2200 Gateway Centre, Suite 201
                      Morrisville NC 27560
                      UNITED STATES
00-04-A3   (hex)      Microchip Technology, Inc.
0004A3     (base 16)  Microchip Technology, Inc.
                      2355 W. Chandler Blvd.
                      Chandler AZ 85224
                      UNITED STATES
00-08-DC   (hex)      Wiznet
0008DC     (base 16)  Wiznet
                      5F Simmtech bldg., 228-3,
                      Nonyhun, Kangnam
                      Seoul  135-830
                      KOREA, REPUBLIC OF
Now the question is how you could get your own MAC address because the Wiznet W5100 chip is shipped without its own MAC address; the answer is you could either register your own MAC address (OUI) to IEEE (of course this is not recommended for the hobbyist as this will be very expensive unless you could effort it) or you could simply use your own computer NIC’s MAC address and just change the last byte of the 6 byte MAC address and cross you finger, hopping this MAC address will be unique within your network as I did. By using the “ipconfig /all” command in the window command prompt, you could get the information of your computer MAC address in hex notation i.e. 00-16-36-DE-58-F5 (the MAC address of my computer); now by adding one to the last byte you will get the W5100 MAC address that I used in this tutorial (00-16-36-DE-58-F6).
The Wiznet W5100 support up to four simultaneous channels or sockets, each of the channels has its own registers address to control the operation. All of these channels is supported by 8 KB memory of the transmit buffer and 8 KB memory of the receive buffer. We could adjust this memory size on each channel by assigning the RMSR and TMSR register (the default is 2 KB for each channel) as shown on this following C code:
  // Setting the Wiznet W5100 RX and TX Memory Size, we use 2KB for Rx/Tx 4 channels
  printf("Setting Wiznet RMSR and TMSR\n\n");
  SPI_Write(RMSR,0x55);
  SPI_Write(TMSR,0x55);
All the W5100 initialization routine is implemented in W5100_Init() function, where we perform both writing and reading in order to understand how we could control the W5100 register through the SPI. The following is the summary of how we initialized the W5100 register. For the complete information about the W5100 registers please refer to the Wiznet W5100 datasheet (consider it as your best friend in this tutorial):

Write 0×80 to W5100 MR (Mode Register) on address: 0×0000 to soft reset the chip
Assign four bytes of the gateway IP address to the W5100 GAR (Gateway Address Register) on address 0×0001 to 0×0004
Assign four bytes of the sub mask address to the W5100 SUBR (Sub Mask Address Register) on address 0×0005 to 0×0008
Assign six bytes of the MAC address to the W5100 SAR (Source Address Register) on address 0×0009 to 0×000E
Assign four bytes of the IP address to the W5100 SIPR (Source IP Register) on address 0×000F to 0×0012
The last is to allocate the transmit and receive buffer size to each of RMSR (RX Memory Size Register) address: 0×001A and TMSR (TX Memory Size Register) on address 0×001B.
Because we use the default value 0×07D0 (200 ms, where 1 mean 100 us) of the RTR (Retry Time Value Register) and default value 0×08 (8 times retry before generating interrupt) of the RCR (Retry Count Register), therefore we don’t need to set these registers

After performing all the W5100 required initialization routine you could examine whether it work or not by sending the “ping” command to the W5100 build in ICMP (Internet Control Message Protocol) package responder. If everything works, then you will get the ICMP reply from the Wiznet W5100 chip. With this understanding now we are ready to continue this tutorial and make our first simple embedded web server.
The Embedded Web Server
The advantage of using the Hypertext Transfer Protocol (HTTP) server in the embedded system is; you don’t have to develop a special client application to communicate with your embedded system. All you need is to use any standard browser that comes with your personal computer operating system or gadget to talk to your embedded system. The HTTP server uses a simple text called Hypertext Markup Language (HTML) to interact with the browser (client application) through the TCP/IP protocol.

The HTTP server work by listening to any request from the client (browser) for any HTTP “GET” or “POST” request through the TCP/IP port 80 (standard HTTP server port). Once the client sends this request to the HTTP server, then the HTTP server will response to this client request by sending the HTTP response header (HTTP/1.0 200 OK and Content-Type: text/html) follow by the blank line and the HTML text to the client, after transfer all the HTML text to the client; the HTTP server will automatically disconnect the established connection with the client. The following is the example of the client request and the HTML text response transmitted by the embedded HTTP server:
Client Request:
GET / HTTP/1.1
Host: 192.168.2.101
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2.3) Gecko/20
100401 Firefox/3.6.3
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
HTTP Server Response:
HTTP/1.0 200 OK
Content-Type: text/html



Embedded Web Server
AVRJazz Mega328 and WIZ811MJ

Temp:  ^OC
Blinking LED

Scanning LED





The client then will translate this received HTML text and display the information on the browser screen such as room’s temperature and the output LED status. By submitting different LED setting from the browser (POST request) to the HTTP server, now we could easily give the needed instruction to the AVR ATMega328 microcontroller that also functioned as the embedded web server.
Now as you understand the basic principal of how the HTTP server protocol work, its time to implement it on the AVR ATMega328 Microcontroller and Wiznet W5100 chip. The following is the complete C code called “wiznetweb.c” for our embedded web server:
/*****************************************************************************
//  File Name    : wiznetweb.c
//  Version      : 1.0
//  Description  : AVRJazz Mega328 and Wiznet W5100 Web Server
//  Author       : RWB
//  Target       : AVRJazz Mega328 Board
//  Compiler     : AVR-GCC 4.3.2; avr-libc 1.6.6 (WinAVR 20090313)
//  IDE          : Atmel AVR Studio 4.17
//  Programmer   : AVRJazz Mega328 STK500 v2.0 Bootloader
//               : AVR Visual Studio 4.17, STK500 programmer
//  Last Updated : 20 July 2010
*****************************************************************************/
#include 
#include 
#include 
#include 
#include 
#include 
// AVRJazz Mega328 SPI I/O
#define SPI_PORT PORTB
#define SPI_DDR  DDRB
#define SPI_CS   PORTB2
// Wiznet W5100 Op Code
#define WIZNET_WRITE_OPCODE 0xF0
#define WIZNET_READ_OPCODE 0x0F
// Wiznet W5100 Register Addresses
#define MR         0x0000      // Mode Register
#define GAR        0x0001      // Gateway Address: 0x0001 to 0x0004
#define SUBR       0x0005      // Subnet mask Address: 0x0005 to 0x0008
#define SAR        0x0009      // Source Hardware Address (MAC): 0x0009 to 0x000E
#define SIPR       0x000F      // Source IP Address: 0x000F to 0x0012
#define RMSR       0x001A      // RX Memory Size Register
#define TMSR       0x001B      // TX Memory Size Register
#define S0_MR	   0x0400      // Socket 0: Mode Register Address
#define S0_CR	   0x0401      // Socket 0: Command Register Address
#define S0_IR	   0x0402      // Socket 0: Interrupt Register Address
#define S0_SR	   0x0403      // Socket 0: Status Register Address
#define S0_PORT    0x0404      // Socket 0: Source Port: 0x0404 to 0x0405
#define SO_TX_FSR  0x0420      // Socket 0: Tx Free Size Register: 0x0420 to 0x0421
#define S0_TX_RD   0x0422      // Socket 0: Tx Read Pointer Register: 0x0422 to 0x0423
#define S0_TX_WR   0x0424      // Socket 0: Tx Write Pointer Register: 0x0424 to 0x0425
#define S0_RX_RSR  0x0426      // Socket 0: Rx Received Size Pointer Register: 0x0425 to 0x0427
#define S0_RX_RD   0x0428      // Socket 0: Rx Read Pointer: 0x0428 to 0x0429
#define TXBUFADDR  0x4000      // W5100 Send Buffer Base Address
#define RXBUFADDR  0x6000      // W5100 Read Buffer Base Address
// S0_MR values
#define MR_CLOSE	  0x00    // Unused socket
#define MR_TCP		  0x01    // TCP
#define MR_UDP		  0x02    // UDP
#define MR_IPRAW	  0x03	  // IP LAYER RAW SOCK
#define MR_MACRAW	  0x04	  // MAC LAYER RAW SOCK
#define MR_PPPOE	  0x05	  // PPPoE
#define MR_ND		  0x20	  // No Delayed Ack(TCP) flag
#define MR_MULTI	  0x80	  // support multicating
// S0_CR values
#define CR_OPEN          0x01	  // Initialize or open socket
#define CR_LISTEN        0x02	  // Wait connection request in tcp mode(Server mode)
#define CR_CONNECT       0x04	  // Send connection request in tcp mode(Client mode)
#define CR_DISCON        0x08	  // Send closing reqeuset in tcp mode
#define CR_CLOSE         0x10	  // Close socket
#define CR_SEND          0x20	  // Update Tx memory pointer and send data
#define CR_SEND_MAC      0x21	  // Send data with MAC address, so without ARP process
#define CR_SEND_KEEP     0x22	  // Send keep alive message
#define CR_RECV          0x40	  // Update Rx memory buffer pointer and receive data
// S0_SR values
#define SOCK_CLOSED      0x00     // Closed
#define SOCK_INIT        0x13	  // Init state
#define SOCK_LISTEN      0x14	  // Listen state
#define SOCK_SYNSENT     0x15	  // Connection state
#define SOCK_SYNRECV     0x16	  // Connection state
#define SOCK_ESTABLISHED 0x17	  // Success to connect
#define SOCK_FIN_WAIT    0x18	  // Closing state
#define SOCK_CLOSING     0x1A	  // Closing state
#define SOCK_TIME_WAIT	 0x1B	  // Closing state
#define SOCK_CLOSE_WAIT  0x1C	  // Closing state
#define SOCK_LAST_ACK    0x1D	  // Closing state
#define SOCK_UDP         0x22	  // UDP socket
#define SOCK_IPRAW       0x32	  // IP raw mode socket
#define SOCK_MACRAW      0x42	  // MAC raw mode socket
#define SOCK_PPPOE       0x5F	  // PPPOE socket
#define TX_BUF_MASK      0x07FF   // Tx 2K Buffer Mask:
#define RX_BUF_MASK      0x07FF   // Rx 2K Buffer Mask:
#define NET_MEMALLOC     0x05     // Use 2K of Tx/Rx Buffer
#define TCP_PORT         80       // TCP/IP Port
// Debugging Mode, 0 - Debug OFF, 1 - Debug ON
#define _DEBUG_MODE      0
#if _DEBUG_MODE
  #define BAUD_RATE 19200
#endif
// Define W5100 Socket Register and Variables Used
uint8_t sockreg;
#define MAX_BUF 512
uint8_t buf[MAX_BUF];
int tempvalue;
uint8_t ledmode,ledeye,ledsign;
#if _DEBUG_MODE
void uart_init(void)
{
  UBRR0H = (((F_CPU/BAUD_RATE)/16)-1)>>8;		// set baud rate
  UBRR0L = (((F_CPU/BAUD_RATE)/16)-1);
  UCSR0B = (1<
void uart_flush(void)
{
  unsigned char dummy;
  while (UCSR0A & (1<
int uart_putch(char ch,FILE *stream)
{
   if (ch == '\n')
    uart_putch('\r', stream);
   while (!(UCSR0A & (1<
   return 0;
}
int uart_getch(FILE *stream)
{
   unsigned char ch;
   while (!(UCSR0A & (1<
void ansi_cl(void)
{
  // ANSI clear screen: cl=\E[H\E[J
  putchar(27);
  putchar('[');
  putchar('H');
  putchar(27);
  putchar('[');
  putchar('J');
}
void ansi_me(void)
{
  // ANSI turn off all attribute: me=\E[0m
  putchar(27);
  putchar('[');
  putchar('0');
  putchar('m');
}
#endif
void SPI_Write(uint16_t addr,uint8_t data)
{
  // Activate the CS pin
  SPI_PORT &= ~(1<
  // Start Wiznet W5100 Write OpCode transmission
  SPDR = WIZNET_WRITE_OPCODE;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address High Bytes transmission
  SPDR = (addr & 0xFF00) >> 8;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address Low Bytes transmission
  SPDR = addr & 0x00FF;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Wait for transmission complete
  while(!(SPSR & (1<
  // CS pin is not active
  SPI_PORT |= (1<
unsigned char SPI_Read(uint16_t addr)
{
  // Activate the CS pin
  SPI_PORT &= ~(1<
  // Start Wiznet W5100 Read OpCode transmission
  SPDR = WIZNET_READ_OPCODE;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address High Bytes transmission
  SPDR = (addr & 0xFF00) >> 8;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Start Wiznet W5100 Address Low Bytes transmission
  SPDR = addr & 0x00FF;
  // Wait for transmission complete
  while(!(SPSR & (1<
  // Wait for transmission complete
  while(!(SPSR & (1<
  return(SPDR);
}
void W5100_Init(void)
{
  // Ethernet Setup
  unsigned char mac_addr[] = {0x00,0x16,0x36,0xDE,0x58,0xF6};
  unsigned char ip_addr[] = {192,168,2,10};
  unsigned char sub_mask[] = {255,255,255,0};
  unsigned char gtw_addr[] = {192,168,2,1};
  // Setting the Wiznet W5100 Mode Register: 0x0000
  SPI_Write(MR,0x80);            // MR = 0b10000000;
  // Setting the Wiznet W5100 Gateway Address (GAR): 0x0001 to 0x0004
  SPI_Write(GAR + 0,gtw_addr[0]);
  SPI_Write(GAR + 1,gtw_addr[1]);
  SPI_Write(GAR + 2,gtw_addr[2]);
  SPI_Write(GAR + 3,gtw_addr[3]);
  // Setting the Wiznet W5100 Source Address Register (SAR): 0x0009 to 0x000E
  SPI_Write(SAR + 0,mac_addr[0]);
  SPI_Write(SAR + 1,mac_addr[1]);
  SPI_Write(SAR + 2,mac_addr[2]);
  SPI_Write(SAR + 3,mac_addr[3]);
  SPI_Write(SAR + 4,mac_addr[4]);
  SPI_Write(SAR + 5,mac_addr[5]);
  // Setting the Wiznet W5100 Sub Mask Address (SUBR): 0x0005 to 0x0008
  SPI_Write(SUBR + 0,sub_mask[0]);
  SPI_Write(SUBR + 1,sub_mask[1]);
  SPI_Write(SUBR + 2,sub_mask[2]);
  SPI_Write(SUBR + 3,sub_mask[3]);
  // Setting the Wiznet W5100 IP Address (SIPR): 0x000F to 0x0012
  SPI_Write(SIPR + 0,ip_addr[0]);
  SPI_Write(SIPR + 1,ip_addr[1]);
  SPI_Write(SIPR + 2,ip_addr[2]);
  SPI_Write(SIPR + 3,ip_addr[3]);    

  // Setting the Wiznet W5100 RX and TX Memory Size (2KB),
  SPI_Write(RMSR,NET_MEMALLOC);
  SPI_Write(TMSR,NET_MEMALLOC);
}
void close(uint8_t sock)
{
   if (sock != 0) return;

   // Send Close Command
   SPI_Write(S0_CR,CR_CLOSE);
   // Waiting until the S0_CR is clear
   while(SPI_Read(S0_CR));
}
void disconnect(uint8_t sock)
{
   if (sock != 0) return;
   // Send Disconnect Command
   SPI_Write(S0_CR,CR_DISCON);
   // Wait for Disconecting Process
   while(SPI_Read(S0_CR));
}
uint8_t socket(uint8_t sock,uint8_t eth_protocol,uint16_t tcp_port)
{
    uint8_t retval=0;
    if (sock != 0) return retval;

    // Make sure we close the socket first
    if (SPI_Read(S0_SR) == SOCK_CLOSED) {
      close(sock);
    }
    // Assigned Socket 0 Mode Register
    SPI_Write(S0_MR,eth_protocol);

    // Now open the Socket 0
    SPI_Write(S0_PORT,((tcp_port & 0xFF00) >> 8 ));
    SPI_Write(S0_PORT + 1,(tcp_port & 0x00FF));
    SPI_Write(S0_CR,CR_OPEN);                   // Open Socket
    // Wait for Opening Process
    while(SPI_Read(S0_CR));
    // Check for Init Status
    if (SPI_Read(S0_SR) == SOCK_INIT)
      retval=1;
    else
      close(sock);

    return retval;
}
uint8_t listen(uint8_t sock)
{
   uint8_t retval = 0;
   if (sock != 0) return retval;
   if (SPI_Read(S0_SR) == SOCK_INIT) {
     // Send the LISTEN Command
     SPI_Write(S0_CR,CR_LISTEN);

     // Wait for Listening Process
     while(SPI_Read(S0_CR));
     // Check for Listen Status
     if (SPI_Read(S0_SR) == SOCK_LISTEN)
       retval=1;
     else
       close(sock);
    }
    return retval;
}
uint16_t send(uint8_t sock,const uint8_t *buf,uint16_t buflen)
{
    uint16_t ptr,offaddr,realaddr,txsize,timeout;   

    if (buflen <= 0 || sock != 0) return 0;
#if _DEBUG_MODE
    printf("Send Size: %d\n",buflen);
#endif
    // Make sure the TX Free Size Register is available
    txsize=SPI_Read(SO_TX_FSR);
    txsize=(((txsize & 0x00FF) << 8 ) + SPI_Read(SO_TX_FSR + 1));
#if _DEBUG_MODE
    printf("TX Free Size: %d\n",txsize);
#endif
    timeout=0;
    while (txsize < buflen) {
      _delay_ms(1);
     txsize=SPI_Read(SO_TX_FSR);
     txsize=(((txsize & 0x00FF) << 8 ) + SPI_Read(SO_TX_FSR + 1));
     // Timeout for approx 1000 ms
     if (timeout++ > 1000) {
#if _DEBUG_MODE
       printf("TX Free Size Error!\n");
#endif
       // Disconnect the connection
       disconnect(sock);
       return 0;
     }
   }	

   // Read the Tx Write Pointer
   ptr = SPI_Read(S0_TX_WR);
   offaddr = (((ptr & 0x00FF) << 8 ) + SPI_Read(S0_TX_WR + 1));
#if _DEBUG_MODE
    printf("TX Buffer: %x\n",offaddr);
#endif	

    while(buflen) {
      buflen--;
      // Calculate the real W5100 physical Tx Buffer Address
      realaddr = TXBUFADDR + (offaddr & TX_BUF_MASK);
      // Copy the application data to the W5100 Tx Buffer
      SPI_Write(realaddr,*buf);
      offaddr++;
      buf++;
    }

    // Increase the S0_TX_WR value, so it point to the next transmit
    SPI_Write(S0_TX_WR,(offaddr & 0xFF00) >> 8 );
    SPI_Write(S0_TX_WR + 1,(offaddr & 0x00FF));	

    // Now Send the SEND command
    SPI_Write(S0_CR,CR_SEND);

    // Wait for Sending Process
    while(SPI_Read(S0_CR));	

    return 1;
}
uint16_t recv(uint8_t sock,uint8_t *buf,uint16_t buflen)
{
    uint16_t ptr,offaddr,realaddr;   	

    if (buflen <= 0 || sock != 0) return 1;   

    // If the request size > MAX_BUF,just truncate it
    if (buflen > MAX_BUF)
      buflen=MAX_BUF - 2;
    // Read the Rx Read Pointer
    ptr = SPI_Read(S0_RX_RD);
    offaddr = (((ptr & 0x00FF) << 8 ) + SPI_Read(S0_RX_RD + 1));
#if _DEBUG_MODE
    printf("RX Buffer: %x\n",offaddr);
#endif	

    while(buflen) {
      buflen--;
      realaddr=RXBUFADDR + (offaddr & RX_BUF_MASK);
      *buf = SPI_Read(realaddr);
      offaddr++;
      buf++;
    }
    *buf='\0';        // String terminated character

    // Increase the S0_RX_RD value, so it point to the next receive
    SPI_Write(S0_RX_RD,(offaddr & 0xFF00) >> 8 );
    SPI_Write(S0_RX_RD + 1,(offaddr & 0x00FF));	

    // Now Send the RECV command
    SPI_Write(S0_CR,CR_RECV);
    _delay_us(5);    // Wait for Receive Process

    return 1;
}
uint16_t recv_size(void)
{
  return ((SPI_Read(S0_RX_RSR) & 0x00FF) << 8 ) + SPI_Read(S0_RX_RSR + 1);
}
int strindex(char *s,char *t)
{
  uint16_t i,n;

  n=strlen(t);
  for(i=0;*(s+i); i++) {
    if (strncmp(s+i,t,n) == 0)
      return i;
  }
  return -1;
}
ISR(TIMER0_OVF_vect)
{
  static unsigned char tenms=1;
  tenms++;                  // Read ADC every 20 x 10ms = 200 milisecond
  if (tenms >= 20) {
    cli();                                // Disable Interupt
    // Select the LED Mode here
    if (ledmode == 1) {
      if (ledeye <= 0) ledeye=0x01;
      if (ledsign == 0) {
	PORTD=ledeye;
	ledeye=ledeye << 1;
	if (ledeye >= 0x80) ledsign=1;
      } else {
	PORTD=ledeye;
	ledeye=ledeye >> 1;
	if (ledeye <= 0x01) ledsign=0;
      }
    } else {
      if (ledsign == 0) {
	PORTD=0x00;
	ledsign=1;
      } else {
	PORTD=0xFF;
	ledsign=0;
      }
    }
    // Set ADMUX Channel for LM35DZ Input
    ADMUX=0x01;
    // Start conversion by setting ADSC on ADCSRA Register
    ADCSRA |= (1<
    // wait until convertion complete ADSC=0 -> Complete
    while (ADCSRA & (1<
    // Get the ADC Result
    tempvalue = ADCW;
    // ADC = (Vin x 1024) / Vref, Vref = 1 Volt, LM35DZ Out = 10mv/C
    tempvalue = (int)(tempvalue) / 10.24;

    tenms=1;	 

    sei();                            // Enable Interupt
  }
  // Start counter from 0x94, overflow at 10 mSec
  TCNT0=0x94;
}
#if _DEBUG_MODE
// Assign I/O stream to UART
FILE uart_str = FDEV_SETUP_STREAM(uart_putch, uart_getch, _FDEV_SETUP_RW);
#endif
int main(void){
  uint8_t sockstat;
  uint16_t rsize;
  char radiostat0[10],radiostat1[10],temp[4];
  int getidx,postidx;

  // Reset Port D
  DDRD = 0xFF;       // Set PORTD as Output
  PORTD = 0x00;	     

#if _DEBUG_MODE
  // Define Output/Input Stream
  stdout = stdin = &uart_str;
  // Initial UART Peripheral
  uart_init();
  // Clear Screen
  ansi_me();
  ansi_cl();
  ansi_me();
  ansi_cl();
  uart_flush();
#endif
  // Initial ATMega386 ADC Peripheral
  ADCSRA = (1<
  // Free running ADC Mode
  ADCSRB = 0x00;
  // Initial the AVR ATMega328 SPI Peripheral
  // Set MOSI (PORTB3),SCK (PORTB5) and PORTB2 (SS) as output, others as input
  SPI_DDR = (1<
  // CS pin is not active
  SPI_PORT |= (1<
  // Enable SPI, Master Mode 0, set the clock rate fck/2
  SPCR = (1<
  // Initial variable used
  sockreg=0;
  tempvalue=0;
  ledmode=1;
  ledeye=0x01;                  // Initial LED Eye Variables
  ledsign=0;
#if _DEBUG_MODE
  printf("WEB Server Debug Mode\n\n");
#endif

  // Loop forever
  for(;;){
    sockstat=SPI_Read(S0_SR);
    switch(sockstat) {
     case SOCK_CLOSED:
        if (socket(sockreg,MR_TCP,TCP_PORT) > 0) {
	  // Listen to Socket 0
	  if (listen(sockreg) <= 0)
	    _delay_ms(1);
#if _DEBUG_MODE
          printf("Socket Listen!\n");
#endif
	}
	break;
     case SOCK_ESTABLISHED:
	// Get the client request size
        rsize=recv_size();
#if _DEBUG_MODE
	printf("Size: %d\n",rsize);
#endif
	if (rsize > 0) {
	  // Now read the client Request
	  if (recv(sockreg,buf,rsize) <= 0) break;
#if _DEBUG_MODE
  	  printf("Content:\n%s\n",buf);
#endif
          // Check the Request Header
	  getidx=strindex((char *)buf,"GET /");
	  postidx=strindex((char *)buf,"POST /");
	  if (getidx >= 0 || postidx >= 0) {
#if _DEBUG_MODE
	    printf("Req. Check!\n");
#endif
            // Now check the Radio Button for POST request
	    if (postidx >= 0) {
	      if (strindex((char *)buf,"radio=0") > 0)
	        ledmode=0;
	      if (strindex((char *)buf,"radio=1") > 0)
	        ledmode=1;
            }
#if _DEBUG_MODE
	    printf("Req. Send!\n");
#endif
	    // Create the HTTP Response	Header
	    strcpy_P((char *)buf,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
	    strcat_P((char *)buf,PSTR("\r\n"));
	    strcat_P((char *)buf,PSTR("Embedded Web Server\r\n"));
	    strcat_P((char *)buf,PSTR("AVRJazz Mega328 and WIZ811MJ\r\n"));
	    strcat_P((char *)buf,PSTR("
\r\n"));
	    // Now Send the HTTP Response
	    if (send(sockreg,buf,strlen((char *)buf)) <= 0) break;

	    // Create the HTTP Temperature Response
	    sprintf((char *)temp,"%d",tempvalue);        // Convert temperature value to string
	    strcpy_P((char *)buf,PSTR("Temp:  ^OC\r\n"));									

	    if (ledmode == 1) {
	      strcpy(radiostat0,"");
	      strcpy_P(radiostat1,PSTR("checked"));
	    } else {
	      strcpy_P(radiostat0,PSTR("checked"));
	      strcpy(radiostat1,"");
	    }

            // Create the HTTP Radio Button 0 Response
	    strcat_P((char *)buf,PSTR("Blinking LED\r\n"));
	    strcat_P((char *)buf,PSTR("
Scanning LED\r\n"));
 	    strcat_P((char *)buf,PSTR("
\r\n"));
	    strcat_P((char *)buf,PSTR("\r\n"));
	    strcat_P((char *)buf,PSTR("\r\n"));
            // Now Send the HTTP Remaining Response
	    if (send(sockreg,buf,strlen((char *)buf)) <= 0) break;
          }
	  // Disconnect the socket
	  disconnect(sockreg);
        } else
	  _delay_us(10);    // Wait for request
	break;
      case SOCK_FIN_WAIT:
      case SOCK_CLOSING:
      case SOCK_TIME_WAIT:
      case SOCK_CLOSE_WAIT:
      case SOCK_LAST_ACK:
        // Force to close the socket
	close(sockreg);
#if _DEBUG_MODE
	printf("Socket Close!\n");
#endif
	break;
    }
  }
  return 0;
}
/* EOF: wiznetweb.c */
From the C code above you’ve noticed that I used many of the Atmel AVR ATMega328 microcontroller build in peripherals features such as SPI, ADC, TIMER and the UART at the same time in order to achieve the project’s goal, you could read more information of how to use all of these peripherals on my previous posted blog Analog to Digital Converter AVR C Programming and Working with AVR microcontroller Communication Port Project.


The W5100 HTTP Server 
To build the HTTP server we need to listen for the client request, read the client request and send the HTML response to the client through the TCP/IP protocol. To configure and control the Wiznet W5100 as the HTTP server basically we need to write and read to and from the Wiznet W5100 Socket Control Register and the TX and RX buffer memory; for the purpose of this tutorial (easier to understand) I only implement one channel (socket 0) of the four available channels (socket 0, 1, 2 and 3) supported by the W5100 chip. But once you understand the basic principal of how the W5100 work on this tutorial it would be easy to implement the remaining channels.
The Wiznet W5100 socket 0 control registers start at address 0×0400 to 0×04FF, the following is the list of W5100 socket 0 control registers with the 2 KB of TX and RX memory buffer used to make the HTTP server in this tutorial (again please refer to the W5100 datasheet for detail information).

Now fasten your seat belt as we are going through the code algorithm behind this W5100 HTTP server program!
Basically we use the command register (S0_CR) to instruct the W5100 chip to write or read to or from the W5100 memory buffer to make a simple HTTP server that response to the client request. The following diagram show of how we could achieve this objective:

From the diagram above after we initialized the W5100 (i.e. it could response to the “ping” command request) we continue with opening the TCP/IP port 80 and listen to this port for any client request. Assigning the TCP/IP protocol and opening the port 80 routine is implemented in the socket() function as shown on this following C code:
...
// Assigned Socket 0 Mode Register
SPI_Write(S0_MR,eth_protocol);

// Now open the Socket 0
SPI_Write(S0_PORT,((tcp_port & 0xFF00) >> 8 ));
SPI_Write(S0_PORT + 1,(tcp_port & 0x00FF));
SPI_Write(S0_CR,CR_OPEN);                   // Open Socket
// Wait for Opening Process
while(SPI_Read(S0_CR));
...
After we wrote the CR_OPEN (0×01) command on the socket 0 command register (S0_CR), then the W5100 will automatically clear this register; therefore we could take advantage of this behavior by reading this register again and examine its contents. Upon completion of the command execution process the contents of the SO_CR register will be reset to 0×00 and the socket 0 status register (S0_SR) will be set to the SOCK_INIT (0×13) status.
Listening to the opening TCP/IP port (i.e. 80) could be done by sending the CR_LISTEN (0×02) command to the socket 0 command register (S0_CR), this will change the socket 0 status register (S0_SR) to the SOCK_LISTEN (0×14) status. The listening routine is implemented in the listen() function. Now the Wiznet W5100 is ready to receive the request from client (browser).
When the client established the connection with the HTTP server, it will send the standard HTTP request protocol to the HTTP server. We could examine whether the connection has been established with the client by reading the status register (SO_CR) for SOCK_ESTABLISHED (0×17) status. Next we examine the RX receive data size by reading the socket 0 received size register (SO_RX_RSR); this routine is implemented in recv_size() function bellow:
uint16_t recv_size(void)
{
  return ((SPI_Read(S0_RX_RSR) & 0x00FF) << 8 ) + SPI_Read(S0_RX_RSR + 1);
}
If the received data exist in the RX buffer memory then we continue to read the RX memory buffer content which is implemented in recv() function. The reading process is accomplished by first calculating the received data physical address location at the 2 KB (2048 or 0×800 in hex notations) RX memory buffer boundary and then start to read the data from this location. The following picture show of how we determine the physical address of the received data.

To determine the Wiznet W5100 RX memory buffer physical address where we start to read the received data we have to mask the value returned by the socket 0 RX read pointer (S0_RX_RD) with the 0×7FF (2 KB minus one in hex notations) and add the result to the RX memory buffer base address 0×6000. Next we use this address result to retrieve the data from RX memory buffer as shown on this following C code:
...
// Read the Rx Read Pointer
ptr = SPI_Read(S0_RX_RD);
offaddr = (((ptr & 0x00FF) << 8 ) + SPI_Read(S0_RX_RD + 1));

while(buflen) {
  buflen--;
  realaddr=RXBUFADDR + (offaddr & RX_BUF_MASK);
  *buf = SPI_Read(realaddr);
  offaddr++;
  buf++;
}
*buf='\0';        // String terminated character
...
After reading all the data we need to write the last pointer value back to the socket 0 RX read pointer register (S0_RX_RD) so the W5100 RX received circular buffer mechanism will know where to put the next received data on the RX memory buffer as shown on this following C code:
...
// Increase the S0_RX_RD value, so it point to the next receive
SPI_Write(S0_RX_RD,(offaddr & 0xFF00) >> 8 );
SPI_Write(S0_RX_RD + 1,(offaddr & 0x00FF));
...
Finally we give the CR_RECV (0×40) to the W5100 socket 0 command register (S0_CR) to complete the W5100 receiving process (updating the RX memory buffer pointer and  received data).
...
// Now Send the RECV command
SPI_Write(S0_CR,CR_RECV);
_delay_us(5);    // Wait for Receive Process
...
The HTTP server will send the response after examining the client request; on this tutorial the response will be the room’s temperature read by the AVR ATMega328 microcontroller ADC peripheral through the AVRJazz Mega328 on board LM35DZ temperature sensor and setting the LED display. In order to save the microcontroller RAM; all the static HTML data is stored in the flash program memory (flash RAM) use a special AVR-GCC PSTR macro and string manipulation functions such as strcpy_P() and strcat_P() to work with static string data stored in the flash program memory as shown on this following C code:
...
// Create the HTTP Response Header
strcpy_P((char *)buf,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
strcat_P((char *)buf,PSTR("\r\n"));
strcat_P((char *)buf,PSTR("Embedded Web Server\r\n"));
...
After copying all the HTML response to the application buffer data (buf), now we are ready to send the response to the client. This function is implemented in the send() function. Before sending we need to check the availability of the W5100 TX memory buffer by reading the W5100 socket 0 free size register (S0_TX_FSR); on normal condition this register should return the value of 2 KB (0×0200) free. After examining this register we are ready to send data in the application buffer and use the same principal as receiving data to determine the actual TX buffer physical address as shown on this following diagram:

Similar to the read operation; to determine the Wiznet W5100 TX memory buffer physical address where we start to write the data we have to mask the value returned by the socket 0 TX write pointer (S0_TX_WR) with the 0×7FF (2 KB minus one in hex notations) and add the result to the TX memory buffer base address 0×4000. Next we use this address result to put the data to TX memory buffer as shown on this following C code:
...
// Read the Tx Write Pointer
ptr = SPI_Read(S0_TX_WR);
offaddr = (((ptr & 0x00FF) << 8 ) + SPI_Read(S0_TX_WR + 1));

while(buflen) {
  buflen--;
  // Calculate the real W5100 physical Tx Buffer Address
  realaddr = TXBUFADDR + (offaddr & TX_BUF_MASK);
  // Copy the application data to the W5100 Tx Buffer
  SPI_Write(realaddr,*buf);
  offaddr++;
  buf++;
}
...
After putting all the data to the TX memory buffer, we need to write the last pointer value back to the socket 0 TX write pointer register (S0_TX_WR) for the next TX memory buffer writing as shown on this following C code:
...
// Increase the S0_TX_WR value, so it point to the next transmit
SPI_Write(S0_TX_WR,(offaddr & 0xFF00) >> 8 );
SPI_Write(S0_TX_WR + 1,(offaddr & 0x00FF));
...
Next we need to write the CR_SEND (0×20) command to the W5100 socket 0 command register (S0_CR) to instruct the W5100 chip to send the HTML response data in the TX memory buffer.
...
// Now Send the SEND command
SPI_Write(S0_CR,CR_SEND);
...
To comply with the HTTP protocol requirement, after sending the HTML response to the client we need to disconnect and close the connection with the client. These routines are implemented in the disconnect() and close() functionsThese two functions simply send the CR_DISCON (0×08) and CR_CLOSE (0×10) to the W5100 socket 0 command register (S0_CR) respectively as shown on this following C code:
...
// Send Disconnect Command
SPI_Write(S0_CR,CR_DISCON);
...
...
// Send Close Command
SPI_Write(S0_CR,CR_CLOSE);
...
Next the infinite loop routine in main program will start opening and listening to the new client request and the whole process is repeated again.
The Temperature and LED Display Indicator
Before executing the for() infinite loop, first we initialized all the needed peripherals such as PORTD for displaying LED, UART for debugging, ADC for reading temperature sensor, SPI for communicating with the Wiznet W5100 chip and last TIMER0 for ADC conversion and controlling the LED display.
The HTTP server protocol handshaking is implemented inside the infinite loop and I use the AVR ATMega328 microcontroller TIMER0 to implement the temperature reading through the ADC peripheral and to control the LED display indicator. The AVR ATMega328 TIMER0 peripheral is being set to execute the TIMER0 interrupt routine ISR(TIMER0_OVF_vect) on every 10 ms. Using the tenms counter variable, we reduce down to about 200 ms to make the LED display appear nicely in our eyes and at the same time we do the ADC conversion from the National Semiconductor LM35DZ precision centigrade temperature sensor. You could read more about reading the LM35DZ from my previous posted blog AVR LCD Thermometer Using ADC and PWM Project.
You could easily activate the debugging mode by changing the _DEBUG_MODE definition value to 1 before compiling the program and use the serial terminal program to watch the result.
// Debugging Mode, 0 - Debug OFF, 1 - Debug ON
#define _DEBUG_MODE   1
This simple embedded Web server C code only took about 6196 bytes of the flash RAM and 816 bytes of the SRAM (debug mode turn off). The whole C code in this project is designed to be just a single file (i.e. wiznetweb.c) and all you need is the standard Win-AVR GCC includes file in order to make this program compiled successfully in the Atmel AVR Studio environment as shown on this following picture:


Now you could enjoy the embedded web server project video on this tutorial. In this video I used both acer aspire notebook and BlackBerry Javelin 8900 smart phone to access the embedded web server which is connected to the Linksys Wireless-G 2.4GHz broadband router:

The Final Thought
Actually the W5100 socket driver for the Atmel AVR microcontroller families has been provided by the Wiznet (version 1.5, as I published this blog), you could download the driver from their site (http://www.wiznet.co.kr). This driver (version 1.4) is adapted and used in the Arduino framework environment, known as the Arduino Ethernet Shield library.
Of course if I use the Wiznet socket driver in this project then you won’t learn anything, therefore to honor the spirit of experimenting inside every electronics hobbyists I decided to write my own version of the Wiznet W5100 socket driver for this project. Hopefully this project will give you a better understanding of how to integrate the Wiznet W5100 TCP/IP hardwire chip in your next embedded system application.

Stepping Into the 16-bit World with the Microchip 16-bit PIC24F16KA102 Family Microcontroller

rwb — Mon, 31 May 2010 14:29:54 +0000

One of the commonly asked questions when we move to the bigger and powerful 16-bit microcontroller is do we really need it? As the 8-bit microcontroller is already suite almost all of our needs from a simple blinking LED to more sophisticated embedded application such as robotics. Despite the debate whether to use the 8-Bit or 16-Bit microcontroller or perhaps just go straight to 32-bit microcontroller in our embedded system design, first I will show you the Microchip PIC18F25J11 (8-Bit) and PIC24F16KA102 (16-bit) basic comparison.

I use the Microchip PIC18F25J11 for the comparison as this microcontroller is considered as the 8-Bit highest end class microcontroller equipped with Microchip nanoWatt XLP technology while the Microchip PIC24F16KA102 is considered as the 16-bit entry level class microcontroller also equipped with Microchip nanoWatt XLP technology. Both microcontrollers have a build in hardware RTCC (Real Time Clock and Calendar), I2C, SPI and CTMU (Charge Time Measurement Unit) for capacitance sensing.

Now here my opinion from the electronics hobbyist perspective, things that we always consider when learning a new microcontroller are how easy to quick prototyping it on the breadboard, how much the cost and the last is the development tools to be used. From the basic comparison above you’ve noticed that for the learning purpose these two types of microcontroller are almost identical. On the other hand let’s consider the advantages of learning the 16-bit microcontroller; the PIC24F16KA102 microcontroller families share the same architecture as the well known Microchip dsPIC (digital signal controlling) microcontroller families, therefore by learning the 16-bit PIC24F16KA102 microcontroller family will open your knowledge and richer your experiences to more advance application of the embedded world system and surely you will love and enjoy it.

…to explore a new 16-bit microcontroller world… new datasheet… and …new programming… to boldly go when the only true electronics hobbyists dare to go…

On this tutorial we are going to step into the 16-bit embedded world and I will use the Microchip PIC24F16KA102 microcontroller as our learning tools. Actually Microchip has a nice product to help you quickly learn the PIC24F16KA102 families features (the Microchip nanoWatt XLP 16-bit Development Board - DM240311) as shown on the following picture:

But for showing the basic PIC24F16KA102 microcontroller peripheral features in this tutorial, we could easily prototype it on the breadboard.

Ok now let list down the necessary electronics components and supported software for our stepping into 16-bit world tutorial and make sure you have the Microchip PIC24F16KA102 microcontroller datasheet near you:

1. Resistors: 330 Ohm (9), 470 Ohm (1) and 10K (2)
2. Capacitors: 0.01uF (2) and 0.1uF (2)
3. LEDS: 3 mm Blue LED (8) and 3 mm Red LED (1)
4. One Microchip 16-bit PIC24F16KA102 microcontroller
5. Two momentary push button
6. One Breadboard and some breadboard’s jumper cables
7. One 2xAA Battery Holder with the 2x AA Alkaline battery (3 volt) for powering the circuit
8. Microchip PICKit3 programmer (used in this project)
9. Microchip MPLAB IDE version 8.47 and Microchip C30 Compiler version 3.30
10. Microchip PIC24 Reference Document: PIC24F16LA102/101 datasheet, AN39703a (CPU), AN39711b (I/O), AN39704a (Timer), AN39705b (ADC)

For quick prototyping this project on the breadboard I used the SIL LED display and SIL push button modules which you could read more about it in my previous posted blog Single In Line (SIL) LED Display for your Microcontroller Project

The 16-bit PIC24 Family Microcontroller

With 16-bit CPU internal data path, the PIC24 family microcontroller is being referred as the 16-bit class microcontroller. This means this microcontroller could process the 16-bit or 8-bit data with just a single instruction. As the result compared to the 8-bit class microcontroller the 16-bit class microcontroller will perform better for intensive arithmetic calculation application such as GUI (graphics user interface) display, TCP/IP application, USB embedded host and digital signal controlling (dsPIC microcontroller family).

Unlike the Microchip 8-bit (PIC12, PIC16 and PIC18) families microcontroller, the Microchip 16-bit PIC24 microcontroller families has a linear memory addressing design, therefore we don’t have to switch back and forth between memory “BANK” to access different peripheral registers as we do in the Microchip 8-bit families microcontroller; you could read more about programming the Microchip 8-bit microcontroller on my previous posted blog Introduction to Microchip PIC Assembler Language – Part 1.

The 16-bit Microchip PIC microcontroller also has 16 x 16-bit array working register known as W0 through W15 compared to only one working register in Microchip PIC 8-bit (WREG), this make the programming code is more efficient comparing to the PIC 8-bit microcontroller because all the arithmetic operation should go through the working register in order to be processed. The Microchip PIC24 microcontroller class also only use 2 cycles clock per instruction compared to 4 cycles clock per instruction on the PIC12/16/18 microcontroller class; this make the PIC24 at least twice more faster than PIC12/16/18 microcontroller. And the best of all, we still use the same Microchip powerful MPLAB integrated development environment for debugging, compiling and programming this 16-bit class microcontroller.

For more detail information about the Microchip 16-bit microcontroller families, I suggest to read more about it in the Microchip 16-bit microcontroller home website. Ok let’s start with the hello 16-bit world C program, where we simply blink one LED using the PIC24F16KA102 microcontroller output port as shown on this following C code:

/* ***************************************************************************
**  File Name    : helloworld.c
**  Version      : 1.0
**  Description  : First 16-bit PIC C Programming
**  Author       : RWB
**  Target       : PIC24F16KA102
**  Compiler     : MPLAB C30 C Compiler v3.23
**  IDE          : Microchip MPLAB IDE v8.46
**  Programmer   : PICKit3 (Firmware Suite Version 01.25.20)
**  Last Updated : 08 April 2010
** ***************************************************************************/
#include

// PIC24F16KA102 Configuration bits
/*
** --------------------------------------------------------------------
** _FBS (Register FBS: 0xF80000)
**  BWRP_OFF - Boot Segment Write Protect Disable
**  BSS_OFF  - Boot Segment Code Protect Disable
** --------------------------------------------------------------------
** _FGS (Register FGS: 0xF80004)
**  GWRP_OFF - General Segment Write Protect Disable
**  GCP_OFF  - General Segment Code Protect Disable
** --------------------------------------------------------------------
** _FOSCSEL (Register FOSCSEL: 0xF80006)
**  FNOSC_FRCDIV - Fast RC Oscillator With Postscale (FRCDIV)
**  IESO_OFF - Two Speed Start-up Disable
** --------------------------------------------------------------------
** _FOSC (Register FOSC: 0xF80008)
**  FCKSM_CSECMD - Clock Switching Enabled, Clock Monitor Disabled
**  POSCFREQ_MS  - Mid Speed (100kHz - 8MHz)
**  OSCIOFNC_ON  - OSCO Pin Has Digital I/O Function (RA3)
**  POSCMOD_NONE - Primary disabled
**  SOSCSEL_SOSCLP - Low Power Secondary Oscillator
** --------------------------------------------------------------------
** _FWDT (Register FWDT (0xF8000A)
**  FWDTEN_OFF - Watchdog Timer (WDT) Disable
**  WINDIS_OFF - Non-Window WDT Mode
**  FWPSA_PR128 - WDT Prescale 1:128
**  WDTPS_PS32768 - WDT Postscale 1:32,768
** --------------------------------------------------------------------
** _FPOR (Register FPOR: 0xF8000C)
**  MCLRE_OFF - MCLR Disabled, RA5 Enabled
**  BORV_LPBOR - Low Power BOR (Brown Out Voltage)
**  BOREN_BOR3 - Enabled in hardware, SBOREN bit disabled
**  I2C1SEL_PRI - Use SCL1/SDA1 Pins For I2C1
**  PWRTEN_OFF - Power Up Timer Disabled
** --------------------------------------------------------------------
** _FICD (Register FICD: 0xF8000E)
**  BKBUG_OFF - Background Debugger Disabled
**  ICS_PGx3 - EMUC/EMUD share PGC3/PGD3
** --------------------------------------------------------------------
** _FDS (Register FDS: 0xF80010)
**  DSWDTEN_OFF - Deep Sleep WDT Disabled
**  DSBOREN_ON - Deep Sleep BOR Enabled
**  RTCOSC_SOSC - RTCC Oscillator select: Secondary Oscillator (SOSC)
**  DSWDTOSC_SOSC - Deep Sleep WDT Low Power RC Oscillator (LPRC)
**  DSWDTPS_DSWDTPSF - Deep Sleep WDT Postscale 1:2,147,483,648
**                     (25.7 Days)
** --------------------------------------------------------------------
*/
_FBS(BWRP_OFF & BSS_OFF)
_FGS(GWRP_OFF & GCP_OFF)
_FOSCSEL(FNOSC_FRCDIV & IESO_OFF)
_FOSC(FCKSM_CSECMD & POSCFREQ_MS & OSCIOFNC_ON & POSCMOD_NONE & SOSCSEL_SOSCLP)
_FWDT(FWDTEN_OFF & WINDIS_OFF & FWPSA_PR128 & WDTPS_PS32768)
_FPOR(MCLRE_ON & BORV_LPBOR & BOREN_BOR3 & I2C1SEL_PRI & PWRTEN_OFF)
_FICD(BKBUG_OFF & ICS_PGx3)
_FDS(DSWDTEN_OFF & DSBOREN_ON & RTCOSC_SOSC & DSWDTOSC_SOSC & DSWDTPS_DSWDTPSF)

int main ( void )
{
  unsigned int i;

  // Use Internal 8 MHz Clock
  OSCCON = 0x0000;
  CLKDIV = 0x0000;

  // Initial the Ports Used
  TRISB  = 0xFF00;         // Set all RB0-RB7 Output, RB8-RB15 Input
  AD1PCFG = 0xffff;        // Set all to digital output
  ODCB   = 0x0000;         // Do not use open drain Output
  LATB   = 0x0000;         // Reset All PORT B

  for(;;) {
    PORTBbits.RB0=1;           // Turn On RB0
    for (i=0; i<0xffff; i++);  // Delay Loop
    PORTBbits.RB0=0;           // Turn Off RB0
    for (i=0; i<0xffff; i++);  // Delay Loop
  }

  return 0;
}

/* EOF: helloworld.c */

The PIC24F16KA102 Output Port

One of the advantages using the PIC2F16KA102 microcontroller is that each of the output ports could be configured as the open drain output using the Open Drain Control Register (e.g. ODCB). By setting this 16-bit register to logical “1” we could configure the port as the open drain output where the P-channel MOSFET transistor is disconnect from the microcontroller output port and leave the N-Channel MOSFET transistor with the open drain (not connected to Vcc). In order for the open drain output to work you need to supply the Pull-up resistor to power the N-Channel MOSFET transistor. Remember when you configure as the open drain output, the output port only could sink current through the N-Channel MOSFET transistor.

The advantages of open drain output feature is, it has a very nice application in terms of making the microcontroller electronics support circuit design simpler such as wire ORing and it could be used as the logical voltage shifter to interface from 3.3 volt logic circuit to 5 volt circuit as shown on this following picture:

Before using the PIC24F16KA102 microcontroller I/O port, first we have to set whether to use it as input or output port by setting the tri state register for PORTB (i.e. TRISB) as follow:

// Initial the Ports Used
TRISB  = 0xFF00;         // Set all RB0-RB7 Output, RB8-RB15 Input
AD1PCFG = 0xffff;        // Set all to digital output
ODCB   = 0x0000;         // Do not use open drain Output
LATB   = 0x0000;         // Reset All PORT B

By setting the TRISB register bits (TRISB1 to TRISB15) to logical “1” we define the port as input (you could see it as “I” for input) and by setting it to logical “0” we define the port as output (you could see it as “O” for output), therefore by setting the TRISB register bits to 0xFF00, mean we set the RB0 to RB7 as output ports while the RB8 to RB15 as the input ports.

Next we configure the ADC (analog to digital conversion) pin configuration register AD1PCFG bits to logical “0“, this mean we configure all of the 10 ADC channel port available in PIC24F16KA102 microcontroller as the digital I/O port. By setting the ODCB register bits to logical “0” we disable the output port open drain feature which we need it in this project to drive the display LED. The last is we simply set the PORTB latch register (LATB) to reset all the display LED. Writing to the PORTB latch register (LATB) will give the same result as we write directly to the PORTB register.

Using the TIMER Peripheral for Generating Delay

From the above example you’ve noticed that I used simply loops to create delay for displaying the LED; the more elegant way to make the delay is to take advantage of the PIC24F16KA102 microcontroller TIMER peripherals. To show how the TIMER peripheral work I modified the above code and add the capabilities to read input from SW2 as well as using the TIMER1 peripheral as the base of our delay routine. Now let’s examine the following C code (ledseq.c):

/* ***************************************************************************
**  File Name    : ledseq.c
**  Version      : 1.0
**  Description  : LED Sequence 16-bit PIC C Programming
**  Author       : RWB
**  Target       : PIC24F16KA102
**  Compiler     : MPLAB C30 C Compiler v3.23
**  IDE          : Microchip MPLAB IDE v8.46
**  Programmer   : PICKit3 (Firmware Suite Version 01.25.20)
**  Last Updated : 08 April 2010
** ***************************************************************************/
#include

// PIC24F16KA102 Configuration bits
_FBS(BWRP_OFF & BSS_OFF)
_FGS(GWRP_OFF & GCP_OFF)
_FOSCSEL(FNOSC_FRCDIV & IESO_OFF)
_FOSC(FCKSM_CSECMD & POSCFREQ_MS & OSCIOFNC_ON & POSCMOD_NONE & SOSCSEL_SOSCLP)
_FWDT(FWDTEN_OFF & WINDIS_OFF & FWPSA_PR128 & WDTPS_PS32768)
_FPOR(MCLRE_ON & BORV_LPBOR & BOREN_BOR3 & I2C1SEL_PRI & PWRTEN_OFF)
_FICD(BKBUG_OFF & ICS_PGx3)
_FDS(DSWDTEN_OFF & DSBOREN_ON & RTCOSC_SOSC & DSWDTOSC_SOSC & DSWDTPS_DSWDTPSF)

void delay_ms(unsigned short ms)
{
  unsigned short i;

  // TIMER1 Period = PR1 x 2 x Tosc x Prescale second
  // TIMER1 Period = 500 x 2 x 1/8000000 x 8 = 0.001 second = 1 ms

  PR1=500;                      // Maximum Counter
  for (i=0; i <= ms;i++) {
    TMR1=0;                     // Reset TIMER1 Counter
    IFS0bits.T1IF=0;            // Clear TIMER1 Interrupt Flag
    T1CONbits.TON=1;            // Turn On TIMER1
    while(IFS0bits.T1IF != 1);  // Wait until TMR1 > PR1 (Overflow)
    T1CONbits.TON=0;            // Turn Off TIMER1
  }
}

int main ( void )
{
  unsigned char mode,count,led_pointer;
  char led_pattern0[10]= {0b00000011,0b00001100,0b00110000,0b11000000,0b00000000,
                          0b11000000,0b00110000,0b00001100,0b00000011,0b00000000};
  char led_pattern1[10]= {0b00000001,0b00000100,0b00010000,0b01000000,0b00000000,
                          0b10000000,0b00100000,0b00001000,0b00000010,0b00000000};                                             

  // Use Internal 8 Mhz Clock
  OSCCON = 0x0000;
  CLKDIV = 0x0000;

  // Initial the Ports Used
  TRISB  = 0xFF00;         // Set all RB0-RB7 Output, RB8-RB15 Input
  CNPU1bits.CN11PUE = 0;   // Disable Week Pull Up on RB15/CN11 Input
  AD1PCFG = 0xFFFF;        // Set all to digital I/O
  ODCB   = 0x0000;         // Do not use open drain Output
  LATB   = 0x0000;         // Reset All PORT B

  // Initial TIMER1 for Delay
  T1CON=0x0010;            // TIMER1 Off, Prescale 1:8 using the internal clock

  // Initial Variables Used
  mode=0;
  count=0;
  led_pointer=0;

  for(;;) {
    // Reading the Switch Input on RB15
    if (PORTBbits.RB15 == 0) {
      if (count++ > 5) {   // The Debouce Count
        count=0;
        mode=~mode;        // Toggle the mode variable
      }
    } 

    // Display the LED Pattern
    if (mode)
      PORTB=led_pattern1[led_pointer];
    else
      PORTB=led_pattern0[led_pointer];      

    if (led_pointer++ > 9)
      led_pointer=0;

    delay_ms(50);          // Call Delay Function
  }
  return 0;
}

/* EOF: ledseq.c */

The Microchip PIC24F16KA102 microcontroller have build in three independent 16-bit TIMER (TIMER1, TIMER2 and TIMER3) where TIMER2 and TIMER3 could be configured as a single 32-bit TIMER. On this tutorial we will use the 16-bit TIMER1 as our delay routine base.

As implied by its name, you could look the TIMER1 as an ordinary 16-bit counter named TMR1; where you could use the external or internal clock to pulse this counter controlled by the TIMER1 control register (T1CON). As the counter value is incremented by the pulse, the 16-bit counter output is constantly compared to the PR1 register when TMR1 reach the PR1 value than the the TIMER1 will automatically set the TIMER1 interrupt flag (T1IF) bit on Intterupt Flag Status 0 register (IFS0).

By using the correct TIMER1 clock prescale and PR1 value we could calculate the TIMER1 period using this following formula:

TIMER1 Period = PR1 x 2 x Tosc x Prescale

By assigning the PR1 register to 500, using 8 MHz internal system clock and with 1:8 prescale than the TIMER1 period could be calculated as follow:

TIMER1 Period = 500 x 2 x 1/8000000 x 8 = 0.001 second = 1 ms

Therefore by waiting for the T1IF bit to become logical “1” by the TIMER1 comparator inside the loop, we could create configurable delay function base on the TIMER1 as show on this following C code:

....
PR1=500;                      // Maximum Counter
for (i=0; i <= ms;i++) {
  TMR1=0;                     // Reset TIMER1 Counter
  IFS0bits.T1IF=0;            // Clear TIMER1 Interrupt Flag
  T1CONbits.TON=1;            // Turn On TIMER1
  while(IFS0bits.T1IF != 1);  // Wait until TMR1 > PR1 (Overflow)
  T1CONbits.TON=0;            // Turn Off TIMER1
}

Reading the Input Port

Reading the input port is done by first configured the I/O port as the input port. When we configure as the input port in the PIC24F16KA102 microcontroller, you could activate the weak pull-up resistor as shown on this following picture:

To enable or disable the weak pull-up resistor we could set the CNxPUE corresponding bits to either “1” (enable) or “0” (disable) in the PIC24F16KA102 microcontroller pull-up control register CNPU1 or CNPU2. In this tutorial because we use the external pull-up resistor, therefore we disable this feature.

TRISB  = 0xFF00;         // Set all RB0-RB7 Output, RB8-RB15 Input
CNPU1bits.CN11PUE = 0;   // Disable Week Pull Up on RB15/CN11 Input

Now by reading the switch on RB15 on PORTB and using simple debounce logic we could easily read the switch input status whether it being pressed or not. This status later on will toggle the mode variable to control how we display the LED pattern data on the PORTB output as shown on this following C code:

// Reading the Switch Input on RB15
if (PORTBbits.RB15 == 0) {
  if (count++ > 5) {   // The Debounce Count
    count=0;
    mode=~mode;        // Toggle the mode variable
  }
}

Using the ADC (Analog to Digital Converter) Peripheral

On the last of this introduction to 16-bit world tutorial, I’m going to explain one of the most important peripheral features on every modern microcontroller which is the Analog to Digital Conversion (ADC) peripheral. Again by slightly modify the example code above I added the capability to adjust the speed of the LED display pattern by using the trimport. Now let’s take a look on this following C code (adcled.c):

* ***************************************************************************
**  File Name    : adcled.c
**  Version      : 1.0
**  Description  : ADC LED Sequence 16-bit PIC C Programming
**  Author       : RWB
**  Target       : PIC24F16KA102
**  Compiler     : MPLAB C30 C Compiler v3.23
**  IDE          : Microchip MPLAB IDE v8.46
**  Programmer   : PICKit3 (Firmware Suite Version 01.25.20)
**  Last Updated : 10 April 2010
** ***************************************************************************/
#include

// PIC24F16KA102 Configuration bits
_FBS(BWRP_OFF & BSS_OFF)
_FGS(GWRP_OFF & GCP_OFF)
_FOSCSEL(FNOSC_FRCDIV & IESO_OFF)
_FOSC(FCKSM_CSECMD & POSCFREQ_MS & OSCIOFNC_ON & POSCMOD_NONE & SOSCSEL_SOSCLP)
_FWDT(FWDTEN_OFF & WINDIS_OFF & FWPSA_PR128 & WDTPS_PS32768)
_FPOR(MCLRE_ON & BORV_LPBOR & BOREN_BOR3 & I2C1SEL_PRI & PWRTEN_OFF)
_FICD(BKBUG_OFF & ICS_PGx3)
_FDS(DSWDTEN_OFF & DSBOREN_ON & RTCOSC_SOSC & DSWDTOSC_SOSC & DSWDTPS_DSWDTPSF)

void delay_ms(unsigned short ms)
{
  unsigned short i;

  // TIMER1 Period = PR1 x 2 x Tosc x Prescale second
  // TIMER1 Period = 500 x 2 x 1/8000000 x 8 = 0.001 second = 1 ms

  PR1=500;                      // Maximum Counter
  for (i=0; i <= ms;i++) {
    TMR1=0;                     // Reset TIMER1 Counter
    IFS0bits.T1IF=0;            // Clear TIMER1 Interrupt Flag
    T1CONbits.TON=1;            // Turn On TIMER1
    while(IFS0bits.T1IF != 1);  // Wait until TMR1 > PR1 (Overflow)
    T1CONbits.TON=0;            // Turn Off TIMER1
  }
}

int main ( void )
{
  unsigned char mode,count,led_pointer;
  char led_pattern0[10]= {0b00000011,0b00001100,0b00110000,0b11000000,0b00000000,
                          0b11000000,0b00110000,0b00001100,0b00000011,0b00000000};
  char led_pattern1[10]= {0b00000001,0b00000100,0b00010000,0b01000000,0b00000000,
                          0b10000000,0b00100000,0b00001000,0b00000010,0b00000000};
  unsigned int iDelay;

  // Use Internal 8 Mhz Clock
  OSCCON = 0x0000;
  CLKDIV = 0x0000;

  // Initial the Ports Used
  TRISB  = 0xFF00;         // Set all RB0-RB7 Output, RB8-RB15 Input
  CNPU1bits.CN11PUE = 0;   // Disable Week Pull Up on RB15/CN11 Input
  AD1PCFG = 0xFFFF;        // Set all to digital I/O
  ODCB   = 0x0000;         // Do not use open drain Output
  LATB   = 0x0000;         // Reset All PORT B

  // Initial TIMER1 for Delay
  T1CON=0x0010;            // TIMER1 Off, Prescale 1:8

  // Initial the ADC Peripheral
  AD1PCFGbits.PCFG12 = 0;  // Set AN10/RB12 as Analog Input
  AD1CON1 = 0x00E0;        // Auto convert after end of sampling
  AD1CON2 = 0x0000;        // Use MUXA, Internal AVdd and AVss as reference, 16-word buffer
  AD1CON3 = 0x1F02;        // Use System clock and Max sample time = 31 TAD, TAD = 3 Tcy
  AD1CSSL = 0x0000;        // No inputs are scanned
  AD1CON1bits.ADON=1;      // Turn ON ADC Peripheral

  // Initial Variables Used
  mode=0;
  count=0;
  led_pointer=0;
  iDelay=50;

  for(;;) {
    // Reading the Switch Input on RB15
    if (PORTBbits.RB15 == 0) {
      if (count++ > 5) {       // The Debounce Count
        count=0;
        mode=~mode;            // Toggle the mode variable
      }
    }

    // Start ADC Conversion
    AD1CHS = 0x000C;               // Read Trimport on Channel 12 (AN12)
    AD1CON1bits.SAMP=1;            // Now Start the ADC Sampling
    while (AD1CON1bits.DONE != 1); // Wait for ADC conversion
    iDelay=ADC1BUF0;               // Get the 10-bit ADC Result

    // Display the LED Pattern
    if (mode)
      PORTB=led_pattern1[led_pointer];
    else
      PORTB=led_pattern0[led_pointer];      

    if (led_pointer++ > 9)
      led_pointer=0;

    delay_ms(iDelay);          // Call Delay Function
  }
  return 0;
}

/* EOF: adcled.c */

Differ from the 8-bit PIC12/16/18 microcontroller families, the 16-bit PIC24 microcontroller ADC peripheral support many advance features such as two independent multiplexing analog channels, multiple single channel A/D conversion or multiple multi channel A/D conversion for single interrupt, four type of A/D conversion data format result (integer, signed integer, fractional and signed fractional) and multiple trigger A/D data conversion method.

The PIC24 families A/D conversion required one A/D clock cycle (TAD) plus 2 additional clock cycles, thus the PIC24 SAR need at least 12 TAD cycles to do the 10-bit conversion. For correct A/D conversions, the A/D conversion clock (TAD) must be selected to ensure a minimum TAD time of 75 ns.

Finally when the conversion is done, the result is loaded into the sixteen words of A/D result buffer array registers (ADC1BUF0 to ADC1BUFF). On this tutorial I used one channel (AN12) with manual sample start A/D conversion method.

The ADC peripheral initialization begin by setting the input pin AN12 (RB12) to be functioned as the analog input by setting PCFG12 bit to logical “1” on ADC pin configuration register (AD1PCFG). Then we continue to ADC peripheral control registers AD1CON1, AD1CON2 and AD1CON3 as shown on this following C code:

// Initial the ADC Peripheral
AD1PCFGbits.PCFG12 = 0;  // Set AN10/RB12 as Analog Input
AD1CON1 = 0x00E0;        // Auto convert after end of sampling
AD1CON2 = 0x0000;        // Use MUXA, Internal AVdd and AVss as reference, 16-word buffer
AD1CON3 = 0x1F02;        // Use internal RC clock and Max sample time = 31 TAD, TAD = 3 Tcy
AD1CSSL = 0x0000;        // No inputs are scanned
AD1CON1bits.ADON=1;      // Turn ON ADC Peripheral

Because in this tutorial I used automatic A/D conversion after the sample and hold amplifier captured the analog signal input, therefore we have to set the A/D conversion source trigger bits (SSRC<2:0>) on AD1CON1 register to “111” to use internal counter for automatic conversion after sampling and set the ASAM bits to logical “0” to instruct the sample and hold amplifier to begin the sampling when the SAMP bit on register AD1CON1 is set to logical “1“.

Next on the AD1CON2 register we choose the PIC24K16KA102 power supply as our A/D reference voltage by setting the voltage configuration bits (VCFG<2:0>) to “000” and configure the A/D result buffer as single word (16-bit) by setting the buffer mode bit (BUFM) to logical “0“. Finally on the AD1CON3 register we configure the A/D conversion clock, because we need at least 75 ns for A/D conversion time (TAD), therefore by setting the conversion period selection bits (ADCS<7:0>) to “00000010” (ADCS = 2) we could calculate the TAD for 8MHz internal clock source (FOSC) as follow:

TAD = (ADCS + 1) x TCY

Because the instruction cycle clock is FOSC/2, therefore the instruction cycle period (TCY) will be 2/FOSC

TAD = 3 x 1 / 8000000 x 2 = 750 ns

Before starting the A/D conversion we have to turn on the ADC peripheral by setting the ADON bit on register AD1CON1 to logical “1” then next selecting the analog input channel using the A/D channel selection register (AD1CHS) to AN12 pin (0×000C):

...
// Start ADC Conversion
AD1CHS = 0x000C;               // Read Trimport on Channel 12 (AN12)
AD1CON1bits.SAMP=1;            // Now Start the ADC Sampling
while (AD1CON1bits.DONE != 1); // Wait for ADC conversion
iDelay=ADC1BUF0;               // Get the 10-bit ADC Result
...

After starting the sample and hold amplifier for sampling the analog input, the ADC peripheral will automatically do the conversion after 31 TAD and by examining the DONE bit on the AD1CON register we could get the A/D conversion status and later read the A/D conversion result on the ADC1BUF0 register. This A/D conversion result than will be used as the delay parameter for displaying the LED, therefore by adjusting the 10K trimport we could adjust the LED display speed.

After compiling and downloading all the HEX code into the PIC24F16KA102 microcontroller you will have similar result as shown on this following video:

The Final Thought

As you walk through this 16-bit microcontroller world tutorial you will noticed that although the inside architecture between the 8-bit (Harvard) and 16-bit (Modified Harvard) Microchip PIC microcontroller is different, but they shared the same designed pattern such as the peripheral register name, the pins name and they all use the Microchip MPLAB integrated development environment. This make move from the 8-bit to the 16-bit class microcontroller become straightforward and easy. By using the 16-bit class microcontroller, you could bring broader range of application into the embedded world.

Building your own Simple Laser Projector using the Microchip PIC12F683 Microcontroller

rwb — Mon, 12 Apr 2010 17:00:53 +0000

The 8 pins PIC12F683 microcontroller is one of the smallest members of the Microchip 8-bit microcontroller families but equipped with powerful peripherals such as ADC and PWM capabilities. This make this tiny microcontroller is suitable for controlling the DC motor speed. In order to demonstrate the PIC12F683 capabilities and to make this tutorial more attractive, I decided to use the PIC12F683 microcontroller to generate simple and yet fascinating laser light show from a cheap keychain laser pointer.

The basic of laser light shown in many entertainments club or park mostly use two method; the first one is to beam the laser shower on the spectators and the second one is to display the laser drawing pattern on the screen. On this tutorial we are going to build the laser projector that displays the spirograph pattern on the screen using the tiny Microchip PIC12F683 microcontroller.

The principal of making the spirograph laser projector is to use at least two DC motors with the attached mirror on it, these mirrors then will deflect the laser beam from one DC motor mirror to the second DC motor mirror and then finally to the screen. By controlling each of the DC motors spinning speed we could generate a fascinating laser spirograph pattern on the screen as shown on this following picture.

The best way to control the DC motor speed is to use the PWM (pulse wave modulation) signal to drive the DC Motor and because we want to change the DC motor speed manually, therefore we need to use the trimport or potentiometer to control each of the DC motors speed. Hmm, this sound like an appropriate job for the microcontroller but could we use this tiny 8 pins PIC12F683 microcontroller to handle this task?

From the datasheet you will notice that the Microchip PIC12F683 microcontroller only has one PWM output (CCP1) and four ADC input channel (AN0, AN1, AN2 and AN3). Because we need two PWM output, therefore instead of using the PIC12F683 microcontroller build in PWM peripheral, in this tutorial I will show you how to generate the PWM signal base on the PIC12F683 microcontroller TIMER0 peripheral. The following is the complete electronic schematic for the laser projector project.

Ok before we go further with the detail; let’s list down the supporting peripherals needed to complete this laser projector project:

Hot glue gun
Keychain laser pointer or any available laser pointer
3xAA, 4.5 volt battery holder for powering the laser pointer, please use the same voltage rate used by your laser pointer.
Two DC motor taken from the discarded PS2 Dual shock joystick
Two toy’s car tire taken from tamiya racing car
CD/DVD for the mirror, use a kitchen scissor to cut the CD/DVD into the two circle shape mirror with approximately 38 mm in diameter
Some toys plastic bricks for holding the DC motor
Breadboard
Hardboard or acrylic is used for the base of our laser projector
Double Tape

The following are the electronic parts and the software development tools that I used to make this laser projector project:

Resistor: 330 (3), 1K (5) and 10K (1)
Trimport: 10K (2)
Capacitor: 100nF (2) and 10nF (1)
One 100uH Inductor
Two 1N4148 Diodes
Two Blue and one Red Light Emitting Diode (LED)
Two 2N2222A transistors
One Mini Push Button Switch
One Microchip PIC12F683 Microcontroller
Microchip MPLAB v8.46 IDE (Integrated Development Environment)
Microchip Macro Assembler MPASMWIN.exe v5.35, mplink.exe v4.35
HI-TECH C Compiler for PIC10/12/16 MCUs (Lite Mode) V9.70
Microchip PICKit3 Programmer (Firmware Suite Version: 01.25.20)

This project is aim as the continuing lessons to my previous posted blog Introduction to PIC Assembly Language Part-1 and Introduction to PIC Assembly Language Part-2, therefore I used the same PIC12F683 board presented in the part 2 which you could down load both of the electronic schematic and the PCB layout designed in Eagle CAD format. The other interesting feature of this laser projector project is; besides the PIC assembly code I also provide the C language version of this project for the C language lover and is compiled with the HI-TECH C Compiler (recently the HI-TECH Software has been acquired by Microchip). This C language version could be used for learning as well as the embedded system programming language comparison.

In this project I also use a new Microchip PICKit3 programmer but of course you could use the Microchip PICKit2 programmer to download the hex code to the PIC12F683 microcontroller flash.

The following is the Laser Projector code in PIC Assembly Language:

;******************************************************************************
;  File Name    : laserlight.asm
;  Version      : 1.0
;  Description  : Laser Light Show Project
;  Author       : RWB
;  Target       : Microchip PIC12F683 Microcontroller
;  Compiler     : Microchip Assembler (MPASMWIN.exe v5.35, mplink.exe v4.35)
;  IDE          : Microchip MPLAB IDE v8.46
;  Programmer   : PICKit3 (Firmware Suite Version: 01.25.20)
;  Last Updated : 01 April 2010
; *****************************************************************************
#include

__config (_INTRC_OSC_NOCLKOUT & _WDT_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _IESO_OFF & _FCMEN_OFF)

#define MAX_TMR0 0xFB
#define MAX_COUNT .200
#define MAX_DEBOUNCE 0x0A
#define MAX_TBLINDEX 0x0A

; Define variables used
     cblock 0x20
Delay:2                      ; Define two registers for the Delay and Delay + 1
mode                         ; Operation Mode
pwm_count                    ; Hold the Main PWM Counter
pwm_m1                       ; Hold the PWM width for Motor 1
pwm_m2                       ; Hold the PWM width for Motor 2
keycount                     ; Debounce Count
tableindex                   ; Table Index for Auto PWM
     endc

; Define variable use for storing STATUS and WREG register
     cblock 0x70             ; Use unbanked RAM, available both in Bank0 and Bank1
saved_w
saved_status
     endc

; Start the Light show Assembler Code here
     org 0x00                ; We always start at flash address 0
     goto Main               ; Jump to Main

     org 0x04                ; 0x04: Start PIC Interrupt Address
PIC_ISR:                     ; Start the PIC Interrupt Service Routine
     movwf   saved_w         ; Save Working Register
     movf    STATUS,w        ; Save Status Register
     movwf   saved_status

; Check the TIMER0 Interrupt here
     btfss   INTCON,T0IF
     goto    ExitISR         ; If (T0IF != 1) then Exit ISR
     bcf     STATUS,RP0      ; Select Registers at Bank 0
     incf    pwm_count       ; pwm_count++
     movlw   MAX_COUNT
     subwf   pwm_count,w     ; if (pwm_count < MAX_COUNT) then CheckPWM
     btfss   STATUS,C        ; else clear GP1 and GP2
     goto    CheckPWM
     bcf     GPIO,GP1        ; GPIO1=0
     bcf     GPIO,GP2        ; GPIO2=0
     goto    ExitPWM

CheckPWM:
     movf    pwm_m1,w
     subwf   pwm_count,w
     btfsc   STATUS,Z        ; if (pwm_count == pwm_m1) then Set GP1
     bsf     GPIO,GP1        ; Set GP1 Bit
CheckM2:
     movf    pwm_m2,w
     subwf   pwm_count,w
     btfsc   STATUS,Z        ; if (pwm_count == pwm_m2) then Set GP2
     bsf     GPIO,GP2        ; Set GP2 bit
ExitPWM:
     bcf     INTCON,T0IF     ; clear the TIMER0 interrupt flag
     movlw   MAX_TMR0
     movwf   TMR0            ; TMR0 = MAX_TMR0

ExitISR:
     movf    saved_status,w
     movwf   STATUS          ; Restore STATUS Register
     swapf   saved_w,f
     swapf   saved_w,w       ; Restore W Register
     retfie                  ; Return from Interrupt

Main:
     bsf     STATUS,RP0      ; Select Registers at Bank 1
     movlw   0x70
     movwf   OSCCON          ; Set the internal clock speed to 8 MHz
     movlw   0x39            ; GP1 and GP2 Output, GP0,GP3,GP4 and GP5 as Input
     movwf   TRISIO          ; TRISIO = 0x39        

     bcf     STATUS,RP0      ; Select Registers at Bank 0
     movlw   0x07
     movwf   CMCON0          ; Turn off Comparator (GP0, GP1, GP2)
     clrf    GPIO

; Now we Set the ADC Peripheral
     bsf     STATUS,RP0      ; Select Registers at Bank 1
     movlw   0x79            ; Set AN0 (GP0) and AN3 (GP4) as Analog Input
     movwf   ANSEL           ; Using the Internal Clock (FRC)  

; Now we set the TIMER0 Peripheral
; TIMER0 Period = 1/FSOC x 4 x Prescale x TMR0
     movlw   0x00            ; Use TIMER0 Prescaler 1:2, Internal Clock
     movwf   OPTION_REG      ; OPTION_REG = 0x00

     bcf     STATUS,RP0      ; Select Registers at Bank 0
     movlw   MAX_TMR0
     movwf   TMR0            ; TMR0=MAX_TMR0      

; Initial the variables used
     clrf    mode            ; Default mode = 0, Light Show Off
     clrf    pwm_count       ; pwm_count = 0
     clrf    pwm_m1          ; pwm_m1 = 0
     clrf    pwm_m2          ; pwm_m2 = 0
     clrf    keycount        ; keycount = 0
     clrf    tableindex      ; tableindex = 0

; Activate the Interrupt
     bsf     INTCON,GIE      ; Enable Global Interrupt

MainLoop:
     btfsc   GPIO,GP5        ; Now we check the Button
     goto    CheckMode       ; if (GP5 != 0) goto CheckMode
     movlw   0x01
     addwf   keycount        ; keycount=keycount + 1
     movf    keycount,w
     sublw   MAX_DEBOUNCE
     btfss   STATUS,C        ; if (keycount > MAX_DEBOUNCE) goto KeyPressed
     goto    KeyPressed
     goto    CheckMode       ; else CheckMode

KeyPressed:
     clrf    keycount        ; keycount=0
     incf    mode            ; mode++
     movlw   0x03
     subwf   mode,w          ; W = mode - 0x03
     btfsc   STATUS,C        ; if (mode >= 0x03)
     clrf    mode            ; mode=0;
     movlw   0x01            ; else check the mode
     subwf   mode,w
     btfss   STATUS,C        ; if (mode >= 0x01) goto TurnOn
     goto    TurnOff         ; else goto TurnOff
     goto    TurnOn

TurnOff:
     bcf     INTCON,T0IE     ; Disable TIMER0 Interrupt
     clrf    pwm_count       ; pwm_count = 0
     clrf    pwm_m1          ; pwm_m1 = 0
     clrf    pwm_m2          ; pwm_m2 = 0
     bcf     GPIO,GP1
     bcf     GPIO,GP2
     movlw   .250
     call    DelayMs         ; DelayMs(250)
     movlw   .250
     call    DelayMs         ; DelayMs(250)
     goto    CheckMode

TurnOn:
     bsf     INTCON,T0IE     ; Enable TIMER0 Interrupt                    

CheckMode:
     movlw   0x01
     subwf   mode,w
     btfss   STATUS,Z        ; if (mode == 1) goto ShowMode1
     goto    CheckMode2
     goto    ShowMode1

CheckMode2:
     movlw   0x02
     subwf   mode,w
     btfss   STATUS,Z        ; if (mode == 2) goto ShowMode2
     goto    KeepLoop
     goto    ShowMode2

ShowMode1:                   ; Used ADC for PWM
     movlw   B'00000001'     ; Left Justify and turn on the ADC peripheral, channel 0 (AN0)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 0 (AN0)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Loop
     call    Delay1ms

     movlw   B'00000001'     ; Left Justify and turn on the ADC peripheral, channel 0 (AN0)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 0 (AN0)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Loop
     movf    ADRESH,w        ; Conversion Done, Read ADRESH
     movwf   pwm_m1          ; pwm_m1 = ADRESH
     call    Delay1ms

     movlw   B'00001101'     ; Left Justify and turn on the ADC peripheral, channel 3 (AN3)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 3 (AN3)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Test
     call    Delay1ms

     movlw   B'00001101'     ; Left Justify and turn on the ADC peripheral, channel 3 (AN3)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 3 (AN3)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Test
     movf    ADRESH,w        ; Conversion Done, Read ADRESH
     movwf   pwm_m2          ; pwm_m2 = ADRESH
     call    Delay1ms
     goto    KeepLoop

ShowMode2:                   ; Used Predefined Value for PWM
     movf    tableindex,w
     call    tablepwm1       ; Call tablepwm1
     movwf   pwm_m1          ; Assigned it to pwm_m1
     movlw   .30
     call    DelayMs         ; DelayMs(30)

     movf    tableindex,w
     call    tablepwm2       ; Call tablepwm2
     movwf   pwm_m2          ; Assigned it to pwm_m2
     movlw   .30
     call    DelayMs         ; DelayMs(30)

     incf    tableindex      ; tableindex++
     movlw   MAX_TBLINDEX
     subwf   tableindex,w
     btfss   STATUS,C        ; if (tableindex >= 0x0A) then tableindex = 0
     goto    KeepLoop
     clrf    tableindex      ; tableindex = 0

KeepLoop:
     goto    MainLoop        ; Goto MainLoop

; Predefined value table for Automatic PWM
tablepwm1:
     addwf   PCL,f
     retlw   0x10
     retlw   0x5A
     retlw   0x9A
     retlw   0x20
     retlw   0x40
     retlw   0x8A
     retlw   0x82
     retlw   0x30
     retlw   0x58
     retlw   0xAA

tablepwm2:
     addwf   PCL,f
     retlw   0x70
     retlw   0x8A
     retlw   0x2A
     retlw   0x30
     retlw   0x1C
     retlw   0x2A
     retlw   0x4B
     retlw   0xA0
     retlw   0x18
     retlw   0x2A

;----------------- DelayMs: Millisecond Delay Subroutine ----------------------
; Paramater: WREG = delay amount in milisecond, max: 255 millisecond
DelayMs:
     movwf   Delay + 1
DelayLoop:
     call    Delay1ms
     decfsz  Delay + 1,f     ; Decrease Delay + 1, If zero skip the next instruction
     goto    DelayLoop       ; Not zero goto DelayLoop
     return                  ; return to the caller

;----------------- Delay1ms: 1 ms Delay Subroutine ---------------------------
Delay1ms:                    ; Total Delay: 1998 x 0.5us ~ 1 ms
     movlw   0x99
     movwf   Delay
DelayLoop1:
     decfsz  Delay,f         ; Decrease Delay, If zero skip the next instruction
     goto    DelayLoop1
DelayLoop2:
     decfsz  Delay,f         ; Decrease Delay, If zero skip the next instruction
     goto    DelayLoop2      ; Not zero goto DelayLoop2
DelayLoop3:
     decfsz  Delay,f         ; Decrease Delay, If zero skip the next instruction
     goto    DelayLoop3      ; Not zero goto DelayLoop2
     return                  ; Return to the caller

     end
; EOF: laserlight.asm

The following is the Laser Projector Project code in C Language version:

// ***************************************************************************
//  File Name    : laserlight.c
//  Version      : 1.0
//  Description  : Laser Light Show Project
//  Author       : RWB
//  Target       : Microchip PIC12F683 Microcontroller
//  Compiler     : HI-TECH C PIC10/12/16 MCUs (Lite Mode) V9.70
//  IDE          : Microchip MPLAB IDE v8.46
//  Programmer   : PICKit3 (Firmware Suite Version: 01.25.20)
//  Last Updated : 03 April 2010
// ***************************************************************************
#include

/*   PIC Configuration Bit:
**   INTIO     - Using Internal RC No Clock
**   WDTDIS    - Wacthdog Timer Disable
**   PWRTEN    - Power Up Timer Enable
**   MCLRDIS   - Master Clear Disable
**   UNPROTECT - Code Un-Protect
**   UNPROTECT - Data EEPROM Read Un-Protect
**   BORDIS    - Borwn Out Detect Disable
**   IESODIS   - Internal External Switch Over Mode Disable
**   FCMDIS    - Monitor Clock Fail Safe Disable
*/
__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT \
  & UNPROTECT & BORDIS & IESODIS & FCMDIS);

// Using Internal Clock of 8 MHz
#define FOSC 8000000L

#define MAX_COUNT 200
#define MAX_TMR0 0xFB
#define MAX_DEBOUNCE 0x0A
#define MAX_TBLINDEX 0x0A

unsigned char pwm_count=0;
unsigned char pwm_m1=0;
unsigned char pwm_m2=0;
unsigned char tablepwm1[10]={0x10,0x5A,0x9A,0x20,0x40,0x8A,0x82,0x30,0x58,0xAA};
unsigned char tablepwm2[10]={0x70,0x8A,0x2A,0x30,0x1C,0x2A,0x4B,0xA0,0x18,0x2A};
unsigned char tableindex=0;

/* The Delay Function */
#define	delay_us(x) { unsigned char us; \
			        us = (x)/(12000000/FOSC)|1; \
			        while(--us != 0) continue; }

void delay_ms(unsigned int ms)
{
  unsigned char i;
  do {
    i = 4;
    do {
      delay_us(164);
    } while(--i);
  } while(--ms);
}

static void interrupt isr(void)
{
  if(T0IF) {	       // TIMER0 Interrupt Flag
    pwm_count++;       // PWM Count Increment
    if (pwm_count >= MAX_COUNT) {
      pwm_count=0;
      GPIO1=0;         // Turn off GP1
      GPIO2=0;         // Turn off GP2
    }

    if (pwm_count == pwm_m1) {
      GPIO1=1;         // Turn On GP1
    }    

    if (pwm_count == pwm_m2) {
      GPIO2=1;         // Turn On GP2
    }      

    TMR0 = MAX_TMR0;   // Initial Value for TIMER0 Interrupt
    T0IF = 0;	       // Clear TIMER0 interrupt flag
  }
}

void main(void)
{
  unsigned char mode,keycount;

  OSCCON=0x70;         // Select 8 MHz internal clock

  /* Initial Port Used */
  TRISIO = 0x39;       // GP1 and GP2 Output, GP0,GP3,GP4 and GP5 as Input
  CMCON0 = 0x07;       // Turn off Comparator (GP0, GP1, GP2)
  GPIO = 0x00;         // Turn Off all IO

  /* Init ADC Peripheral */
  ANSEL = 0x79;        // Set AN0 (GP0) and AN3 (GP4) as Analog Input, Internal Clock

  /* Init TIMER0: TIMER0 Period = 1/FSOC x 4 x Prescale x TMR0*/
  OPTION = 0b00000000; // 1:2 Prescale
  TMR0=MAX_TMR0 ;

  /* Init Variable Used */
  pwm_count=0;
  pwm_m1=0;
  pwm_m2=0;
  mode=0;
  keycount=0;
  tableindex=0;

  GIE =1;		       // Enable Global Interrupt

  for(;;) {
    // Display the LED
    if (GPIO5 == 0) {
      keycount++;
      if (keycount > MAX_DEBOUNCE) {
        keycount=0;
        mode = mode + 1;
        if (mode > 2) mode = 0;

        if (mode >= 0x01) {
          T0IE = 1;	       // Enable TIMER0 Interrupt on Overflow
        } else {
          T0IE = 0;	       // Disable TIMER0 Intterupt on Overflow
          pwm_count=0;
          pwm_m1=0;
          pwm_m2=0;
          GPIO1=0;             // Turn off GP1
          GPIO2=0;             // Turn off GP2
          delay_ms(500);
        }
      }
    }

    if (mode == 1) {
      /* Read the ADC here */
      ADCON0=0b00000001;       // select left justify result. ADC port channel AN0
      GODONE=1;	               // initiate conversion on the channel 0

      while(GODONE) continue;  // Wait for ldr_left conversion done
      pwm_m1=ADRESH;           // Read 8 bits MSB, Ignore 2 bits LSB in ADRESL

      delay_ms(1);

      /* Read the ADC here */
      ADCON0=0b00001101;       // select left justify result. ADC port channel AN3
      GODONE=1;	         // initiate conversion on the channel 4

      while(GODONE) continue;  // Wait for ldr_left conversion done
      pwm_m2=ADRESH;           // Read 8 bits MSB, Ignore 2 bits LSB in ADRESL     

      delay_ms(1);
    }

    if (mode == 2) {
      pwm_m1=tablepwm1[tableindex];
      delay_ms(10);
      pwm_m2=tablepwm2[tableindex];
      delay_ms(10);
      tableindex++;
      if (tableindex >= MAX_TBLINDEX)
        tableindex = 0;
    }
  }
}

/* EOF: laserlight.c */

Generating the PWM (Pulse Width Modulation)

The simple way to generate the PWM output is to take advantage of the PIC12F683 microcontroller PWM build in feature, but because the PIC12F683 only support one PWM output therefore we need to find a way to imitate this peripheral behavior in the firmware. Most of microcontroller PWM peripheral use TIMER peripheral to generate the pulse; in the PIC12F683 the PWM generator use the TIMER2 to generate the PWM output (CCP1) as shown on this following picture:

When TIMER2 start counting, the value of the TMR2 register (TIMER2 counter register) is constantly compared to both the PR2 and CCPR1L registers. When TMR2 equal to CCPR1L value the CCP1 output will be reset and when TMR2 equal to PR2 value it will set the CCP1 output. Therefore by changing the CCPR1L register value as shown on the picture above, we could change the PWM duty cycle (pulse width). You could read more about the principal of using the PIC microcontroller PWM peripheral on my previous posted blog H-Bridge Microchip PIC Microcontroller PWM Motor Controller.

Using the same principal I made the PWM generator in firmware base on the Microchcip PIC12F683 microcontroller TIMER0 peripheral as this following block diagram:

The basic principal of the TIMER0 base PWM generator is to use the TIMER0 overflow interrupt to increase our PWM counter variable pwm_count and if this variable reaches the MAX_COUNT (200) then we will reset both the GP1 and GP2 output pins. If not then we will compare it with the PWM duty cycle control variables pwm_m1 and pwm_m2, if equal then we simply set the GP1 or GP2 output pins. Using this principal now we could easily generate an efficient PWM signal base on the PIC12F683 microcontroller TIMER0 peripheral.

Now take a look at the PIC assembler code that implements the PIC12F683 microcontroller TIMER0 peripheral base PWM generator:

; Check the TIMER0 Interrupt here
     btfss   INTCON,T0IF
     goto    ExitISR         ; If (T0IF != 1) then Exit ISR
     bcf     STATUS,RP0      ; Select Registers at Bank 0
     incf    pwm_count       ; pwm_count++
     movlw   MAX_COUNT
     subwf   pwm_count,w     ; if (pwm_count < MAX_COUNT) then CheckPWM
     btfss   STATUS,C        ; else clear GP1 and GP2
     goto    CheckPWM
     bcf     GPIO,GP1        ; GPIO1=0
     bcf     GPIO,GP2        ; GPIO2=0
     goto    ExitPWM

This routine first examine if this interrupt is generated by TIMER0 peripheral by checking the T0IF bit on the INTCON register, if this interrupt come from TIMER0 then the T0IF bit will be set (logical “1“) then we continue to increase the pwm_count variable and if it reach the MAX_COUNT we reset the GP1 and GP2 output pins. Next if the pwm_count is not reaches the MAX_COUNT, then compare its value to the pwm_m1 and pwm_m2 variables as shown on this following code:

CheckPWM:
     movf    pwm_m1,w
     subwf   pwm_count,w
     btfsc   STATUS,Z        ; if (pwm_count == pwm_m1) then Set GP1
     bsf     GPIO,GP1        ; Set GP1 Bit
CheckM2:
     movf    pwm_m2,w
     subwf   pwm_count,w
     btfsc   STATUS,Z        ; if (pwm_count == pwm_m2) then Set GP2
     bsf     GPIO,GP2        ; Set GP2 bit

When the pwm_count equal to pwm_m1 or pwm_m2 then we set (logical “1“) each of the GP1 and GP2 output pins.

To calculate the PWM period, first we have to calculate the TIMER0 period using this following formula:

TIMER0 Period = 1/Fosc x 4 x Prescale x (TMR0 + 1)

In this tutorial we use 1:2 prescale, TMR0 = 251 (0xFB) and 8 MHz internal oscillator, therefore the TIMER0 will be interrupted every:

TIMER0 Period = 1/8000000 x 4 x 2 x (256 - 251) = 0.000005 second

Every time the TIMER0 interrupted (TMR0 overflow), we will increase the pwm_count variable until it reach the MAX_COUNT (200), then we will reset each of the GP1 and GP2 output pins. Therefore the approximately PWM period could be calculated as follow:

PWM Period = MAX_COUNT x 0.000005 seconds = 200 x 0.000005 = 0.001 second
PWM Frequency = 1 / T = 1/0.001 = 1000 Hz = 1KHz

Changing the DC Motor Speed

This laser projector project has two mode for controlling both of the DC motors speed, the first one is to use the trimports (VR1 and VR2) where we read the voltage level produce by these trimports (voltage divider circuit) using the PIC12F683 microcontroller Analog to Digital Converter (ADC) peripheral, then apply these ADC values to change each of the DC motor speed. The second one is to use the fixed value stored in the lookup table and then assign these values to change each of the DC motor speed.

The Microchip PIC12F683 microcontroller has four ADC channels available; on this project we use the channel 0 (AN0) and the channel 4 (AN3). By choosing the require ADC channel on the ADCON0 register (the ADC control register) and selecting the left justify result (ADFM=0) we could read the voltage value produced by each of the VR1 and VR2 trimports in ADRESH register and assign these value to pwm_m1 and pwm_m2 variables as shown on this following PIC assembly code:

ShowMode1:                   ; Used ADC for PWM
     movlw   B'00000001'     ; Left Justify and turn on the ADC peripheral, channel 0 (AN0)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 0 (AN0)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Loop
     call    Delay1ms

     movlw   B'00000001'     ; Left Justify and turn on the ADC peripheral, channel 0 (AN0)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 0 (AN0)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Loop
     movf    ADRESH,w        ; Conversion Done, Read ADRESH
     movwf   pwm_m1          ; pwm_m1 = ADRESH
     call    Delay1ms

     movlw   B'00001101'     ; Left Justify and turn on the ADC peripheral, channel 3 (AN3)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 3 (AN3)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Test
     call    Delay1ms

     movlw   B'00001101'     ; Left Justify and turn on the ADC peripheral, channel 3 (AN3)
     movwf   ADCON0          ; Vreff=Vdd
     bsf     ADCON0,GO       ; Start the ADC Conversion on channel 3 (AN3)
     btfss   ADCON0,GO       ; while(GO == 1)
     goto    $-1             ; Keep Test
     movf    ADRESH,w        ; Conversion Done, Read ADRESH
     movwf   pwm_m2          ; pwm_m2 = ADRESH
     call    Delay1ms
     goto    KeepLoop

For more information about using the PIC ADC peripheral you could read my previous posted blog PIC Analog to Digital Converter C Programming.

Next is the automatic mode, this mode will assign the predetermined value for each PWM value on the PIC program flash. By using the PIC assembler “retlw k” (return literal value k on the W register) instruction we could easily retrieve these values. The following PIC assembly code shows how we do it:

ShowMode2:                   ; Used Predefined Value for PWM
     movf    tableindex,w
     call    tablepwm1       ; Call tablepwm1
     movwf   pwm_m1          ; Assigned it to pwm_m1
     movlw   .30
     call    DelayMs         ; DelayMs(30)
     movf    tableindex,w
     call    tablepwm2       ; Call tablepwm2
     movwf   pwm_m2          ; Assigned it to pwm_m2
     movlw   .30
     call    DelayMs         ; DelayMs(30)

     incf    tableindex      ; tableindex++
     movlw   MAX_TBLINDEX
     subwf   tableindex,w
     btfss   STATUS,C        ; if (tableindex >= 0x0A) then tableindex = 0
     goto    KeepLoop
     clrf    tableindex      ; tableindex = 0
...
...
; Predefined value table for Automatic PWM
tablepwm1:
     addwf   PCL,f
     retlw   0x10
     retlw   0x5A
     retlw   0x9A
     retlw   0x20
     retlw   0x40
     retlw   0x8A
     retlw   0x82
     retlw   0x30
     retlw   0x58
     retlw   0xAA

tablepwm2:
     addwf   PCL,f
     retlw   0x70
     retlw   0x8A
     retlw   0x2A
     retlw   0x30
     retlw   0x1C
     retlw   0x2A
     retlw   0x4B
     retlw   0xA0
     retlw   0x18
     retlw   0x2A

The principal here is to modify the PCL (program counter loading) register. The PCL is the PIC12F683 microcontroller program counter least significant byte and together with the PCLATH register forming the PIC12F683 microcontroller 13-bits wide program counter. The “goto” command behavior could be achieved by manipulating the PCL content, for example:

     movlw   0x01
     call    tablepwm2
     nop

tablepwm2:
     addwf   PCL,f
     retlw   0x70
     retlw   0x8A
     retlw   0x2A

When the PIC microcontroller run the “call tablepwm” instruction then it immediately change the program counter (PCL) to the program address pointed by “tablepwm2” label which is the “addwf PCL,f” instrunction. When the PIC microcontroller execute this instruction it will add the content of W register (0×01) to the PCL register and the PIC microcontroller immediately jump to the “PCL + 0×01” program address. Next it will execute the “retlw 0×8A” instruction and it simply return to the caller with 0×8A value on the W register.

Therefore by increasing the tableindex (the lookup table pointer) variables we could easily assigned the predetermined value on each of the pwm_m1 and pwm_m2 variables.

The basic of PIC Assembly if condition

One of the confusing part in understanding the PIC assembly instruction especially for the beginner is “how to implement the if condition” in the assembly code. In this laser projector project PIC assembly code you noticed that it use quite a lot of “if condition” in order to make it work. The basic of PIC assembler “if condition” could be constructed using this following first template code:

movf   var_1,w   ; w = var_1
subwf  var_2,w   ; w = var_2 - var_1
btfss  STATUS,C  ; if (var_2 >= var_1) goto label_2
goto   label_1   ; else goto label_1
goto   label_2

The first code (movf var_1,w) instructs the PIC microcontroller to put the content of var_1 into the W (working) register. The second code (subwf var_2,w) instructs the PIC microcontroller to subtract the content of var_2 variable with the content of W register and put the result in the W register or we could write down as:

W = var_2 - var_1

The third code (btfss - bit test f register, skip if set) instructs the PIC microcontroller to examine if the C (carry) bit in the STATUS register is set (logical “1“), if it set then skip one instruction (the PIC microcontroller actually will automatically replace the next instruction goto label_1 with the nop instruction) and it will execute the “goto label_2” code. If the C bit is clear (logical “0“) then it will execute the “goto label_1” code.

The C (carry) bit in STATUS register will always set (logical “1“) if the value of var_2 variable is greater or equal to var_1 variable. Next, the second “if condition” template is shown on this following code:

movf   var_1,w   ; w = var_1
subwf  var_2,w   ; w = var_2 - var_1
btfss  STATUS,Z  ; if (var_2 == var_1) goto label_2
goto   label_1   ; else goto label_1
goto   label_2

This time we will examine the Z (zero) bit in the STATUS register, The Z (zero) bit will always set (logical “1“) when the var_2 value equal to var_1 value. Last, the third “if condition” template is shown on this following code:

movlw  0x08      ; w = 0x08
subwf  var_1,w   ; w = var_1 - 0x08
btfss  STATUS,C  ; if (var_1 >= 0x08) goto label_2
goto   label_1   ; else goto label_1
goto   label_2

This third template is just a variation of the first template, this time we load the literal value 0×08 on the W register and compare it with the var_1 variable. By using just these three “if condition” templates, you could easily implement many types of the “if condition” in your code. The key to understand and implement the PIC assembly “if condition” instruction successfully in your code is to use these templates consistently, once you understand than you could modify or combine it with the btfsc (bit test f register, skip if clear) instruction or any PIC assembler instruction that effecting the C and Z bits in the STATUS register to make your assembly code more efficient.

To make the PIC assembly code easier to understand, in this laser projector tutorial I put many comments in the code and you could also compare it with the equivalent C language code provided for this project. The C language code uses the same variable name as in the PIC assembly code for easier comparison purpose.

Inside the PIC Assembler Code

The laser projector project use the PIC12F683 microcontroller TIMER0 and ADC peripheral to control each of the DC motors speed. These following instructions are used to initial the PIC12F683 peripherals:

Main:
     bsf     STATUS,RP0      ; Select Registers at Bank 1
     movlw   0x70
     movwf   OSCCON          ; Set the internal clock speed to 8 MHz
     movlw   0x39            ; GP1 and GP2 Output, GP0,GP3,GP4 and GP5 as Input
     movwf   TRISIO          ; TRISIO = 0x39        

     bcf     STATUS,RP0      ; Select Registers at Bank 0
     movlw   0x07
     movwf   CMCON0          ; Turn off Comparator (GP0, GP1, GP2)
     clrf    GPIO

; Now we Set the ADC Peripheral
     bsf     STATUS,RP0      ; Select Registers at Bank 1
     movlw   0x79            ; Set AN0 (GP0) and AN3 (GP4) as Analog Input
     movwf   ANSEL           ; Using the Internal Clock (FRC)  

; Now we set the TIMER0 Peripheral
; TIMER0 Period = 1/FSOC x 4 x Prescale x TMR0
     movlw   0x00            ; Use TIMER0 Prescaler 1:2, Internal Clock
     movwf   OPTION_REG      ; OPTION_REG = 0x00

     bcf     STATUS,RP0      ; Select Registers at Bank 0
     movlw   MAX_TMR0
     movwf   TMR0            ; TMR0=MAX_TMR0     

; Initial the variables used
     clrf    mode            ; Default mode = 0, Light Show Off
     clrf    pwm_count       ; pwm_count = 0
     clrf    pwm_m1          ; pwm_m1 = 0
     clrf    pwm_m2          ; pwm_m2 = 0
     clrf    keycount        ; keycount = 0
     clrf    tableindex      ; tableindex = 0

; Activate the Interrupt
     bsf     INTCON,GIE      ; Enable Global Interrupt

The first instruction is to set the OSCCON (oscillator control) register to use the 8MHz internal clock, next we set the TRISIO (the three state I/O controller buffer) register for the input and output port and turn off the comparator peripheral on CMCON0 (comparator control) register. After resetting the GPIO (general purpose I/O) register we continue to setting the ANSEL (analog select) register for the ADC peripheral and OPTION_REG for the TIMER0 peripheral and initial all the variables used in the program by clearing them.

Right before entering the infinite loop we activate the GIE (global interrupt enable) bit in the INTCON (interrupt control) register so the TIMER0 interrupt could occur when the TMR0 (TIMER0 counter) register overflow (more than 255).

Inside the infinite loop (the MainLoop label), we continuously checked the mode variable; the mode value is used to determine the program behavior. When the mode value is 0 then the program simply continuously loop, when the mode value is 1 then the program will use the ADC value to control each of the DC motor speed and when the mode value is 2 then the program will use the look-up table to control the PWM signal (automatic mode).

The PIC Assembly Code and the C Code Comparison

Since in this project I use the PIC Assembly language and the C language for the firmware; it would be interest to compare both the HEX program sizes. The following is the HEX code produced by the Microchip PIC Assembler and HI-TECH C PRO (Lite Mode) compiler.

The HEX code produce by the HI-TECH C PRO compiler is 356 Word (623 Byte) in “Lite Mode“, but if the C code is compiled in “PRO Mode” the size will be 40% smaller or it’s about 214 Word (374.5 Bytes), on the other hand the Microchip Macro Assembler produce 180 Word (315 Bytes) for the HEX code. Now you could see, that if we use the professional C language compiler it could produce a very small HEX code where it almost equal to the HEX code produced by the Assembly language.

Downloading the HEX Code

After compiling and simulating your code it’s time to download the code using the Microchip PICKit3 programmer, connect the PICKit3 ICSP (Microchip In Circuit Serial Programming) port to your PIC12F683 microcontroller pins then from the Programmer menu Select Programmer -> PicKit3 and the select the Programmer -> Program menu to download your HEX code into the PIC12F683 microcontroller flash.

Now it’s time to enjoy the laser projector project presented in this following video:

The Final Though

In this laser projector project both the PIC Assembly and C code demonstrate that the 2048 bytes of the 8-bit Microchip PIC12F683 microcontroller flash is still adequate to handle more advanced application such as the PICAXE-08M microcontroller from the Revolution Education Ltd, this microcontroller is based on the Microchip PIC12F683 microcontroller and they put a powerful BASIC (Beginners for All Purpose Symbolic Code) interpreter inside, so the PICAXE-08M could be used as a complete development framework for the embedded system application. You could read more information about the PICAXE microcontroller in my previous posted blog Introduction to the embedded system with PICAXE microcontroller.

Using the TIMER peripheral to generate the PWM signal as shown on this project could be applied to almost any microcontrollers available today. The basic principal shown here also could be easily modified to drive the multiple servos output as the servo use the PWM signal to control its movement.

Working with the Comparator Circuit

rwb — Mon, 15 Mar 2010 14:28:58 +0000

Sometimes in the embedded system world we need to process the analog world and sending the signal to the microcontroller when the analog signal exceed some predetermine limit we’ve set. Some example of this situation is to send the interrupt signal to the microcontroller operation when the temperature is already exceeds certain limit or the light intensity exceeds certain bright level. This is when the comparator circuit becomes handy as it’s designed specially for this purpose.

Today the modern comparator is easily found in the form of integrated circuit such as the popular National Semiconductor LM339 quad (four) comparator 14 pins dual in line (DIL) package bellow:

When you look closely to the comparator symbol, some of you will recognize it as the Op-Amp (Operational Amplifier) symbol, so what make this comparator differ from its big brother; Op-Amps is designed to accept the analog signal and outputting the analog signal while the comparator only outputting the digital signal; although the ordinary Op-Amp could be used as the comparator such as the popular National Semiconductor LM324 quad Op-Amps, but the real comparator is designed to have a faster switching time comparing to the multipurpose Op-Amps. Therefore you could say that the comparator is the modified version of the Op-Amps which specially designed to give the digital output.

1. Basic Comparator Circuit

The comparator circuit work by simply taking two analog inputs, comparing them and produce the logical output high “1” or low “0“.

By applying the analog signal to the comparator + input called “non-inverting” and - input called “inverting“, the comparator circuit will compared this two analog signal, if the analog input on + input is greater than the analog input on - input (inverting) then the output will swing to the logical “1” and this will make the open collector transistor Q8 on the LM339 equivalent circuit above to turn ON. When the analog input on + input (non inverting) is less than the analog input on - input (inverting) then the comparator output will swing to the logical “0” (the Q8 transistor turn OFF). Furthermore on this tutorial, I will use the term non-inverting and inverting instead of + input and - input on the comparator analog input.

As you’ve seen from the LM339 equivalent circuit picture above, the LM339 use an open collector transistor Q8 for its output, therefore we have to use what is called “pull-up” resistor connected to the Q8 collector lead with the Vcc in order to make this Q8 transistor work. The maximum current that could flow on this Q8 transistor (output sink current) according to the LM339 datasheet is about 18 mA.

The testing circuit simply connects the comparator inverting input to the voltage divider R1 and R2, with 5 Volt voltage supply the V- could be calculated as follow:

V- = (R2 / (R1 + R2)) x Vcc
V- = (10 / 20) x 5 volt = 2.5 volt

For more information about the voltage divider circuit please refer to my previous posted blog Basic Resistor Circuit.

The comparator non-inverting input is connected to the 10 K trimport which is also forming the voltage divider circuit where we could adjust the V+ voltage start from 5 volt down to 0 volt. First when the V+ is equal to Vcc (5 volt) the comparator output will swing to the logical high (Vout = Vcc) because the V+ is greater than V- (2.5 volt). This will switch the Q8 transistor OFF and the LED will turn OFF. When the voltage V+ drop bellow 2.5 volt, the comparator output will swing to the logical low (Vout = GND) and this will switch the Q8 transistor ON and the LED will turn ON.

By swapping the analog input; the R1 and R2 voltage divider connected to the non-inverting input (V+) and the trimport connected to the inverting input (V-) we will get the opposite output result.

Again using the voltage divider principal the voltage on the non-inverting input (V+) is about 2.5 volt, therefore if we start the inverting input voltage (V-) at 5 volt; the V+ is lower than the V-, this will make the comparator output will swing to the logical low (the Q8 transistor ON) and the LED will turn ON. When we adjust the V- down bellow the 2.5 volt (V+) than the comparator output will swing to the logical high (the Q8 transistor OFF) because the V+ now is greater than V- and the LED will turn OFF. You could see all of this experiment on the video at the end of this tutorial.

As you’ve seen from the experiment above, the comparator is usually used to compare one variable analog signal with predetermined analog signal or we could call it as the reference voltage. Therefore by placing the reference voltage to the inverting or non-inverting input we could manage the comparator output accordance to our need. This comparator circuit is also known as the zero crossing detector circuit.

The following schema show you how we utilized the zero crossing detector circuit in the infra-red reflective detector usually found in many robotics projects.

When the infra-red LED beam reflected back to the photo transistor, the photo transistor will turn ON; this will make the reference voltage (V+) become greater than the input voltage (V-). This condition will make the comparator give a logical high to the microcontroller I/O port. When the infra-red LED beam is blocked, the photo transistor will turn OFF; this will make the input voltage (V-) become greater than the reference voltage (V+) and the comparator will give a logical low to the microcontroller I/O port.

Hmm, by applying the circuit schema above to all the comparators in the LM339 package (four comparators), we could make a very sensitive infrared reflector sensors for sensing the black/white line used in many line follower or line maze solver robot.

2. Comparator with the Positive Feedback

One of the drawbacks with the zero crossing detector on the circuit above is; it’s very sensitive to the noise signal (small interference signal) on its input as shown on this following picture:

Because the comparator basically is an uncompensated high gain operational amplifier, therefore this could make the comparator to start oscillate or continuously giving high and low output. To compensate this behavior we could apply a small amount of voltage feedback to the non-inverting input as shown on this following schema:

To analyze this circuit first we assume the output voltage is high; in order to meet this condition the V- (inverting input) voltage should be lower than the V+ (non-inverting input) voltage. When the V- voltage increases toward the V+ voltage, this will drive the Vout toward ground which will also shift the V+ voltage through the R3 resistor. Because the V+ is the non-inverting input to the comparator; this feedback will help to drive down the Vout to ground even faster. The opposite condition also occur when the V- voltage decrease, because of the R3 resistor feedback on the V+ input; this feedback will shift the V+ voltage input will ensure a faster switching result to logical high (Vcc) on the Vout.

The V+ voltage upper threshold (VUT) to make the Vout voltage to swing to ground could be calculated as this following formula.

VUT = (R2 / (R2 + R1||R3)) x Vout

We assume the Vout equal to Vcc when the output is high then we could have this following formula:

VUT = (R2 / (R2 + R1||R3)) x Vcc

and

R1||R3 = (R1 x R3) / (R1 + R3).

Substituting the R1||R3 (R1 parallel R3) inside this equation we will get this following formula:

VUT = (Vcc x R2 x (R1 + R3)) / (R1 x R2 + R1 x R3 + R2 x R3).

The V+ voltage lower threshold (VLT) to make the Vout voltage to swing to high (Vcc) could be calculated as this following formula.

VLT = (R2||R3 / (R2||R3 + R1)) x Vcc
and

R2||R3 = (R2 x R3) / (R2 + R3).

Again by substituting the R2||R3 (R2 parallel R3) inside this equation we will get this following formula:

VLT = (Vcc x R2 x R3) / (R1 x R2 + R1 x R3 + R2 x R3).

The different between the upper and lower threshold voltage is called the hysteresis voltage:

VH = VUT - VLT

Therefore by applying the upper and lower threshold formula, we could get the hysteresis voltage as follow:

VH = (Vcc x R1 x R2) / (R1 x R2 + R1 x R3 + R2 x R3).

To insure that Vout will swing between Vcc and ground we have to choose:

R3 > R pull-up and R pull-up < R load

Therefore by assigning the R pull-up = 10K, R1 = R2 = R3 = 100K and using the 5 volt supply we could calculate the upper and lower threshold voltage as follow:

VUT = 2/3 Vcc and VLT = 1/3 Vcc

The different between the upper and lower threshold is called the hysteresis voltage:

VH = 1/3 Vcc

The common way to represent the hysteresis graph instead of using two graphs as shown on the above picture is by assigning the Vout on the Y axis and V- (in) on the X axis, now we could get this following picture:

Therefore by shifting the V+ voltage with the R3 feedback resistor we could compensate the comparator output to become more immune to the noise signal. This hysteresis comparator circuit also could be used as a Schmitt Trigger with the adjustable threshold point by just changing the value of R1, R2 and R3 resistors respectively.

One of the interesting usages of this hysteresis behavior is to use the comparator as the pulse generator or oscillator; where you could easily make a simple LED blinker as shown on this following circuit bellow:

Again to analyze this circuit first we assume the Vout is high, this will turn on the TR1 transistor and the LED will be ON. In order to meet this condition the V- should be less than V+ (V- almost zero) or we could say that the C1 is now being charged through the R4 resistor. Now the V- will slowly increase and because of the voltage shift provided by the R3 feedback resistor on the V+ input; this will make the Vout rapidly swing to the logical low (LED OFF) and this time the C1 will discharge its energy through the R4 resistor and the V- will decrease; when it reach bellow the V+ then the process will repeat again. You could easily change the LED blink rate by changing the R4 and C1 value respectively.

The output frequency could be calculated using this following formula (taken from AN-74: National Semiconductor Application Note 74):

Where R4 is the resistance in Ohm, C1 is the capacitance in Farad and freq. is the pulse frequency in Hertz. Therefore using this formula, we could calculate the frequency of the LED blinker circuit above as follow:

1 / Freq. = 2 (0.694) x 470000 x 0.0000001 = 0.65236
Frequency = 1 / 0.65236 = 1.53 Hertz

By using different R4 and C1 values on each comparator in the LM339 package (four comparators) you could assembly four independent LED blinker with each of them have a different blink rate. By hooking up to 4 LEDs on each 2N2222 transistor you could get a very nice random LED blink effect similar to the main computer panel shown on many sci-fi movies.

3. The Limit Window Comparator

Using a single comparator we could only have one voltage reference value, if we want to have two voltage reference values; where we could set the upper and lower voltage level limit value to determine the output; we could used what is called the limit window comparator circuit or also known as dual edge limit detector circuit. On our next experiment we will build the light sensor circuit with the LDR (light dependent resistor) as the sensor and using the limit window comparator circuit. This circuit will light up the LED according to the light intensity detected by LDR. The complete example circuit is shown on this following schema:

To analyze the circuit above; first we assume that the VR2 is equal to 10K; Again the R1, VR2 and R2 will form the voltage divider circuit to both V1 and V2:

V1 = ((R2 + VR2) / (R1 + VR2 + R2)) x Vcc = 2/3 Vcc
V2 = (R2 / (R1 + VR2 + R2)) x Vcc = 1/3 Vcc

The LDR and the VR1 are also forming the voltage divider circuit on the Vin:

Vin = (VR1 / (VR1 + LDR) x Vcc

Therefore if Vin is greater than V1 and V2 (Vin > 2/3 Vcc) then the comparator CMP1 output will swing to the logical low and make the TR2 to turn OFF (LED2 OFF), while the comparator CMP2 output will swing to the logical high, this will power the TR1 base make the TR1 to turn ON (LED2 ON).

When the Vin is less then V1 but greater than V2 (1/3 Vcc < Vin < 2/3 Vcc) then the comparator CMP1 output will swing to logical high and make the TR2 to turn ON (LED2 ON). The comparator CMP2 output also will swing to the logical high, this will provide the necessary voltage input on the TR1 base to make it ON (LED1 ON).

The last when the Vin voltage goes bellow the V1 and V2 (Vin < 1/3 Vcc) then the comparator CMP1 output will swing to logical high and make the TR2 to turn ON (LED2 ON), while the comparator CMP2 output will swing to the logical low and make the TR1 to turn OFF (LED1 OFF).

Therefore by adjusting the VR1 and VR2 you could easily adjust the Vin and set the upper and lower voltage reference level limit as necessary.

By connecting both comparator open collector output (wired-OR) we could get the desired response, where the output only swing to the logical high (”1“) when Vin voltage is within the Lower and Upper limit voltage.

The limit window comparator mostly used to detect two conditions such as for the temperature sensor, when the temperature exceed the upper limit or way down below the lower limit; the limit window comparator output will send the warning or control signal to the microcontroller I/O port

4. Comparator inside the Microcontroller

On this last comparator tutorial we will take a look at the comparator circuit inside the microcontroller. Most of today’s modern microcontroller has already equipped with this feature. Usually it being used as the zero crossing detector circuit, where it takes two analog inputs and compares them; then produce the interrupt according to the voltage input level on both input.

Now let’s take a look at the Atmel AVR ATTiny25 microcontroller; it’s one of the smallest and yet powerful 8-bit 8-pins AVR family microcontroller which has a build in one powerful analog comparator circuit inside.

The AIN0 (PB0) could be used as the comparator’s non-inverting input and the AIN1 (PB1) could be used as the comparator inverting input. We also could choose to use the AVR ATTiny25 microcontroller internal reference voltage 1.1 volt connected to the non-inverting input. To understand how this analog comparator works, I use a simple circuit to demonstrate how we could use the microcontroller analog comparator as the zero crossing detectors. This time I will take advantage of the internal reference voltage on the non-inverting input and connect the comparator inverting input to the LDR and trimport. This following schema shows you the example of light detector using the ATTiny25 microcontroller analog comparator feature.

The following is the AVR microcontroller assembler code that demonstrates this capability:

;***************************************************************************
; File Name    : comparator.asm
; Version      : 1.0
; Description. : Zero Crossing Detector Examples
; Author       : RWB
; Target       : AVR ATTiny25
; Compiler     : AVR macro assembler 2.1.41 (build 1792)
; IDE          : Atmel AVR Studio 4.17
; Programmer   : Atmel AVRISPmkII
; Last Updated : 01 March 2010
;***************************************************************************
.include "tn25def.inc"

; Use AVR ATTiny25 Default Frequency Clock
.equ F_CPU = 8000000

.cseg

; Start on the flash ram's address 0
.org 0
        rjmp  main             ; Jump to the Main Program

.org    ACIaddr                ; 0x0007 - Analog Comparator Interrupt Vector
        rjmp  a_comp           ; Jump to Analog Comparator Interrupt Handler

; Analog Comparator Interrupt Routine Handler
a_comp: in    R0,SREG          ; Save the SREG Status
        sbic  ACSR,ACO         ; if (AC0 == 0), V- > 1.1V, Turn Off LED
        rjmp  led_on           ; else, V- < 1.1 V, Turn On LED
        cbi   PORTB,PB4        ; Turn Off LED on PB4
        rjmp  ex_int           ; Goto Exit Interrupt
led_on: sbi   PORTB,PB4        ; Turn On LED on PB4
ex_int: out   SREG,R0          ; Restore the SREG Status
        reti                   ; Return from Interrupt Handler

; Start the Main Program
main:   ldi   R24,RAMEND       ; Initial Stack Pointer
        out   SPL,R24          ; SP = RAMEND

; Initial the I/O Used
        ldi   R16,0b00010000   ; Set PB4=Output, PB0,PB1,PB2,PB3,PB5 and PB6 as Input
        out   DDRB,R16         ; DDRB=0x10

; Initial the Analog Comparator
        cbi   ADCSRB,ACME      ; Disable Multiplex Inverting input, just use AN1 (PB1)
        cbi   ACSR,ACD         ; Enable Analog Comparator
        sbi   ACSR,ACBG        ; Use 1.1V (Band Gap) Internal Reference on AN0-Non Inverting Input
        cbi   ACSR,ACIS1       ; Use Interrupt Output Toggle
        cbi   ACSR,ACIS0

        ldi   R16,0b00000011   ; Disable Digital Input on AN0 (PB0) and AN1 (PB1)
        out   DIDR0,R16

        sbi   ACSR,ACIE        ; Enable Analog Comparator Interrupt
        sei                    ; Enable Global Interrupt

loop:   rjmp  loop             ; Loop Forever and Let the Interrupt do the work

.exit

; EOF: comparator.asm

The analog comparator inside the Atmel AVR ATTiny25 microcontroller is capable to use multiplex inverting analog input from ADC0, ADC1, ADC2 and ADC3, but on this tutorial I will use the AN1 (PB1) as the inverting input which connected to the LDR and 10 K trimport voltage divider circuit. By clearing the ACME (Analog Comparator Multiplex Enable) bit on the ADCSRB register, we simply disable this feature.

The non-inverting input is designed to use the 1.1 volt internal reference voltage by enabling the analog comparator band gap (ACBG) bit on the ACSR register. By enabling the analog comparator interrupt (ACIE) bit on the ACSR register, we could instruct the AVR ATTiny25 microcontroller to generate interrupt on every output toggle by clearing the ACIS1 and ACIS0 bits on the ACSR register. Therefore by examining the analog comparator output (ACO) bit on the ACSR register we could easily determine whether the V- inverting voltage (AN1) is less or greater than the V+ (AN0) inverting voltage and use this information to toggle the PB4 output port to make the LED ON and OFF. You could read more about programming the AVR assembler code on my previous posted blog Beginners AVR Assembler Language Programming 1

Using the powerful Atmel AVR Studio v4.17 integrated development environment you could easily compile and debug this AVR assembler code, and then down load the hex code into the ATTiny25 microcontroller flash ram using the AVR microcontroller programmer; on this tutorial I used Atmel AVRISPmkII programmer.

Now you could enjoy this following video which showing all the experiments we’ve already done on this tutorial

The Final Thought

The comparator or op-amps in general is one of the breakthroughs in the integrated circuit development as this tiny smart circuit has tremendous applications in electronics industries. Therefore understanding of how the comparator work will help you take the advantage of this amazing circuit in your next electronics or embedded system project.

Build Your Own Simple and Easy PICAXE Microcontroller Based Photovore Robot

rwb — Thu, 04 Feb 2010 11:34:43 +0000

Building a simple and easy microcontroller based robot is always a fascinating topic to be discussed, especially for the robotics newbie enthusiast. On this tutorial I will show you how to build your own microcontroller based robot which known as a photovore or you could call it as the light chaser robot using the simplest possible circuit for the microcontroller based robot brain, locomotion motor and the sensor.

One of the most frustrating parts when building your first microcontroller based robot is to program it and to download it into the microcontroller flash ram. On this tutorial this kind of “trouble maker” is being reduced as we will use the PICAXE programming editor from the Revolution Education Ltd (http://www.rev-ed.co.uk/picaxe) as our Integrated Development Environment (IDE) to program our robot brain using the BASIC (Beginners All Purpose Symbolic Instruction Code) language and to download the program into the PICAXE 28X1 microcontroller.

The PICAXE 28X1 microcontrollers actually is based on the popular Microchip 8-bit 28 pins PIC16F886 microcontroller that have a preload PICAXE BASIC interpreter firmware inside, in fact when you buy it its looks the same as the usual Microchip PIC16F886 microcontroller. Together with the free PICAXE Programming Editor and simple serial cable connector for the program downloader makes this PICAXE framework suitable for beginners and even for the professional.

You could read more information about the PICAXE microcontroller on my previous posted blog “Introduction to the Embedded system with PICAXE Microcontroller“.

On this tutorial I will refer this photovore robot as the BRAM-AXE as this is a simplify version of the more advanced version of its big brother BRAM (Beginners Robot Autonomous Mobile) which you could read more information about it on my previous posted blog “Building BRAM your first Autonomous Mobile Robot using Microchip PIC Microcontroller – Part 1” and “Behavior Based Artificial Intelligent Mobile Robot with Sharp GP2D120 Distance Measuring Sensor - BRAM Part 2“.

The BRAM-AXE robot simply use its light sensitive sensor to navigate to the light source, when it being placed in the dark environment it will automatically switch to the light search mode and try to find the light source, when it encounter the light source it will navigate to the light source and when the light source intensity is bright enough it will stop and enjoying the light. You could see all this behavior on the video at the end of this tutorial. Ok now let’s list down all the electronics parts, robot chassis materials and software needed to build this interesting robot.

BRAM-AXE board: based on the PICAXE 28X1 microcontrollers together with the PICAXE serial downloader cable which you could easily build from my previous posted blog “Make your own Microcontroller Printed Circuit Board (PCB) using the Toner Transfer Method“.
Two LDR and Two 1K Ohm 0.25 watt resistor
Two Continues Servo (on this tutorial I use the Parallax Continues Servo)
Two toys tire to be attached to the servo’s arms
Enough cables and Tubing (1mm and 3mm)
3 x AA battery holder with 3 x AA alkaline battery
1 CD or DVD
A good double tape or epoxy glue for the permanent robot
One paper clips and neck less beads for the robot caster (the robot’s third wheel)
Enough bolts and nuts for the caster
PICAXE Programming Editor from Revolution Education Ltd which you could download from their website

The BRAM-AXE Chassis Assembly

The BRAM-AXE main chassis is made from the CD/DVD which you could find easily at home or just use the blank one as I did if you don’t have any discarding CD/DVD at home. For the wheel you could use any toy’s wheel or you could use anything that has a circle form as long as the diameter is greater or equal to the servo’s arms.

The assembly of BRAM-AXE chassis is straight forward; you just need to drill two holes for placing the caster. Attached the two continues servo on the button of the CD/DVD with the double tapes and attached the wheel to the servo’s arms with the double tape or you could use the epoxy for permanent one. You could see the whole process on these following pictures:

Now attached the 3 x AA battery holder and BRAM-AXE board on top of the CD; again using our flexible friend the double tape as shown on these following pictures.

Connect the power socket to the BRAM-AXE polarized power pin and the servo’s socket to the BRAM-AXE board output 0 and output 1 three pins socket respectively as shown on this following servo’s circuit diagram.

The BRAM-AXE board output pins is design to be attached directly with the servo, every output pins provide both power and ground needed to power the servo. Connect the left servo connector to the BRAM-AXE output 0 and the right servo connector to the BRAM-AXE output 1. After finishing all this steps now it’s the time to test the robot steering mechanism.

The BRAM-AXE Steering Method

The BRAM-AXE steering use the simple method called the “differential drive“; when the two servos rotate on the same direction the robot will move forward or backward, and when they rotate on different direction (counter rotation to each other) the robot will rotate to left or right.

Servo basically is a high quality geared DC motor with electronic circuit for controlling the DC motor rotation direction and position; its being used widely in model hobbyist such as car R/C model for steering and acceleration control or airplane R/C model for moving the rudder, ailerons, elevators and acceleration control. Typically there are two type of servo available on the market the first one is “standard” servo which could rotate between 120 to 180 degree and the second one is “continues” servo which could rotate 360 degree.

By using the continues servo, the locomotion circuit become very simple as we only connect the servo directly to the BRAM-AXE board and supply the correct PWM (Pulse Width Modulation) signal in order to make it rotate. The PICAXE BASIC language has a build in servo commands that we could use to make the servo rotate.

servo output_pin, n
servopos output_pin, n

The servo command will initial the PICAXE 28X1 (Microchip PIC16F886) internal TIMER which is used to generate the PWM signal to the servo and after initialization you have to use the servopos command in order to control the servo. The n is the number between 75 and 255, where this number will determine the servo rotation direction (clock wise or counter clock wise). The output_pin is the PICAXE 28X1 output pin which range from 0 to 7.

Now connect the serial programming cable from the BRAM-AXE board to your computer COM/RS232 port or you could use the USB to RS232 adapter as I did and download this following servo testing program using the PICAXE Programming Editor:

'***************************************************************************
'  File Name    : bram-axe_servo_test.bas
'  Version      : 1.0
'  Description  : BRAM-AXE Photovore Servo Testing
'  Author       : RWB
'  Target       : BRAM-AXE Learning Board - PICAXE 28x1
'  Intepreter   : PICAXE Firmware version A.6
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 03 January 2010
'***************************************************************************

' Use PICAXE 28x1 with 4 MHz Internal Clock
#picaxe 28x1
SetFreq m4

' Assigned Variables
symbol cnt_val = b0
symbol move_mode = b1

let pins = %00000000 ' Reset all the Output Pins

' Initial the Servo
gosub BRAM_ServoInit

move_mode=1
cnt_val=1

main:
  select move_mode
    case 1
      gosub BRAM_MoveForward
    case 2
      gosub BRAM_MoveBackward
    case 3
      gosub BRAM_RotateRight
    case 4
      gosub BRAM_RotateLeft
    case 5
      gosub BRAM_Stop
    case 6
      gosub BRAM_ServoInit
  end select

  pause 10        ' Pause 10 Second
  cnt_val=cnt_val + 1
  if cnt_val > 150 then
    move_mode=move_mode + 1
    if move_mode > 6 then
      move_mode=1
    endif
    cnt_val=1
  endif

  goto main      ' Back to main loop
  end

' BRAM Steering Subroutines
BRAM_ServoInit:
  servo 0,125        ' Left Servo
  servo 1,200        ' Right Servo
return

BRAM_MoveForward:
  servopos 0,125     ' Left Servo Forward
  servopos 1,200     ' Right Servo Backward
return

BRAM_MoveBackward:
  servopos 0,200     ' Left Servo Backward
  servopos 1,125     ' Right Servo Forward
return

BRAM_RotateRight:
  servopos 0,125     ' Left Servo Forward
  servopos 1,125     ' Right Servo Forward
return

BRAM_RotateLeft:
  servopos 0,200     ' Left Servo Backward
  servopos 1,200     ' Right Servo Backward
return

BRAM_Stop:
  settimer off       ' TIMER Off
return

' EOF: bram-axe_servo_test.bas

Usually the servo is designed to have a wide tolerance on the incoming PWM signal, but if your servo doesn’t work with the above value (125 and 200) try to experiment with other value as long as the value range is between 75 and 255. For more information about controlling the servo you could read my previous posted blog “Basic Servo Motor Controlling with Microchip PIC Microcontroller“.

The BRAM-AXE Sensors

In order to make the complete photovore robot, we need to use the light sensitive sensor; the simple and cheapest one is to use a special made resistor (made from Cadmium Sulfide) called Light Dependent Resistor or LDR for short. The LDR will vary its resistance according to the light intensity fall on its surface; the bright light intensity will make its resistance decrease significantly (about 1K Ohm to 5 K Ohm) while on the completely dark its resistance will increase as high as 100 K Ohm.

By connecting the LDR in series with 1 K Ohm resistor, we could get the simplest possible light sensor circuit that will give us the variable voltage output according to the light intensity as shown on this following picture.

This simple circuit is known as the voltage divider circuit, you could read more information about the voltage divider circuit on my previous posted blog “Basic Resistor Circuit“.

Connect the sensor circuit output directly to the PICAXE 28X1 microcontroller analog to digital conversion (ADC) input port (ADC 0 and ADC 1) and use the power taken from the BRAM-AXE board output pin as shown on these following pictures:

With the PICAXE ADC feature, now we could easily read the numeric representation of the light intensity on each sensor (left LDR and right LDR) using this following PICAXE BASIC commands:

readadc adc_channel, variable

The readadc command will read the ADC input port (0 to 3 on PICAXE 28X1 microcontroller) and assigned the 8-bit data value to the variable. By examining the ADC value we could command our robot to follow the light as shown on this following BRAM-AXE_photovore.bas program:

'***************************************************************************
'  File Name    : bram-axe_photovore.bas
'  Version      : 1.0
'  Description  : BRAM-AXE Photovore
'  Author       : RWB
'  Target       : BRAM-AXE Learning Board - PICAXE 28x1
'  Intepreter   : PICAXE Firmware version A.6
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 03 January 2010
'***************************************************************************

' Use PICAXE 28x1 with 4 Mhz Internal Clock
#picaxe 28x1
SetFreq m4

' Assigned Variable
symbol ldr_left = b0
symbol ldr_right = b1
symbol diff_value = b2
symbol mode = b3
symbol cnt = b4
symbol stop_stat = b5

let pins = %00000000 ' Reset all Output Pins

' Initial variable used
mode=0
cnt=0
stop_stat=0

main:
  ' Read the LDR ADC Value
  readadc 0,ldr_left
  readadc 1,ldr_right

  ' For Debugging the ADC Value
  ' sertxd("LDR Left: ",#ldr_left,13,10)
  ' sertxd("LDR Right: ",#ldr_right,13,10)
  ' pause 100 

  ' Searching Mode if both LDR less or equal to 5
  if ldr_left <= 5 and ldr_right <= 5 then
    cnt=cnt + 1
    if cnt > 80 then
      cnt=0
      mode=mode + 1
      if mode > 5 then
        mode = 0
      endif
    endif

    select mode
      case 1
        gosub BRAM_Stop
      case 2
        gosub BRAM_RotateRight
      case 3
        gosub BRAM_MoveBackward
      case 4
        gosub BRAM_RotateLeft
      case 5
        gosub BRAM_MoveForward
    end select

    pause 10
    goto main
  endif

  ' STOP both LDR greater or equal to 90
  if ldr_left >= 90 and ldr_right >= 90 then
    gosub BRAM_Stop
    pause 10
    goto main
  endif

  ' BRAM-AXE Bang-Bang steer control
  if ldr_left > ldr_right then
    diffvalue=ldr_left - ldr_right
    if diff_value >= 20 then
      gosub BRAM_RotateRight
    else
      gosub BRAM_MoveForward
    endif
  endif

  if ldr_right > ldr_left then
    diffvalue=ldr_right - ldr_left
    if diff_value >= 20 then
      gosub BRAM_RotateLeft
    else
      gosub BRAM_MoveForward
    endif
  endif

  pause 10       ' Pause 10 seconds  

  goto main      ' Back to main loop
  end

' BRAM Steering Subroutines
BRAM_MoveForward:
  if stop_stat = 1 then
    servo 0,125        ' Init Left Servo Forward
    servo 1,200        ' Init Right Servo Backward
    stop_stat=0
  else
    servopos 0,125     ' Left Servo Forward
    servopos 1,200     ' Right Servo Backward
  endif
return

BRAM_MoveBackward:
  if stop_stat = 1 then
    servo 0,200        ' Init Left Servo Backward
    servo 1,125        ' Init Right Servo Forward
    stop_stat=0
  else
    servopos 0,200     ' Left Servo Backward
    servopos 1,125     ' Right Servo Forward
  endif
return

BRAM_RotateRight:
  if stop_stat = 1 then
    servo 0,125        ' Init Left Servo Forward
    servo 1,125        ' Init Right Servo Forward
    stop_stat=0
  else
    servopos 0,125     ' Left Servo Forward
    servopos 1,125     ' Right Servo Forward
  endif
return

BRAM_RotateLeft:
  if stop_stat = 1 then
    servo 0,200        ' Init Left Servo Backward
    servo 1,200        ' Init Right Servo Backward
    stop_stat=0
  else
    servopos 0,200     ' Left Servo Backward
    servopos 1,200     ' Right Servo Backward
  endif
return

BRAM_Stop:
  stop_stat=1
  settimer off
return

' EOF: bram-axe_photovore.bas

The key for this photovore program to work properly is to place the two LDR sensors about 45 degree from the center of the robot chassis as shown on these following pictures:

When the two LDR sensors get an equal light intensity than we command the BRAM-AXE to move forward, when the light intensity is bright enough than we make it stop as shown on this PICAXE BASIC code:

' STOP both LDR greater or equal to 90
if ldr_left >= 90 and ldr_right >= 90 then
  gosub BRAM_Stop
  pause 10
  goto main
endif

When one of the LDR sensors is brighter then the other than we command the BRAM-AXE to rotate right or rotate left:

' BRAM-AXE Bang-Bang steer control
if ldr_left > ldr_right then
    diffvalue=ldr_left - ldr_right
    if diff_value >= 20 then
      gosub BRAM_RotateRight
    else
      gosub BRAM_MoveForward
    endif
endif

if ldr_right > ldr_left then
    diffvalue=ldr_right - ldr_left
    if diff_value >= 20 then
      gosub BRAM_RotateLeft
    else
      gosub BRAM_MoveForward
    endif
endif

When both LDR sensors is quite dark than we command the BRAM-AXE to enter the light search mode, this light search program algorithm will keep the BRAM-AXE to move forward, backward, rotate left and right until it locate the light source.

The BRAM-AXE photovore program algorithm use the simplest steering method control called the bang-bang control or on/off control which is the simplest closed loops control method usually used in the embedded system. For more information about the bang-bang control method you could read my previous posted blog “Basic Servo Motor Controlling with Microchip PIC Microcontroller“.

You could adjust all the bang-bang control numeric values to suite your need, in order to do that you have to know the ADC value before making your adjustment. This could be done by opening the commented PICAXE BASIC serial data transmit and pause command on these following lines:

' For Debugging the ADC Value
sertxd("LDR Left: ",#ldr_left,13,10)
sertxd("LDR Right: ",#ldr_right,13,10)
pause 100

You could display these value directly to the PICAXE Programming Editor build in serial terminal, which you could access from menu PICAXE -> Terminal or you could press the F8 key, re-down load the code again to run this monitor. Do not disconnect the serial programmer cable from the BRAM-AXE board as the PICAXE BASIC sertxd command use this serial connection to transmit the data and make sure you set the baud rate to 4800 as shown on this following picture:

Now as you have completely build your own photovore robot its time to watch this cute and simple robot in action:

The Final Though

As you’ve learned to build this simple and easy to build photovore robot hopefully this will trigger your passion to learn more about robotics and the embedded system. Learning by experiences is the key to success in learning the embedded system, keep experimenting as this will build your understanding and confidence in developing your own embedded system project.

Make your own Microcontroller Printed Circuit Board (PCB) using the Toner Transfer Method

rwb — Sun, 03 Jan 2010 16:55:30 +0000

As the electronics hobbyist one of knowledge that we have to be familiar with is how to make our own printed circuit board (PCB). Making our own simple single side PCB actually is not require a sophisticated technique and technology as you might think, instead most of the required materials is already available at your home. I’ve started make my first single side through-hole PCB for a simple two transistors astable multivibrator project using just a water proof marker and draw the PCB layout directly on the PCB copper surface.

On those days the CAD (computer aided design) for electronic schematic and PCB are expensive and it runs on the expensive computer hardware too. That is why most of the electronics hobbyist on those days rely only on the hand draw method and occasionally combine it with a special made sticker for drawing the IC parts.

Nowadays as the technology evolve making a decent quality home made single side PCB is become possible and easy. On this tutorial we are going to learn of how to make a through-hole single side PCB and later on use this home made PCB for many of the blog up-coming projects or you could simply use it for your project.

The BRAM-AXE Microcontroller Board

The BRAM-AXE microcontroller board is based on the PICAXE 28×1 microcontrollers from the Revolution Education Ltd (http://www.rev-ed.co.uk/picaxe). The PICAXE 28×1 microcontroller actually is based on the midrange 8-bit Microchip PIC16F886 microcontroller with preload PICAXE BASIC (Beginner’s All-Purpose Symbolic Instruction Code) interpreter firmware inside which is suitable for both beginners and advanced usage. Now let’s take a look at the BRAM-AXE microcontroller board electronic schematic which is specially designed to be used on this PCB tutorial.

The PICAXE 2×1 microcontroller has a build in program loader, therefore this board could be easily reprogrammed using the PICAXE programming editor by connecting the board COM/RS232 port to your computer serial COM/RS232 port or USB port with the USB to COM/RS232 adapter.

The PICAXE 28×1 microcontroller support up to 1000 lines of code, for more advanced application you could replace the PICAXE 28×1 microcontroller with the PICAXE 28×2 microcontroller which based on Microchip advanced 8-bit PIC18F2520 microcontroller which support up to 4000 lines of code.

For more information about the PICAXE microcontroller you could read my previous posted blog Introduction to the Embedded System with PICAXE microcontroller.

The following is the list of electronic parts required to assembly the BRAM-AXE board:

1. Resistor ¼ watt: 180 Ohm (1), 470 Ohm (1), 4K7 (1), 10K (1) and 22K (1)
2. Capacitor: 0.1 uF (1) and 0.01 uF (1)
3. One PICAXE 28×1 microcontroller
4. One 28 pin IC Socket
5. One mini switch button
6. One blue 3mm LED
7. One 2 pin polarized socket for the power supply
8. One 3 pin polarized socket for the COM/RS232
9. One COM/RS232 DB-9 female connector and cable
10. Optional USB to COM/RS232 adapter
11. One 1×40 male header
12. 3xAA battery holder and 3xAA alkaline battery for powering the board

The BRAM-AXE Board PCB Layout

The BRAM-AXE board schematic is created with EAGLE version 5.6.0 Lite Edition; it’s a freeware version of the powerful CAD software made by CADSOFT (http:// www.cadsoft.de) for creating electronics schema and generating the PCB layout. This following picture is the PCB layout generated by this software:

For the purpose of this tutorial I will not describe of how to use the EAGLE software, all of the EAGLE software project files and the PDF print out could download from BRAM-AXE PCB on this blog. You could visit the CADSOFT website above for more information and tutorial of how to use the EAGLE software for creating electronic schematic and generating the PCB layout from it.

Ok know let’s list down all the material required to make this BRAM-AXE board PCB:

1. A piece of glossy magazine paper, brochure, catalog for the toner transfer method medium.
2. Laser Printer with adequate toner for printing the PCB to the glossy magazine paper or you could also use a copy machine
3. 60×45 mm Copper clad laminated printed circuit board (PCB)
4. Kitchen scrub with soap to wash the PCB
5. Hacksaw and sandpaper for cutting the PCB and smoothing
6. The house hold iron for doing the actual toner transfer from the glossy magazine paper to the PCB
7. Ferry Chloride for etching
8. Plastic container for etching and washing
9. A pair of disposal rubber hands glove and eyes protection goggle
10. Nail Polish Remover to remove the toner from the PCB
11. Water proof marker
12. Hand drill with 1mm and 3mm drill bits for drilling the through-hole PCB

The Toner Transfer Method

The toner transfer method is actually based on the same principal as the professional PCB making process, but instead of using the expensive photo film and photosensitive material to transfer the PCB drawing layout to PCB copper; we use the laser jet printer toner to do the job.

The laser jet printer toner actually contain a plastic material and not an ink as the deskjet printer does; therefore when we print this PCB drawing layout on a glossy paper, the black toner plastic material will be attached only on the surface of this glossy paper; by using enough hot from the house hold iron we could make this black toner plastic material melt and reattached to the PCB copper surface.

Now as the magazine glossy paper and the black toner plastic material attached to the PCB copper surface, we could easily remove the paper part by submerging it in the water; once the paper dissolve and become pulp what is left is the black toner plastic material on the PCB copper surface.

Using the etching process the uncovered area on the PCB copper surface will chemically react with the Ferry Chloride (FeCl3) solution and become dissolved but the covered area will not be dissolved as it being protected by the black toner plastic material. The last step is to remove this black toner plastic material using the nail polish remover and drill the board.

The Making of BRAM-AXE Board PCB

Now as you understand how this toner transfers method work; let’s make the BRAM-AXE board PCB.

The Preperation

Cut the copper clad laminated PCB to 60×45mm size and smooth it’s surrounding with the sandpaper.

Wash and scrub the PCB using the kitchen scrub and soap to remove any dirt and grease on the PCB copper surface

Cut the glossy magazine paper to about half of A4 paper length size and full width of A4 paper size; try to use the paper with less printed image or letter on it, so you could easily examine the printed PCB layout. In fact you could use any glossy paper; but do not use the glossy photo paper as it hard to remove the glossy coating material on the PCB copper surface when the toner has been transferred; just safe it for printing your photo.

Print it with the laser jet printer on the glossy magazine paper. The other alternative is to print it with other type of printer (e.g. deskjet printer) and use the real copier machine to copy the PCB layout to the glossy magazine paper because the copier machine use the same toner material as the laser jet printer. On this tutorial I used the HP LaserJet P1006 to print this PCB layout.

When printing the PCB layout you could use the EAGLE software directly or you could use the PDF version of the PCB layout provided here.

The Toner Transfer Process

Next aligned the glossy magazine paper so the printed PCB layout is facing toward the PCB copper surface and you could lock this paper corner with the tape so it won’t move. Cover the glossy magazine paper with another paper to protect it again the over heating (usually this glossy magazine paper is quite thin).

Power on the house hold iron and set it to its maximum heat, let it become hot for a while.

Pre-head the PCB copper surface for about 15 seconds, this will ensure the toner from the glossy magazine paper will transfer perfectly.

Flip the glossy paper magazine toward the PCB precisely; apply pressure and move gently the iron on the top of the paper for about 45 second, make sure you cover the whole PCB layout. Wait until it become cold, do not remove it while it is hot as it could harm your hand and the black toner plastic material will not transfer perfectly to the PCB copper surface.

Trim the glossy magazine paper so it has the same size as the PCB. Next immerse the PCB in the water and wait for a couple of minutes than gently pealing all the paper until it all being removed.

Examine the PCB layout, and make sure all the connection is perfectly covered by the black toner. You could use the marker to repair the tiny un-perfectly covered area or you could repeat the whole process again by first removing all the black toner using the nail polish remover.

The Etching Process

Prepare the etching solution in the plastic container by mixing four part of water with one part of Ferry Chloride (FeCl3) and it would be better to use the hot water about 40 to 50 centigrade degree because the chemical reaction will be faster at higher temperature.

Make sure you are wearing the disposal rubber hand glove and the eye protection goggle when working with this Ferry Chloride solution because this chemical acid solution is very corrosive and poison; you should always take extra precaution when working with this Ferry Chloride solution. If you accidentally exposed with this acid solution, make sure you wash it with plenty of water and soap.

Next immerse the PCB in the Ferry Chloride solution and gently move backward and forward the plastic container so the chemical solution could react with the PCB uncovered copper effectively. Keep watching until all the uncovered copper area becomes dissolved.

Wash the PCB with plenty of water and soap; make sure you mix the Ferry Chloride solution with the water and soap solution to neutralize this remaining acid solution before you discard it. Usually the Ferry Chloride solution could only be used once, therefore use just enough amount as needed to etch your PCB. As a rule of thumb the acid solution area size should be a least twice as your PCB copper surface area size and the acid solution deep is about 10 mm to 20 mm.

The last process is to remove the black toner on the PCB copper surface with the nail polish remover (acetone); you could examine the black toner material while you are removing it and you will find out that it’s made from a plastic material.

The Finishing

Drill the PCB components hole with the 1mm drill bit size and the PCB stand off with the 3mm drill bit size. On this tutorial I’m using the general purpose hand drill to drill this PCB board.

Again wash and scrub the PCB with water and soap to remove any dirt and grease before you start to solder the electronic components on it.

The BRAM-AXE Board Assembly

To complete this tutorial we will assembly all the electronic components on the BRAM-AXE board, solder all the electronic components on it include the 28 pin IC socket and just leave it empty without the PICAXE 28×1 microcontroller.

Now connect the 3xAA battery power to the board and make sure the power LED is lid; if not, disconnect the power and examine your 3xAA power connector make sure the positive and the ground pins are connect correctly to the board. Again examine all the electronics components if it ok, then disconnect the power and you could put the PICAXE 28×1 microcontroller on the 28 pin IC socket.

The BRAM-AXE Board PCB Test

After finish assembly all the electronic components now we are going to test this BRAM-AXE board I used this following test circuit to test both PICAXE 28×1 microcontroller input and output:

For the PICAXE 28×1 microcontroller output I used the SIL (single in line) LED as shown on my previous posted blog Single In Line (SIL) LED Display for your Microcontroller Based Project and for the PICAXE 28×1 digital input I used a mini push button switch and 10K trimport for the PICAXE 28×1 ADC (Analog to Digital Converter) input.

The following is the PICAXE BASIC program code for testing the BRAM-AXE board.

'***************************************************************************
'  File Name    : bram-axe.bas
'  Version      : 1.0
'  Description  : BRAM-AXE Board Testing Program
'  Author       : RWB
'  Target       : BRAM-AXE Learning Board - PICAXE 28x1
'  Intepreter   : PICAXE Firmware version A.6
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 03 January 2010
'***************************************************************************

' Use PICAXE 28x1 with 8 Mhz Internal Clock
#picaxe 28x1
SetFreq m8

' Assigned Variables
symbol adc_val = b0
symbol high_val = b1
symbol low_val = b2
symbol sign = b3

let pins = %00000000 ' Reset all Output Pins
sign = 0             ' Default Running LED

main:
  ' Read Mini Switch on IN0
  if pin0 = 0 then
    sign=sign XOR 1
  endif

  ' Read 10K Trimport ADC Value on ADC0
  readadc 0,adc_val  

  if sign = 1 then
    for high_val = 0 to 7
      low_val=high_val - 1
      low low_val
      high high_val    

      pause adc_val
    next high_val

    for high_val = 6 to 0 step -1
      low_val=high_val + 1
      low low_val
      high high_val    

      pause adc_val
    next high_val
  else
    let pins = %10101010
    pause adc_val
    let pins = %01010101
    pause adc_val
  endif

  goto main      ' Back to main loop
  end

' EOF: bram-axe.bas

Connect the DB-9 female COM/RS232 connector to your computer COM/RS232 port or you could use the USB to COM/RS232 adapter to connect the board to the computer USB port as I did. Now power the board and run the PICAXE Programming Editor, paste the above code and save it as bram-axe.bas.

Click the “Syntax” button in the PICAXE Programming Editor to check the PICAXE BASIC program syntax and if it ok than you could continue to compile and download the code to the board by choosing the “Program” button.

The eight LED blink pattern will change as you press the mini switch button, while the 10K trimport is used to adjust the eight LED blink speed as it take advantage of the PICAXE 28×1 microcontroller ADC capability to read the voltage value from the ADC 0 input.

Now you could enjoy this following video that shows all the BRAM-AXE Board PCB making process that we’ve been going through:

The Final Though

As you’ve learned through this tutorial, making a decent quality single side PCB actually is not a very difficult task; it’s not required a complex process like the conventional PCB making method (i.e. using the film and photosensitive method). The more you practice the whole process the more you gain the experiences from it.

Either you are an electronics hobbyist or a professional making your own PCB is one of the important knowledge that you should acquired; just imagine this situation one day in the middle of the night suddenly you get an idea of a very cool electronics circuit and you eagerly want to prototype this circuit as soon as possible; now your experiences in making the PCB become handy as you could make your own prototype circuit PCB right away.

The 2009 Year End Notes

rwb — Fri, 18 Dec 2009 04:59:36 +0000

First of all I would like to thank to all the ermicroblog readers. I started to write this blog about a year ago; precisely on December 2008, during this year I received a lot of comments and questions and some of it were on my email. For me there are no such a silly questions as I believe that as long as we live in this world we always in the continues learning mode state, therefore what seems silly to some people actually is a really serious question to the other people. I would do my best to answer all the questions regarding this blog contents; as answering the people’s question also is a part of the learning process.

On this first year I tried to post most of the Microcontroller’s foundation knowledge such as ADC, PWM, Interrupt Services, SPI and I2C, where this important knowledge is needed for understanding some of the next year advanced project. On the next year, I also plan to put some of my most popular posted articles and extent it with more examples and experiments into the ebook (PDF formatted).

I do hope this blog could bring a better understanding of how we could make use of the microcontroller in our learning stage or just for hobby and fun. Again thank you for your support and encouragement.

“Glory to God in the highest,
and on earth peace to men on whom his favor rests - Luke 2:14″

Merry Christmas 25 December 2009 and Happy New Year 1 January 2010

God Bless You

PIC18 Pulse Width Modulation (PWM) DC Motor Speed Controller with the RPM Counter Project

rwb — Wed, 09 Dec 2009 10:05:46 +0000

Equipped with sophisticated Enhanced Capture/Compare/PWM (ECCP) peripheral the Microchip PIC18F14K50 microcontroller could produce up to four PWM channels output. The enhanced PWM (Pulse Width Modulation) mode in ECCP peripheral is capable to drive the full bridge DC Motor circuit directly both in forward or reverse direction. It also could generate single PWM output on the selectable PIC18F14K50 pins when it configured in pulse steering mode. In this tutorial we will take advantage of PIC18F14K50 pulse steering mode to drive the DC Motor and at the same time we will build the RPM (Rotation per Minute) counter to observe the PWM effect on the DC Motor speed and display it on the 2×16 LCD.

The PWM and RPM Counter Project

On this project we will use the HITEC C PRO PIC18 MCU Family Version 9.63PL3 and Microchip MPLAB IDE version 8.40 as our development tools platform. This project also serves as the learning tools of how to use many of the Microchip PIC18 advanced peripherals simultaneously to accomplish the project goal. You could see the complete project demonstrated on the video at the end of this tutorial; Ok now let’s list down all the project interesting features:

Using Advanced 8-bit Microchip PIC18F14K50 microcontroller with PICJazz 20PIN development board
Driving the HD44780U 2×16 LCD in 4-bit data mode
Use DC Motor taken from discarded dual shock PS2 Playstation joystick and the Tamiya racing car tire for measuring the DC Motor RPM
Simple and easy to build RPM sensor with the infra red reflective object sensor
Use the ADC peripheral to read the trimport value for adjusting the DC Motor Speed and display the PWM duty cycle on the LCD
Use the PIC18F14K50 external interrupt and 16-bit TIMER0 counter to measure the RPM and display it on the LCD.

The following is the C code that makes this thing happens:

/* ***************************************************************************
**  File Name    : pwmrpm.c
**  Version      : 1.0
**  Description  : PIC18 Pulse Width Modulation with RPM Counter
**  Author       : RWB
**  Target       : PICJazz 20PIN Board: PIC18F14K50
**  Compiler     : HI-TECH C PRO PIC18 MCU Family(Lite) Version 9.63PL3
**  IDE          : Microchip MPLAB IDE v8.40
**  Programmer   : PICKit2
**  Last Updated : 28 Nov 2009
** ***************************************************************************/
#include

/*
** PIC18F14K50 Configuration Bit:
**
** FCMDIS     - Fail-Safe Clock Monitor disabled
** CPUDIV_0   - No CPU System Clock divide
** RCIO       - Internal RC Oscillator
** PLLDIS     - PLL is under software control
** ----------------------------------------------------------------------
** BORDIS     - Brown-out Reset disabled in hardware and software
** WDTDIS     - WDT is controlled by SWDTEN bit of the WDTCON register
** ----------------------------------------------------------------------
** MCLREN     - MCLR pin enabled, RE3 input pin disabled
** ----------------------------------------------------------------------
** XINSTDIS   - Disable extended instruction set (Legacy mode)
** LVPDIS     - Single-Supply ICSP disabled
*/

__CONFIG(1, FCMDIS & CPUDIV_0 & RCIO & PLLDIS);
__CONFIG(2, BORDIS & WDTDIS);
__CONFIG(3, MCLREN);
__CONFIG(4, XINSTDIS & LVPDIS);
__CONFIG(5, 0xFFFF);
__CONFIG(6, 0xFFFF);
__CONFIG(7, 0xFFFF);

// LCD Definition
#define LCD_HOME 0x02
#define LCD_NEXT_LINE 0xC0
#define LCD_CLEAR 0x01
#define LCD_1CYCLE 0
#define LCD_2CYCLE 1

// RPM Counter Variable
volatile unsigned int rpm_value;
char sdigit[6]={'0','0','0','0','0','\0'};

/* Delay Function */
#define FOSC 16000000UL  // Using Internal Clock of 16 MHz
#define	delay_us(x) { unsigned char _dcnt; \
		       _dcnt = (x)/(24000000UL/FOSC)|1; \
		       while(--_dcnt != 0) continue; \
                    }

void delay_ms(unsigned int cnt)
{
  unsigned char i;
  do {
    i = 5;
    do {
      delay_us(164);
    } while(--i);
  } while(--cnt);
}

// PIC18 High-priority Interrupt Service
void interrupt high_isr(void){
  static unsigned char pulse_state=0;
  unsigned int rpm_timer;

  if (TMR0IF) {                     // Check for TIMER0 Overflow Interrupt
    rpm_value = 0;                  // Reset the RPM Value
    TMR0IF=0;                       // Clear TIMER0 interrupt flag
  }

  if (INT0IF){                      // Check for External INT0 Interrupt
    switch(pulse_state) {
      case 0:                       // First Low to High Pulse
        TMR0H = 0;                  // Zero the high byte in TMR0H Buffer
        TMR0L = 0;                  // Clear 16-bit TIMER0 Counter
        pulse_state=1;
        break;
      case 1:                       // Second Low to High Pulse
        rpm_timer=TMR0L;            // Get the first 8-bit TIMER0 Counter
        rpm_timer+=(TMR0H << 8);    // Get the last 8-bit TIMER0 Counter

        // Calculate RPM = 60 x (1/Period)
        // RPM Value = 60000 (1 / (0.032 ms x rpm_timer))
        rpm_value = (int) (60000.0 / (0.032 * rpm_timer));
        pulse_state=0;
    }
    INT0IF = 0;                     // Clear INT0 interrupt flag
  }
}

/*
** LCD Routine
** LCD Data RB7,RB6,RB5,RB4
** LCD Control: RC7 -> E-Enable, RC6 -> RS-Register Select, R/W-Always 0
*/
void LCD_putcmd(unsigned char data,unsigned char cmdtype)
{
  // Put the Upper 4 bits data
  PORTB = data & 0xF0;
  RC6=0;         // RS = 0
  RC7=1;         // E = 1

  // E=0; write data
  RC7=0;
  delay_us(1);    // Delay 1us for 16 MHz Internal Clock    

  // cmdtype = 0; One cycle write, cmdtype = 1; Two cycle writes
  if (cmdtype) {
    // Put the Lower 4 bits data
    PORTB = (data & 0x0F) << 4;
    RC6=0;       // RS = 0
    RC7=1;       // E = 1   

    // E=0; write data
    RC7=0;
    delay_us(1); // Delay 1us for 16 MHz Internal Clock
  }
  delay_ms(5);             // Wait for busy flag (BF)
}

void LCD_putch(unsigned char data)
{
  // Put the Upper 4 bits data
  PORTB = data & 0xF0;
  RC6=1;         // RS = 1
  RC7=1;         // E = 1

  // E=0; write data
  RC7=0;
  delay_us(1);   // Delay 1us for 16 MHz Internal Clock       

  // Put the Lower 4 bits data
  PORTB = (data & 0x0F) << 4;
  RC6=1;         // RS = 1
  RC7=1;         // E = 1 

  // E=0; write data
  RC7=0;
  delay_ms(5);             // Wait for busy flag (BF)
}

void LCD_init(void)
{
  // Wait for more than 15 ms after VCC rises to 4.5 V
  delay_ms(30);

  // Send Command 0x30
  LCD_putcmd(0x30,LCD_1CYCLE);

  // Wait for more than 4.1 ms
  delay_ms(8);

  // Send Command 0x30
  LCD_putcmd(0x30,LCD_1CYCLE);

  // Wait for more than 100 us
  delay_us(200);          // Delay 250us for 16 MHz Internal Clock  ;

  // Send Command 0x30
  LCD_putcmd(0x30,LCD_1CYCLE);

  // Function set: Set interface to be 4 bits long (only 1 cycle write).
  LCD_putcmd(0x20,LCD_1CYCLE);

  // Function set: DL=0;Interface is 4 bits, N=1; 2 Lines, F=0; 5x8 dots font)
  LCD_putcmd(0x28,LCD_2CYCLE);

  // Display Off: D=0; Display off, C=0; Cursor Off, B=0; Blinking Off
  LCD_putcmd(0x08,LCD_2CYCLE);

  // Display Clear
  LCD_putcmd(0x01,LCD_2CYCLE);

  // Entry Mode Set: I/D=1; Increament, S=0; No shift
  LCD_putcmd(0x06,LCD_2CYCLE);

  // Display On, Cursor Off
  LCD_putcmd(0x0C,LCD_2CYCLE);
}

void LCD_puts(const char *s)
{
  while(*s != 0) {      // While not Null
    if (*s == '\n')
      LCD_putcmd(LCD_NEXT_LINE,LCD_2CYCLE);  // Goto Second Line
    else
      LCD_putch(*s);
    s++;
  }
}

// Implementing integer value from 0 to 65530
char *num2str(unsigned int number,unsigned char start_digit)
{
   unsigned char digit;

   if (number > 65530) number = 0;    

   digit = '0';                       // Start with ASCII '0'
   while(number >= 10000)             // Keep Looping for larger than 10000
   {
     digit++;                         // Increase ASCII character
     number -= 10000;                 // Subtract number with 10000
   }

   sdigit[0]='0';                     // Default first Digit to '0'
   if (digit != '0') sdigit[0]=digit; // Put the first digit

   digit = '0';                       // Start with ASCII '0'
   while(number >= 1000)              // Keep Looping for larger than 1000
   {
     digit++;                         // Increase ASCII character
     number -= 1000;                  // Subtract number with 1000
   }

   sdigit[1]='0';                     // Default Second Digit to '0'
   if (digit != '0') sdigit[1]=digit; // Put the Second digit

   digit = '0';                       // Start with ASCII '0'
   while(number >= 100)               // Keep Looping for larger than 100
   {
     digit++;                         // Increase ASCII character
     number -= 100;                   // Subtract number with 100
   }

   sdigit[2]='0';                     // Default Second Digit to '0'
   if (digit != '0') sdigit[2]=digit; // Put the Second digit

   digit = '0';                       // Start with ASCII '0'
   while(number >= 10)                // Keep Looping for larger than 10
   {
     digit++;                         // Increase ASCII character
     number -= 10;                    // Subtract number with 10
   }

   sdigit[3]='0';                     // Default Second Digit to '0'
   if (digit != '0') sdigit[3]=digit; // Put the Second digit

   sdigit[4]='0' + number;
   return(sdigit + start_digit);
}

void main(void)
{
  unsigned char motor_stat,duty_cycle;

  OSCCON=0x70;         /* Select 16 MHz internal clock */

  // Initial PORT
  TRISA = 0x30;        // Input for RA4 and RA5
  TRISC = 0x01;        // Set RC0 as Input, RC<7:1> on PORTC as Output
  PORTC = 0x00;        // Initial Port C
  TRISB = 0x00;        // Set PORTB as Output
  PORTB = 0x00;        // Initial Port B
  TRISB = 0x00;	       // Set All on PORTB as Output
  ANSEL = 0x08;        // Set PORT AN3 to analog input
  ANSELH = 0x00;       // Set PORT AN8 to AN11 as Digital I/O

  // Initial LCD using 4 bits data interface
  LCD_init();
  LCD_puts("PICJazz 20-PIN\n");

  // Init ADC
  ADCON0=0b00001101;   // ADC port channel 3 (AN3), Enable ADC
  ADCON1=0b00000000;   // Use Internal Voltage Reference (Vdd and Vss)
  ADCON2=0b00101011;   // Left justify result, 12 TAD, Select the FRC for 16 MHz 

  // Init TIMER0: Period: 4 x Tosc x Prescale for each counter
  // Tosc = 1/16 Mhz = 0.0000000625
  // TIMER0 Period: 4 x 0.0000000625 x 128 = 0.000032 Second = 0.032 ms
  T0CON = 0b10000110;   // TIMER0 Enable, use 16-bit timer and prescale 1:128
  TMR0H = 0;            // Zero the high byte in TMR0H Buffer
  TMR0L = 0;            // Clear 16-bit TIMER0 Counter
  TMR0IE = 1;           // Enable TIMER0 Overflow Interrupt

  // Set the External Interrupt on INT0 (RC0) Port
  INT0IE = 1;          // Enables the INT0 external interrupt
  INTEDG0 = 1;         // Interrupt on rising edge

  // Init PWM for Single Output
  CCP1CON=0b00001100;  // Single PWM mode; P1A, P1C active-high; P1B, P1D active-high
  CCPR1L=0;            // Start with zero Duty Cycle
  PSTRCON=0b00000100;  // Enable PIC Pulse Steering PWM on RC3 Port

  // PWM Period = 4 x Tosc x (PR2 + 1) x TMR2 Prescale Value
  // Tosc = 1/16 Mhz = 0.0000000625
  // PWM Period = 4 x 0.0000000625 x 201 x 4 = 0.000201
  // PWM Frequency = 1/PWM Period = 1/0.000201 = 4.975 kHz
  T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
  PR2=200;             // Frequency: 4.975 kHz
  TMR2=0;              // Start with zero Counter   

  // Initial Variable used
  rpm_value=0;
  motor_stat=0;        // Motor Off Condition
  duty_cycle=0;        // 0 Duty Cycle

  // Now Enable the Interrupt
  IPEN = 1;           // Enable High Priority Interrupt
  GIEH = 1;           // Global Interrupt Enable (High Priority)

  for(;;) {
    if (RA5 == 0) {   // Read Switch
      delay_ms(1);
      if (RA5 == 0) { // Read again for Simple Debounce
        motor_stat ^= 0x01;
      }
    }     

    if (motor_stat) {
      GODONE=1;
      while (GODONE) continue; // Wait conversion done
      duty_cycle=ADRESH;       // Get the High byte ADC 8-bit result
    } else {
      duty_cycle=0;
    }

    // Assign duty cycle to the PWM CCPR1L register
    CCPR1L = duty_cycle;

    // Display the Information on the LCD
    LCD_putcmd(LCD_HOME,LCD_2CYCLE);      // LCD Home
    LCD_puts("Duty Cycle: "); LCD_puts(num2str((int)((duty_cycle/255.0) * 100.0),3));
    LCD_puts(" %");
    LCD_putcmd(LCD_NEXT_LINE,LCD_2CYCLE); // Goto Second Line
    LCD_puts("RPM: "); LCD_puts(num2str(rpm_value,1));

    // Put the delay here
    delay_ms(10);
  }
}

/* EOF: pwmrpm.c */

The PIC18 Pulse Steering PWM mode

The heart of the PIC18F14K50 pulse steering PWM mode is rely on the TIMER2 peripheral, where it used as the basic counter generator for the PWM signal. The TIMER2 counter clock (TMR2) is supplied by selectable prescale clock, this prescale circuit will divide the system clock by 1, 4 or 16 respectively. The prescale could be selected by assigning the T2CKPS1 and T2CKPS0 bits in the T2CON register.

The TMR2 register value is continuously compared to the PR2 register which determine the TOP value of the TMR2 counter register. When the TMR2 register value reach the PR2 value, then the TMR2 counter register value will be reset to 0.

At the same time the value of TMR2 counter register is also being compared to the CCPR1L register value (actually with the CCPR1H register value, since the CCPR1H equal to CCPR1L than we could say CCPR1L), when the TMR2 reach the CCPR1L value than the PWM peripheral circuit will reset the CCP1 output (logical “0“) and when the TMR2 counter register equal to the PR2 register value than it will set the CCP1 output (logical “1“). Therefore by changing the PR2 value we could change the PWM period and this mean changing the PWM frequency as well. The PWM period could be calculated using this following formula:

PWM period = 4 x Tosc x ( PR2 + 1) x (TMR2 prescale value) second

Where Tosc is the system clock period in second

PWM frequency = 1 / PWM Period Hz

By assigning the PR2 register with 200 and select the prescale to 4; and applying all these values to the formula above, we could determine the PWM frequency for our DC Motor base on the internal system oscillator of 16 MHz as follow:

PWM period = 4 x (1 / 16.000.000) x 201 x 4 = 0.000201 second

Therefore the PWM frequency is:

PWM frequency = 1 / 0.000201 = 4.975 kHz

The T2CON (TIMER2 Control) register is used select the postscale (T2OUTPS<3:0>), activate the TIMER2 peripheral (TMR2ON) and set the prescale clock used by the TMR2 counter register. BY setting the T2CKPS1=0 and T2CKPS0=1 in the T2CON register we select the 1:4 prescale; and by setting the TMR2ON to logical “1” we activate the TIMER2 peripheral.

The following is the C code to initialize the TIMER2 peripheral:

// PWM Period = 4 x Tosc x (PR2 + 1) x TMR2 Prescale Value
// Tosc = 1/16 Mhz = 0.0000000625
// PWM Period = 4 x 0.0000000625 x 201 x 4 = 0.000201
// PWM Frequency = 1/PWM Period = 1/0.000201 = 4.975 kHz
T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
PR2=200;             // Frequency: 4.975 kHz
TMR2=0;              // Start with zero Counter

By setting P1M1=0 and P1M0=0 bits in the CCP1CON register we select the single output PWM; setting the CCP1M3=1, CCP1M2=1, CCP1M1=0 and CCP1M0=0 in the CCP1CON register we select the PWM mode with P1A, P1C active-high; P1B, P1D active-high.

On this tutorial we just set the additional 2 LSB extended bits (DC1B1 and DC1B0) to all zero (logical “0“) for the CCPR1L register (10-bit wide). We start by setting the CCPR1L to zero mean we start with zero duty cycle (no PWM output yet). In single PWM mode we could select the PWM output to PIC18F14K50 RC3 output port by setting the STRC bit on PSTRCON (Pulse Steer Control) register to the logical “1” while other bits is set to logical “0“. The following is the C code:

// Init PWM for Single Output
CCP1CON=0b00001100;  // Single PWM mode; P1A, P1C active-high; P1B, P1D active-high
CCPR1L=0;            // Start with zero Duty Cycle
PSTRCON=0b00000100;  // Enable PIC Pulse Steering PWM on RC3 Port

By applying the analog value read from the 10K trimport connected to the PIC18F14K50 RA4 pins, we could easily varying the PWM duty cycle by changing the voltage divider output formed by the 10K trimport. The following C code shows how we use the PIC18F14K50 microcontroller ADC peripheral to change the PWM duty cycle; for more information about using the ADC peripheral on PIC18 families you could read my previous posted blog PIC18 Microcontroller Analog to Digital Converter with Microchip C18 Compiler:

// Init ADC
ADCON0=0b00001101;   // ADC port channel 3 (AN3), Enable ADC
ADCON1=0b00000000;   // Use Internal Voltage Reference (Vdd and Vss)
ADCON2=0b00101011;   // Left justify result, 12 TAD, Select the FRC for 16 MHz
...
...

if (motor_stat) {
  GODONE=1;
  while (GODONE) continue; // Wait conversion done
  duty_cycle=ADRESH;       // Get the High byte ADC 8-bit result
} else {
  duty_cycle=0;
}

// Assign duty cycle to the PWM CCPR1L register
CCPR1L = duty_cycle;

The enhanced PWM feature on the PIC18 families actually is almost identical to the PIC16 families series, therefore you could read more about the enhanced PWM feature if you want to drive the H-bridge DC motor circuit from my previous posted blog H-Bridge Microchip PIC Microcontroller PWM motor Controller.

The RPM Sensor

To count the DC motor rotation per minute (RPM), I decided to use the infra red reflective object sensor Junye JY209-01 or you could replace it with Fairchild QRE00034; as this type of sensor will make sensing the DC motor rotation become easier.

The infra red reflective object sensor work by simply emitting the infra red beam and when it encounter the white object surface than the infra red beam will be reflected back to the phototransistor; next the phototransistor and the 2N3904 transistor which formed the Darlington pair will start to conduct and will generate enough voltage across the 470 Ohm resistor to be considered by the PIC18F14K50 microcontroller build in Schmitt trigger RC0 input port as the logical “1“. When the infra red beam encounters the black tire surface than both of the phototransistor and 2N3904 transistor will turn off; and the voltage across 470 Ohm resistor will drop to zero volt (logical “0“).

Therefore by timing the generated pulse period by the infra red reflective object sensor we could easily calculate the RPM using this following formula:

Frequency = 1/T Hz; T is the generated pulse period in second.

RPM (Rotation per Minute) = Frequency x 60

The following pictures show in detail of how I put the PS2 Playstation dual shock DC motor, the Tamiya racing car tire with the white sticker and the infra red reflective object sensor for this project.

The PIC18 External Interrupt

As I mention before that in order to calculate the DC motor RPM, we could simply calculate the period of the pulse generated by the RPM sensor shown above. One of the methods to measure the pulse period is to use the PIC18F14K50 microcontroller ECCP (Enhanced Capture/Compare/PWM) peripheral in the capture mode to calculate the period; in the capture mode we could easily use the 16-bit TIMER1 or TIMER3 to count the pulse period by feeding the pulse directly to the CCP1 pins (RC5). The capture interrupt will be generated every rising edge of the pulse (or falling edge), therefore by knowing the exact TIMER1 or TIMER3 counter clock time period and get the timer 16-bit counted value between the two rising edge pulse we could calculate the RPM.

Unfortunately we could not use the Microchip PIC18F14K50 microcontroller ECCP peripheral as this peripheral has already being used to generate the PWM signal for the DC motor in our project, but using the same principal we could make use of the PIC18F14K50 external interrupt peripheral on pin INT0 (RC0) or INT1 (RC1). This external interrupt peripheral will generate interrupt on every rising edge (or falling edge) of the pulse; therefore by combining it with the 16-bit TIMER0 counter mode now we could calculate the RPM as shown on the following diagram.

As shown on the above picture, first we have to activate the PIC18F14K50 microcontroller external interrupt and configure it to detect the pulse rising edge; next we configure the TIMER0 peripheral for the RPM period counter.

By setting the TMR0E and INT0IE bits to logical “1” on the PIC18F14K50 microcontroller interrupt control register (INTCON) and TMT0ON bits to logical “1” on the TIMER0 control register (T0CON), we activate both the TIMER0 and External peripherals. Selecting the 1:256 prescale value we could calculate the time required to increase the TIMER0 16-bit counter.

TIMER0 Clock period = 4 x Tosc x TMR2 prescale value second

TIMER0 Clock period = 4 x (1/16.000.000) x 128 = 0.000032 second = 0.032 ms

This mean the TIMER0 counter required 0.032 ms to increase the TMR0L and TMR0H registers counter value by one. The following C code shows the PIC18F14K50 microcontroller external interrupt and TIMER0 peripherals initialization:

// Init TIMER0: Period: 4 x Tosc x Prescale for each counter
// Tosc = 1/16 Mhz = 0.0000000625
// TIMER0 Period: 4 x 0.0000000625 x 128 = 0.000032 Second = 0.032 ms
T0CON = 0b10000110;   // TIMER0 Enable, use 16-bit timer and prescale 1:128
TMR0H = 0;            // Zero the high byte in TMR0H Buffer
TMR0L = 0;            // Clear 16-bit TIMER0 Counter
TMR0IE = 1;           // Enable TIMER0 Overflow Interrupt

// Set the External Interrupt on INT0 (RC0) Port
INT0IE = 1;          // Enables the INT0 external interrupt
INTEDG0 = 1;         // Interrupt on rising edge

By setting the INTEDG0 to logical “1” on INTCON2 (interrupt Control 2) register we choose the Rising Edge detection. The RPM value is being calculated inside the interrupt service routine as shown on this following C code:

// PIC18 High-priority Interrupt Service
void interrupt high_isr(void){
  static unsigned char pulse_state=0;
  unsigned int rpm_timer;

  if (TMR0IF) {                     // Check for TIMER0 Overflow Interrupt
    rpm_value = 0;                  // Reset the RPM Value
    TMR0IF=0;                       // Clear TIMER0 interrupt flag
  }

  if (INT0IF){                      // Check for External INT0 Interrupt
    switch(pulse_state) {
      case 0:                       // First Low to High Pulse
        TMR0H = 0;                  // Zero the high byte in TMR0H Buffer
        TMR0L = 0;                  // Clear 16-bit TIMER0 Counter
        pulse_state=1;
        break;
      case 1:                       // Second Low to High Pulse
        rpm_timer=TMR0L;            // Get the first 8-bit TIMER0 Counter
        rpm_timer+=(TMR0H << 8);    // Get the last 8-bit TIMER0 Counter

        // Calculate RPM = 60 x (1/Period)
        // RPM Value = 60000 (1 / (0.032 ms x rpm_timer))
        rpm_value = (int) (60000.0 / (0.032 * rpm_timer));
        pulse_state=0;
    }
    INT0IF = 0;                     // Clear INT0 interrupt flag
  }
}

By resetting the TIMER0 counter on the first rising edge external interrupt and reading back the TIMER0 counter on the second rising edge external interrupt we could easily calculate the pulse period

Pulse Period = 0.032 x TIMER0 Counter (TMR0H:TMR0L) millisecond

The RPM value is the frequency of rotation measured in minute (60 second), therefore the DC motor RPM value could be calculated as the following formula:

rpm_value = (1 / Pulse Period) in second x 60 = 60000.0 / 0.032 x rpm_timer

The rpm_timer variable contains the 16-bit TIMER0 counter value, while the global rpm_value contain the RPM value of the DC motor.

The PICKit2 Logic Analyzer

To check the RPM counter accuracy I simply use one of the useful feature of the Microchip PICKit2 programmer, where we could use it as the powerful Logic Analyzer tools to debug serial communication buses such as UART, SPI and I2C. This time we will use it to analyze the RPM pulse produce by the infra red reflective object sensor circuit above and connected the output directly to the PIC18F14K50 microcontroller RC0 input port and the PICKit2 channel 3 inputs to measure the RPM pulse period.

The PICKit2 Logic Analyzer tool could be used by running the PICKit2 programmer Version v2.61 and selecting the Logic Tools from the Tools menu; set the Rising Edge trigger on the channel 3 and 100 ms Sample Rate; next press the RUN button. After the pulse appears check the Cursor checkbox to activate the X and Y horizontal bar to measure the pulse period.

As shown on the above picture, the channel 3 on the PICKit2 logic analyzer tool show that the measured pulse frequency is about 77.52 Hz; this mean the RPM is about 4651 (77.52 x 60) which is close enough to the RPM calculated value 4641 displayed on the LCD at 72% PWM duty cycle.

The 2×16 LCD Display

To display both of the PWM duty cycle and RPM value, I used the Hitachi HD44780U or the equivalent microcontroller 2×16 LCD with back light LED in 4-bit data mode. Most of the LCD function C routine I use in this project is taken from my previous posted blog AVR LCD Thermometer Using ADC and PWM Poject; where you could read more information about the principal of how to drive this kind of display. The following is the list of C function for driving the LCD:

LCD_putch() function is used to display single character on the LCD
LCD_putcmd() function is used to send LCD command (e.g. clear the LCD, move to second row, etc)
LCD_init() function is used to initialized the 2×16 LCD; this function will initialized the 2×16 LCD into 4-bit data mode
LCD_puts() function is used to display a string on the LCD
num2str() function is used to convert a numeric value to a string, we use this function to display numeric value on the LCD.

Inside the C Code

The C program begins by selecting the 16 MHz internal clock and setting all the I/O ports used on this project. After doing the LCD, ADC, TIMER0, External Interrupt and PWM/TIMER2 peripherals setup. After enabling the high priority interrupt and activating the global interrupt the code enter the for(;;) endless loop. Inside this loop; first we read the user’s switch, this switch is attached to the PIC18F14K50 microcontroller input port RA5 and work as the toggle switch to run or stop the DC motor:

if (RA5 == 0) {   // Read Switch
  delay_ms(1);
  if (RA5 == 0) { // Read again for Simple Debounce
    motor_stat ^= 0x01;
  }
}

The PIC18F14K50 microcontroller ADC peripheral than read the analog input on channel 3 (RA4) port and assigned the value to the CCPR1L register where it used to control the PWM duty cycle.

if (motor_stat) {
  GODONE=1;
  while (GODONE) continue; // Wait conversion done
  duty_cycle=ADRESH;       // Get the High byte ADC 8-bit result
} else {
 duty_cycle=0;
}

// Assign duty cycle to the PWM CCPR1L register
CCPR1L = duty_cycle;
Then next we display the duty cycle and the RPM value on the 2x16 LCD:

// Display the Information on the LCD
LCD_putcmd(LCD_HOME,LCD_2CYCLE);      // LCD Home
LCD_puts("Duty Cycle: "); LCD_puts(num2str((int)((duty_cycle/255.0) * 100.0),3));
LCD_puts(" %");
LCD_putcmd(LCD_NEXT_LINE,LCD_2CYCLE); // Goto Second Line
LCD_puts("RPM: "); LCD_puts(num2str(rpm_value,1));

Downloading and Running the Code

After compiling and simulating your code hook up your PICKit2 programmer to the PICJazz 20PIN development and learning board ICSP port turn power on. From the MPLAB IDE menu select Programmer -> Select Programmer -> Pickit2 it will automatically configure the connection and display it on the PICkit2 tab Output windows; now you are ready to down load the code from MPLAB IDE menu select Programmer -> Program; this will down load the HEX code into the PICJazz 20PIN board with the Microchip PIC18F14K50 microcontroller on it.

Now its time to run your PWM and RPM counter code, where you could enjoy this following video showing all of the process that we’ve been going through.

The Final Though

Obviously the Microchip PIC18 PWM peripheral feature is almost identical to its 8-bit PIC16 little brother families, therefore upgrading from the PIC16 to PIC18 could be done almost without changing the code. In this project we also take advantage of the infra red reflective object sensor to measure the RPM, where we don’t have to make special modification on the wheel in order to make this sensor to sense the rotation; all we need is just a piece of white sticker attached to the wheel.

This project also shows us an example of how we use many of the advanced PIC18F14K50 microcontroller peripherals at the same time, which will help to shape our understanding of how we could utilize all of these peripherals in the future project.

PIC18 Microcontroller Analog to Digital Converter with Microchip C18 Compiler

rwb — Sun, 08 Nov 2009 15:49:13 +0000

The Microchip PIC18 Microcontroller family is the Microchip highest performance 8-bit class microcontroller. Powered by advanced RISC CPU, this PIC18 microcontroller family could deliver up to 16 MIPS computing power compared to the other Microchip 8-bit microcontroller family such as PIC10, PIC12 and PIC16 which only could deliver up to 5 MIPS. The PIC18 microcontroller architecture is optimized to be programmed in C language and supporting many advance industrial standard interface peripherals such as I2C, SPI, UART, USB, CAN, Ethernet, LCD and Touch Screen; this make the PIC18 microcontroller family become a popular choice to the new 8-bit embedded system design.

The Microchip C18 compiler is designed to fully utilize the PIC18 microcontroller capabilities, together with Microchip C18 royalty free advanced library such as USB, TCP/IP stack and ZigBee wireless network protocol make the C18 compiler is the best choice to many embedded system designer and hobbyists.

On this tutorial we will learn of how to program the PIC18LF14K50 microcontroller ADC peripheral using the Microchip C18 compiler. The principal we learn here could be applied to the other Microchip PIC18 microcontroller family as well. On this tutorial we will use this following simplify ermicro PICJazz 20PIN board schematic.

After placing the PIC18LF14K50 to the 20 pin socket; using the female to female cable jumper that come with the PICJazz 20PIN board we could easily reconfigure the user trimport and user switch to RA4 and RA5 respectively.

On this tutorial we will use two different approaches to program the PIC18 microcontroller family analog to digital converter (ADC) peripheral. The first one is to use the standard C programming code to manipulate the PIC18LF14K50 ADC peripheral registers and the second one is to use the Microchip C18 ADC wrap-up library. Now take a look on our first code:

/* ***************************************************************************
**  File Name    : adc.c
**  Version      : 1.0
**  Description  : Analog to Digital Converter
**  Author       : RWB
**  Target       : PICJazz 20PIN Board: PIC18LF14K50
**  Compiler     : Microchip C18 v3.34 C Compiler
**  IDE          : Microchip MPLAB IDE v8.30
**  Programmer   : Microchip PICKit2 Programmer
**  Last Updated : 28 Oct 2009
** ***************************************************************************/
#include 
#include

/*
** PIC18LF14K50 Configuration Bit:
**
** FOSC = IRC        - Internal RC Oscillator
** CPUDIV = NOCLKDIV - No CPU System Clock divide
** PLLEN = OFF       - PLL is under software control
** FCMEN = OFF       - Fail-Safe Clock Monitor disabled
** BOREN = OFF       - Brown-out Reset disabled in hardware and software
** WDTEN = OFF       - WDT is controlled by SWDTEN bit of the WDTCON register
** MCLRE = ON        - MCLR pin enabled, RE3 input pin disabled
** LVP = OFF         - Single-Supply ICSP disabled
*/
#pragma config FOSC = IRC, CPUDIV = NOCLKDIV, PLLEN = OFF
#pragma config FCMEN = OFF, BOREN = OFF
#pragma config WDTEN = OFF, MCLRE = ON, LVP = OFF

// Delay in 1 ms (approximately) for 16 MHz Internal Clock
void delay_ms(unsigned int ms)
{
  do {
    Delay1KTCYx(4);
  } while(--ms);
}

void main(void)
{
  unsigned char chSign,chEye,chType,iCount;
  unsigned int iDelay;
  unsigned char led_patern[] = {0b00000000,0b00000001,
                                0b00000011,0b00000111,
                                0b00001111,0b00001111,
                                0b00001110,0b00001100,
                                0b00001000,0b00000000};

  OSCCON=0x70;         // Select 16 MHz internal clock

  TRISC = 0x00;        // Set All on PORTC as Output
  TRISA = 0x30;        // Input for RA4 and RA5
  ANSEL = 0b00001000;  // Set PORT AN3 to analog input
  ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/O

  /* Init ADC */
  ADCON0=0b00001101;   // ADC port channel 3 (AN3), Enable ADC
  ADCON1=0b00000000;   // Use Internal Voltage Reference (Vdd and Vss)
  ADCON2=0b10101011;   // Right justify result, 12 TAD, Select the FRC for 16 MHz

  chEye=0x01;          // Initial Eye Variables with 0000 0001
  chSign=0;
  iDelay=100;
  chType=0;
  iCount=0;

  for(;;) {
    ADCON0bits.GO=1;
    while (ADCON0bits.GO);   // Wait conversion done

    iDelay=ADRESL;           // Get the 8 bit LSB result
    iDelay += (ADRESH << 8); // Get the 2 bit MSB result

    // Display the LED
    if (PORTAbits.RA5 == 0) {
      chType=~chType;
      chSign=0;
    }

    if (chType == 0) {
      PORTC=led_patern[iCount++];
      delay_ms(iDelay);          // Call Delay function
      if(iCount == 10) iCount=0;
    } else {
      if (chSign == 0) {
	PORTC=chEye;
	delay_ms(iDelay);        // Call Delay function
	chEye=chEye << 1;
  	if (chEye > 0x04) chSign=1;
      } else {
        PORTC=chEye;
        delay_ms(iDelay);        // Call Delay function
        chEye=chEye >> 1;
	if (chEye <= 0x01) chSign=0;
      }
    }
  }
}

/* EOF: adc.c */

The Analog to Digital Converter C Code

This program basically will show the running LED pattern attached to RC0, RC1, RC2 and RC3 ports on the PIC18LF14K50 microcontroller; the display speed is controlled by the voltage value reads from the user’s trimport on the port RA4 (AN3 - analog input channel 3). This voltage value will be converted by the PIC18LF14K50 ADC peripheral and passing the converted numeric value as the delay argument on the delay_ms() function inside the loop. Pressing the user’s switch will change the running LED pattern.

The user’s trimport work as the voltage divider circuit and provide voltage input level to the microcontroller analog port (AN3); therefore by changing the trimmer means we change the voltage level input and this also will change the running LED speed.

The user’s switch works as a toggle switch, by pressing it once will switch to the second running LED pattern; pressing once again will switch back to the first running LED pattern.

Just for your reference, you could read of how to program the Microchip PIC16 microcontroller family ADC peripheral using HITEC PICC on my previous posted blog PIC Analog to Digital Converter C Programming. Ok now let’s take a look at the PIC18LF14K50 microcontroller ADC peripheral registers (for more information please refers to the datasheet).

1. ADCON0: A/D CONTROL REGISTER 0

The function of this register is to control the microcontroller ADC operation such as power on the ADC circuit, start converting, channel selection, ADC voltage reference selection and ADC result format presentation selection.

The CHS3, CHS2, CHS1 and CHS0 bits are used to select the ADC input channel, by setting all these bits to “0011” means we choose the channel 3 or AN3 (PIN 3) port which connected to the user’s trimport.

ADCON0=0b00001101;   // ADC port channel 3 (AN3), Enable ADC

Powering the ADC circuit is simply turning on the ADON bit by setting it to logical “1” and to instruct the PIC microcontroller to start the conversion we just turn on the GO/DONE bit (logical “1“) and wait until this bit turn off when the PIC18LF14K50 microcontroller ADC peripheral done with the conversion; we use the C while statement to wait the ADC conversion as this following code:

ADCON0bits.GO=1;
while (ADCON0bits.GO);   // Wait conversion done

2. ADCON1: A/D CONTROL REGISTER 1

The PIC18LF14K50 microcontroller ADC peripheral uses the successive approximation method to do the conversion; this method required the reference voltage in order to work. The ADCON1 register is use to tell the ADC peripheral whether we want to use the internal or external voltage references.

By setting all of these bits to logical “0“, we simply tell the PIC18LF44K50 microcontroller ADC peripheral to use its own internal voltage reference for the conversion.

ADCON1=0b00000000;   // Use Internal Voltage Reference (Vdd and Vss)

3. ADCON2: A/D CONTROL REGISTER 2

The ADCON2 register is use to set of how the 10-bit ADC result will be presented in two 8-bit registers (ADRESH and ADRESL) and to select the ADC acquisition time and the ADC conversion clock.

By setting the ADFM bit to logical “1” we use the “right justified” result. This mean the higher 2 bits value will be place in the ADRESH register and the lower 8 bits value are in the ADRESL register. By using the C left shifting operation, we could get this 10-bit value as this following code:

iDelay = ADRESL;           // Get the 8 bit LSB result
iDelay += (ADRESH << 8);   // Get the 2 bit MSB result

In order for ADC circuit inside the PIC18LF44K50 microcontroller to meet its specified accuracy than ADC clock period (ADCS) and the ADC acquisition time (ACQT) should be set accordingly

The recommended minimum value for the ADC acquisition time before the ADC circuit start to do the conversion is about 7.45 us and when we use the PIC8LF14K50 microcontroller internal oscillator the time required to convert 1-bit analog data is about 1.7 us; therefore it would be safe to choose twice the minimum acquisition time:

TACQT = 2 x 7.45 us = 14.9 us

The closest ACQT setting for this purpose is to set the ACQT to 12 TAD which give us

TACQT = 12 TAD = 12 x 1.7 us = 20.4 us

If you are not using the TACQT (ACQT2 = 0, ACQT1= 0 and ACQT0 = 0) you have to do the delay in program before starting the AD conversion, therefore it always safer to use the PIC18LF14K50 microcontroller ACQT feature. The following is the complete ADCON2 setup:

ADCON2=0b10101011;   // Right justify result, 12 TAD, Select the FRC for 16 MHz

The PIC18LF14K50 microcontroller ADC peripheral is also capable of generating interrupt when it finish the conversion by setting the ADC interrupt flag ADIF bit to logical “1” in PIR1 register, but for the purpose of this tutorial we will not use this facility.

Initial the Internal Oscillator clock and ADC Port

One of the most important setup before we could use the PIC ADC peripheral is to configure the PIC18LF14K50 microcontroller internal clock and ports.

By setting the IRCF2, IRCF1 and IRCF0 bits to logical “1” on the OSCCON register we choose the 16 MHz internal clock from the high frequency internal oscillator (HFINTOSC):

OSCCON=0x70;         // Select 16 MHz internal clock

For the analog input this can be done by setting the TRISA, ANSEL and ANSELH registers as the following code:

TRISC = 0x00;        // Set All on PORTC as Output
TRISA = 0x30;        // Input for RA4 and RA5
ANSEL = 0b00001000;  // Set PORT AN3 to analog input
ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/

Because the we use both RA4 and RA5 ports as an input ports (RA4 for user’s trimport and RA5 for user’s switch) then we turn on the tristate input gate on these ports by setting the TRISA to 0×30 and enabling the AN3 analog input selection by setting the ANSEL to 0b00001000 (0×08 hex value). For the LED’s, we just enabling all of the PORTC tristate gate ports as an output by setting the TRISC register to all zero.

Downloading your C18 ADC project Code

After compiling and simulating your code hook up your PICKit2 programmer to the PICJazz 20PIN board ICSP port turn on the PICJazz 20PIN power. From the MPLAB IDE menu select Programmer -> Select Programmer -> Pickit2 it will automatically configure the connection and display it on the PICkit2 tab Output windows:

You could get the information about the size of your program by opening the adc.map file in your project directory or you could use the MPLAB IDE Memory Usage Gauge facility from the MPLAB IDE menu select View -> Memory Usage Gauge as follow:

Now you are ready to down load the code from MPLAB IDE menu select Programmer -> Program; this will down load the HEX code into the PICJazz 20PIN board:

You could see the running code on the video at the end of this tutorial.

Using the Microchip C18 ADC Peripheral Library

As I mention before that on this tutorial we are going to use the alternative approach to code the PIC18LF14K50 microcontroller ADC peripheral, where we are going to use the Microchip C18 ADC wrap-up library (version 3.34). Using this library supposedly will be much easier than coding the PIC18F14K50 microcontroller ADC peripheral registers directly especially for the beginners; …hmm let’s find out how ease this approach comparing to the first one.

Looking at the Microchip C18 library (MPLAB_C18_Libraries_51297f.pdf) document the ADC library could be used as the above diagram. First we have to use the OpenADC() function to initial the PIC18LF14K50 microcontroller ADC peripheral registers. From the library we know that this function is depend on the microcontroller type we used; therefore to get more detail information about this ADC library we have to read other C18 peripheral library document file found at \doc\periph-lib\AD Converter.htm. From this reference document you will get 12 version of the OpenADC() function and for the PIC18LF14K50 microcontroller we have to use the ADC_V10 OpenADC() function as follow (taken from the AD Converter.htm document):

Function: Configure the A/D convertor.
Include: adc.h
Prototype:

void OpenADC(unsigned char config,
                      unsigned char config2 ,
                      unsigned char config3,
                      unsigned int portconfig);

Code Example:

With AND mask:
OpenADC( ADC_FOSC_32      &
         ADC_RIGHT_JUST   &
         ADC_12_TAD,
         ADC_CH0          &
         ADC_REF_VDD_VSS  &
         ADC_INT_ON, ADC_10ANA);

With OR mask:
OpenADC( ADC_FOSC_32 |
         ADC_RIGHT_JUST |
         ADC_12_TAD,
         ADC_CH0 |
         ADC_REF_VDD_VSS |
         ADC_INT_ON, ADC_10ANA);

This ADC_V10 OpenADC() function will accept 4 arguments: config, config2, config3 and portconfig; you should remember here for other PIC18 microcontroller type the OpenADC() function version may accept only 2 or 3 arguments instead of 4 arguments therefore its important to know which OpenADC() function to be used when you use the other type of PIC18 microcontroller family. There is no general OpenADC() function that work to all PIC18 microcontroller type.

The ADC_V10 OpenADC() function first argument (config) is used to set the A/D Clock Source, A/D result justification and the A/D acquisition time. The second argument (config2) is used to set the A/D channel, A/D interrupt and some miscellaneous option. The third argument (config3) is used to set the A/D Vref+ and Vref- configuration and last the fourth argument (portconfig) is used to set the analog channel port (i.e. ANSEL and ANSELH registers).

Now we continue to look at the ADC_V10 OpenADC() function code example and you will notice that the example only use 3 arguments instead of 4 arguments? Is this mean that the example document give us a wrong information? Now its time to open the ADC_V10 OpenADC() function wrap-up library to find out how this thing really work. Opening the \src\pmc_common\ADC\adcopen.c file and here what we get for the ADC_V10 OpenADC() function:

#elif defined (ADC_V10)
void OpenADC( unsigned char config,
              unsigned char config2,
              unsigned char config3,
              unsigned int portconfig)
{
    ADCON0 = 0;
    ADCON1 = 0;
    ADCON2 = 0;

    ADCON0 = (config2 >> 1) & 0b00111100;  //channel selection
    ADCON1 = (config3 & 0b00001100) | //Positive Voltage Reference Configuration bits
             (config3 & 0b00000011);  //Negative Voltage Reference Configuration bits
    ADCON2 = (config & 0b10000000) |
             ((config >> 4) & 0b00000111) | //A/D Conversion Clock Select bits
             ((config << 2) & 0b00111000);  //A/D Acquisition Time Select bits

    ANSEL = portconfig;			//Didn't Change
    ANSELH = (portconfig >> 8);		//Didn't Change

	if( config2 & 0b10000000 )		//interrupt enable check
    {
      PIR1bits.ADIF = 0;			//Clear the ADC Interrupt bit
      PIE1bits.ADIE = 1;			//Enable the ADC Interrupt
      INTCONbits.PEIE = 1;			//Peripheral Interrupt Enable
    }
    //A/D Conversion Status bit--A/D converter module is operating
    ADCON0bits.ADON = 1;
}

Hmm,.. this ADC_V10 OpenADC() function use 4 arguments after all (the example document is wrong) and this code seem similar to what we have already done on the first example; by carefully reading the necessary bits definition in the \h\adc.h file and used them with the AND mask as the arguments to the ADC_V10 OpenADC() function; do some debugging on the required PIC18LF14K50 registers, finally I came with this following C code:

/* ***************************************************************************
**  File Name    : adc2.c
**  Version      : 1.1
**  Description  : Analog to Digital Converter
**                 Using C18 ADC Peripheral Wrap-up Library
**  Author       : RWB
**  Target       : PICJazz 20PIN Board: PIC18LF14K50
**  Compiler     : Microchip C18 v3.34 C Compiler
**  IDE          : Microchip MPLAB IDE v8.30
**  Programmer   : PICKit2
**  Last Updated : 28 Oct 2009
** ***************************************************************************/
#include 
#include 
#include

/*
** PIC18LF14K50 Configuration Bit:
**
** FOSC = IRC        - Internal RC Oscillator
** CPUDIV = NOCLKDIV - No CPU System Clock divide
** PLLEN = OFF       - PLL is under software control
** FCMEN = OFF       - Fail-Safe Clock Monitor disabled
** BOREN = OFF       - Brown-out Reset disabled in hardware and software
** WDTEN = OFF       - WDT is controlled by SWDTEN bit of the WDTCON register
** MCLRE = ON        - MCLR pin enabled, RE3 input pin disabled
** LVP = OFF         - Single-Supply ICSP disabled
*/
#pragma config FOSC = IRC, CPUDIV = NOCLKDIV, PLLEN = OFF
#pragma config FCMEN = OFF, BOREN = OFF
#pragma config WDTEN = OFF, MCLRE = ON, LVP = OFF

// Delay in ms (approximately) for 16 MHz Internal Clock
void delay_ms(unsigned int ms)
{
  do {
    Delay1KTCYx(4);
  } while(--ms);
}

void main(void)
{
  unsigned char chSign,chEye,chType,iCount;
  unsigned int iDelay;
  unsigned char led_patern[] = {0b00000000,0b00000001,
                                0b00000011,0b00000111,
                                0b00001111,0b00001111,
                                0b00001110,0b00001100,
                                0b00001000,0b00000000};

  OSCCON=0x70;         // Select 16 MHz internal clock

  TRISC = 0x00;        // Set All on PORTC as Output
  TRISA = 0x30;        // Input for RA4 and RA5  

  /* Init ADC */
  /*
  ** Original:
  ** #define ADC_REF_VDD_VDD 0b11111001 // ADC voltage source VREF+ = AVDD
  **
  ** We redefine this definition to ADC_REF_VDD_VDD_X
  */
  #define ADC_REF_VDD_VDD_X 0b11110011 	// ADC voltage source VREF+ = AVDD

  OpenADC(ADC_FOSC_RC & ADC_RIGHT_JUST & ADC_12_TAD,
          ADC_CH3 & ADC_INT_OFF,
          ADC_REF_VDD_VDD_X & ADC_REF_VDD_VSS,
          0b00001000);

  chEye=0x01;          // Initial Eye Variables with 0000 0001
  chSign=0;
  iDelay=100;
  chType=0;
  iCount=0;  

  for(;;) {
    ConvertADC();                 // Start conversion
    while(BusyADC());             // Wait for completion
    iDelay = ReadADC();           // Read result

    // Display the LED
    if (PORTAbits.RA5 == 0) {
      chType=~chType;
      chSign=0;
    }

    if (chType == 0) {
      PORTC=led_patern[iCount++];
      delay_ms(iDelay);           // Call Delay function
      if(iCount == 10) iCount=0;
    } else {
      if (chSign == 0) {
	PORTC=chEye;
	delay_ms(iDelay);         // Call Delay function
	chEye=chEye << 1;
  	if (chEye > 0x04) chSign=1;
      } else {
        PORTC=chEye;
        delay_ms(iDelay);         // Call Delay function
        chEye=chEye >> 1;
	if (chEye <= 0x01) chSign=0;
      }
    }
  }
  CloseADC(); // Disable A/D converter
}

/* EOF: adc2.c */

As you’ve seen from the above code, I had to redefine the third argument definition ADC_REF_VDD_VDD (0b11111001) to ADC_REF_VDD_VDD_X (0b11110011) to make the ADC_V10 OpenADC() function to set the PIC18LF14K50 microcontroller ADCON1 register correctly (using the internal voltage reference). I think this is a bug for the ADC_V10 type on the Microchip C18 version 3.34 ADC peripheral libraries.

For starting and reading the ADC channel using this library is just a little bit easier comparing to the first approach as shown on this following code:

ConvertADC();                 // Start conversion
while(BusyADC());             // Wait for completion
iDelay = ReadADC();           // Read result

Just for curiosity, I put this following memory usage gauge to compare the memory usage between using the Microchip C18 ADC peripheral library approach and without using it; and it’s obvious that using the first approach give you a lesser HEX code size.

After compiling and downloading the HEX code to the PICJazz 20PIN board you will have similar result as shown on this following video:

The Final Though

Is obviously the Microchip C18 (version 3.34) ADC peripheral library is not ease to use at all and certainly is not intended to be used by the beginners; as you will have to read many documents and must have a good understanding of the PIC18 microcontroller ADC principal in order to make this library work for you. My suggestion is to avoid using the Microchip C18 ADC peripheral library (especially if you are really not understand the PIC18 microcontroller ADC peripheral) and use direct register manipulation as shown on the first approach to handle your PIC18 microcontroller ADC project.

Introduction to the Embedded System with PICAXE Microcontroller

rwb — Sat, 17 Oct 2009 15:23:17 +0000

These days we are living and surrounding by many tiny computers called embedded products. Unlike the general purpose desktop computer that we use for browsing or typing our email, this tiny computer is designed to do only a limited specific task. We could easily found this embedded product just about anywhere such as home appliance (e.g. washing machine, refrigerator, microwave oven, TV/DVD), personal gadget (e.g. cell phone, MP3 players, digital camera), car (e.g. anti lock brake system, GPS navigation, alarm) and many more. The tremendous use of the embedded products in our daily life make the embedded system become one of the most important and interest subject to be learned.

Now come to the most asked question “How do I start it?” Actually when we learn the embedded system; we learn two things at the same time, the first one is the hardware which usually a microcontroller and the second one is the software to program the microcontroller to perform the desire task. Therefore most of the microcontroller manufacture already provides this learning tool all in one package (starter kits) to introduce their product to the microcontroller newcomer. Unfortunately most of this learning tool is aimed for the people that already have an adequate knowledge both in hardware and programming language.

Considering this need, many companies and the open source community start to offer their own embedded system development framework version, where this framework mostly aim for student, hobbyist and even to the professional.

Among these embedded system learning and development framework I found that the PICAXE from Revolution Education Ltd in UK (http://www.rev-ed.co.uk/picaxe) is one of the best in terms of price and ease to be used. Equipped with the free sophisticated PICAXE Programming Editor to program, debug, simulate and download the code to the PICAXE microcontroller; therefore this makes the PICAXE framework is a perfect choice for the embedded system newcomer.

The PICAXE Programming Editor also can automatically generate the BASIC program code base on the flowchart you draw.

The PICAXE microcontroller is based on various range of Microchip PIC microcontroller, start from 8 pins up to 40 pins PIC microcontroller.

The PICAXE Microcontroller

Unlike the other BASIC interpreter framework mention above which use the EEPROM to store the program, the PICAXE is a stand alone microcontroller solution, where both of program and the BASIC interpreter firmware is stored in the PIC microcontroller own memory (FLASH and/or EEPROM). Therefore the PICAXE only required a very view external electronic component in order to make it work.

In fact you could drop the 180 ohm resistor (connect pin 19 directly to TX) shown on the above schematic, which left only two resistors (22K and 10K) to make this PICAXE microcontroller a fully function embedded learning system. Connecting the RS232 DB-9 female connector to your computer COM port or USB to RS232 converter and you are ready to program this PICAXE microcontroller.

How ease to program this PICAXE microcontroller? To find it out, I did a small research; First I taught my fourth grade son (9 years old) just an essential PICAXE BASIC (Beginner’s All-Purpose Symbolic Instruction Code) language commands to program the PICAXE microcontroller output which connected to four LED and let him play with it for a while; later on I asked him to program the PICAXE 20M using the AXEJazz 20PIN learning and development board from ermicro, so it could display the back and forth running LED. This is the PICAXE BASIC code that he came with and I called it “HelloWorld.bas” (I put some comments on the original code to make it clear).

'--------------------------------------------------------------------
' Program Name : HelloWorld.bas
' Description  : HelloWorld PICAXE Program
' Author       : TRB
' Target       : AXEJazz 20PIN Learning Board
' Interpreter  : PICAXE Firmware version 3.B
' IDE          : PICAXE Programming Editor Version 5.2.6
' Programmer   : PICAXE Programming Editor Version 5.2.6
' Last Update  : 15 Aug 2009
'--------------------------------------------------------------------
#picaxe 20M

symbol led7=7    ' LED7 Attached to PICAXE Output 7
symbol led6=6    ' LED6 Attached to PICAXE Output 6
symbol led5=5    ' LED5 Attached to PICAXE Output 5
symbol led4=4    ' LED5 Attached to PICAXE Output 5

main: high led7  ' Set High Output 7
      low led6   ' Set Low Output 6
      low led5   ' Set Low Output 5
      low led4   ' Set Low Output 4
      pause 100  ' Pause 100ms

      low led7
      high led6
      low led5
      low led4
      pause 100  ' Pause 100ms

      low led7
      low  led6
      high led5
      low led4
      pause 100  ' Pause 100ms  

      low led7
      low led6
      low led5
      high led4
      pause 100  ' Pause 100ms

      low led7
      low led6
      high led5
      low led4
      pause 100  ' Pause 100ms

      low led7
      high led6
      low led5
      low led4
      pause 100  ' Pause 100ms                        

      goto main  ' Back to the main label
      end              

' EOF: HelloWorld.bas

As you’ve seen from the code above, this is a simple endless loop program with contain only three PICAXE BASIC high, low and pause commands. Even though this program looks naïve to the more experience BASIC programmer, but it proves that programming the PICAXE microcontroller is not difficult. To read more about the PICAXE you could visit their website mention above; they have a very good PICAXE user manual and the PICAXE BASIC user reference.

The PICAXE Analog to Digital Converter

Using the same Input/Output circuit above, I enhanced the HelloWorld.bas program so we could control the LED display speed using the 10K trimport connected to the PICAXE Input 7 (ADC input) and at the same time reading the digital input connected to the PIXAXE Input 3 to change the LED display behavior

'***************************************************************************
'  File Name    : blinkled.bas
'  Version      : 1.0
'  Description  : PICAXE Blinking LED
'  Author       : RWB
'  Target       : AXEJazz 20PIN Learning Board
'  Interpreter  : PICAXE Firmware version 3.B
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 22 September 2009
'***************************************************************************

' Use PICAXE 20M
#picaxe 20M

' Assign Variables
symbol adc_val = b0  ' Use b0 for adc_val
symbol high_val = b1
symbol low_val = b2
symbol sign = b3

let pins = %00000000 ' Reset all Output Pins
sign = 0             ' Default Running LED

main:
  ' Read User Switch on Input IN3
  if pin3 = 0 then
    sign=sign XOR 1
  endif

  ' Read Trimport ADC Value on Input IN7
  readadc 7,adc_val  

  if sign = 0 then
    for high_val = 4 to 7
      low_val=high_val - 1
      low low_val
      high high_val    

      pause adc_val
    next high_val

    for high_val = 6 to 4 step -1
      low_val=high_val + 1
      low low_val
      high high_val    

      pause adc_val
    next high_val
  else
    let pins = %11000000
    pause adc_val
    let pins = %00110000
    pause adc_val
  endif

  goto main      ' Back to the main loop
  end

' EOF: blinkled.bas

The trimport is used as the voltage divider circuit, where adjusting the trimport will varying the voltage on the PICAXE Input 7. Using the PICAXE BASIC readadc command we could easily capture the voltage changing and represent it in digital form (Analog to Digital Conversion). Then we use this ADC value to set the LED display delay using pause adc_val command. For comparison of how to do this ADC stuff in C language you could read my previous posted blog PIC Analog to Digital Converter C Programming.

By examining the PICAXE Input3 status (pin3), we could determine whether this pin is low (button pressed) or high (button release) and use this status to toggle the sign variable for different LED display behavior

' Read User Switch on Input IN3
if pin3 = 0 then
  sign=sign XOR 1
endif

The PICAXE BASIC interpreter use a predefined general purpose variables to store temporary data on the microcontroller RAM, these general purpose variables is called “bit” for 1-bit operation, “b” for 8-bit operation and “w” for 16-bit operation. The total variable that you could utilize is depending on the PICAXE type we use.

Using the PICAXE BASIC symbol command, we could redefine the variable name to become more readable instead of just using the b0, b1,b2 and b3 as shown on this following code:

' Assigned Variable
symbol adc_val = b0  ' Use b0 for adc_val
symbol high_val = b1
symbol low_val = b2
symbol sign = b3

The last is the let pins command, this special command is used to set or clear the PICAXE output port, therefore by assigning the pins with binary value of %00000000, means we clear all the PICAXE-20M output port (Output 0 to Output 7).

let pins = %00000000 ' Reset all Output Pins

Driving the Seven Segment Display with PICAXE

Driving the seven segment display is one of the basic knowledge that should be known when we learn the embedded system. Basically the seven segment display contain 7 LED plus 1 LED for the dot sign, therefore driving this seven segment display use the same principal as we drive an ordinary LED.

The following program show the counted number from 0 to 9 on the common cathode seven segment display:

'***************************************************************************
'  File Name    : sevenseg.bas
'  Version      : 1.0
'  Description  : PICAXE Seven Segment
'  Author       : RWB
'  Target       : AXEJazz 20PIN Learning Board
'  Interpreter  : PICAXE Firmware version 3.B
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 22 September 2009
'***************************************************************************

' Use PICAXE 20M
#picaxe 20M

' Assign Variables
symbol cnt = b0
symbol adc_val=b1
symbol seg_dot = 7

let pins = %00000000 ' Reset all Output Pins

main:
  for cnt=0 to 9
    readadc 7,adc_val  ' Read ADC Value on Input Port 7

    gosub disp_val
    pause adc_val
  next cnt 

  ' Clear Output
  let pins = %00000000 ' Reset all Output Pins
  pause 100

  for cnt=0 to 2
    high seg_dot
    pause adc_val
    low seg_dot
    pause adc_val
  next cnt 

  goto main      ' Back to main loop
  end

disp_val:
  select cnt
    case 0
      let pins = %00111111     ' 0 -> A=1,B=1,C=1,D=1,E=1,F=1,G=0,DOT=0
    case 1
      let pins = %00000110     ' 1 -> A=0,B=1,C=1,D=0,E=0,F=0,G=0,DOT=0
    case 2
      let pins = %01011011     ' 2 -> A=1,B=1,C=0,D=1,E=1,F=0,G=1,DOT=0
    case 3
      let pins = %01001111     ' 3 -> A=1,B=1,C=1,D=1,E=0,F=0,G=1,DOT=0
    case 4
      let pins = %01100110     ' 4 -> A=0,B=1,C=1,D=0,E=0,F=1,G=1,DOT=0
    case 5
      let pins = %01101101     ' 5 -> A=1,B=0,C=1,D=1,E=0,F=1,G=1,DOT=0
    case 6
      let pins = %01111101     ' 6 -> A=1,B=0,C=1,D=1,E=1,F=1,G=1,DOT=0
    case 7
      let pins = %00000111     ' 7 -> A=1,B=1,C=1,D=0,E=0,F=0,G=0,DOT=0
    case 8
      let pins = %01111111     ' 8 -> A=1,B=1,C=1,D=1,E=1,F=1,G=1,DOT=0
    case 9
      let pins = %01101111     ' 9 -> A=1,B=1,C=1,D=1,E=0,F=1,G=1,DOT=0
 endselect
 return      

' EOF: sevenseg.bas

As you’ve seen from the code above, by controlling which of the LED segment to be displayed we could easily display the number on this seven segment display. For example if we want to display the value “6“, we could simply make the LED on segment A, C, D, E, F and G to illuminate. Here I used the PICAXE BASIC subroutine disp_val to do the seven segment display task, therefore by calling this subroutine with gosub command it will display the number on the seven segment display according to the cnt variable value. Again in this experiment the ADC (Input 7) is being used for controlling the display delay.

Connecting PICAXE with Dallas DS18B20 Digital Thermometer

On this last example, I will show you how ease to use Dallas DS18B20 digital thermometer with PICAXE microcontroller and at the same time we will use the serial (RS232) terminal to display the temperature result.

Dallas DS18B20 is a well known 1-Wire interface centigrade digital thermometer, this TO-92 package chip could measure temperature range from -55 centigrade degree to +125 centigrade degree and it only require 1 data line plus the ground to communicate with the microcontroller. Now take a look of how the PICAXE BASIC communicates with this sophisticated digital temperature sensor:

'***************************************************************************
'  File Name    : ds18b20.bas
'  Version      : 1.0
'  Description  : Temperature Sensor with Dallas DS18B20
'  Author       : RWB
'  Target       : AXEJazz 20PIN Learning Board
'  Interpreter   : PICAXE Firmware version 3.B
'  IDE          : PICAXE Programming Editor Version 5.2.6
'  Programmer   : PICAXE Programming Editor Version 5.2.6
'  Last Updated : 22 September 2009
'***************************************************************************

' Use PICAXE 20M
#picaxe 20M

' Assign Variables
symbol temp_val = b0
symbol row_pos = b1
symbol col_pos = b2

let pins = %00000000   ' Reset all Output Pins

' Initial ANSI Terminal
' Baud: 4800,Data: 8, Parity: None, Stop Bit: 1
gosub ansi_me
gosub ansi_cl

let row_pos=1
let col_pos=1
gosub ansi_cm

sertxd ("AXEJazz 20PIN - DS18B20 Digital Thermometer")

main:
  readtemp 1,temp_val  ' Read the DS18B20 Data Value        

  let row_pos=3
  let col_pos=1
  gosub ansi_cm

  if temp_val <= 127 then
    sertxd ("Temperature: ",#temp_val," ",248,"C")
  else
    let temp_val = temp_val - 128
    sertxd ("Temperature: -",#temp_val," ",248,"C")
  endif

  pause 100

  goto main            ' Back to main loop
  end  

ansi_me:
  ' ANSI turn off all attribute: me=\E[0m
  sertxd (27,"[0m")
  return  

ansi_cl:
  ' ANSI clear screen: cl=\E[H\E[J
  sertxd (27,"[H",27,"[J")
  return

ansi_cm:
  ' ANSI cursor movement: cl=\E[%row;%colH
  sertxd (27,"[",#row_pos,";",#col_pos,"H")
  return

' EOF: ds18b20.bas

On this experiment we just use 8-bit precision (the eighth bit is used as a negative sign bit) temperature measurement using the PICAXE BASIC readtemp command which is especially designed function just for the Dallas DS18B20 chip; and when it’s done (approximately 750ms) then the 8-bit temp_val variable will be contained the exact room temperature measured by the DS18B20 chip. When the value reach 128, mean the room temperature is swing to negative (the eighth bit is logical “1“) then we subtract the value with 128 to get the exact negative value. Next we display this value to the serial terminal using the sertxd command.

You could use the Hyperterminal or puTTY program to display the room temperature and set the baud rate to 4800, 8-bit for the data width, none for the parity and 1-bit as the stop bit sign. Remember the PICAXE automatically use this setting when working with serial terminal, for 8 MHz PICAXE clock the baud rate will be automatically set to 9600.

Now you could enjoy seeing the whole PICAXE experiment we’ve done above on this following video:

The Final Though

The PICAXE actually show us how the technology could make our life easier, it just like when you want to copy a file on your desktop computer, you don’t have to type “copy source_directory\file_name target_directory\file_name“; instead on the modern computer operating system you just simply click “Copy” and click “Paste” the file. I bet many peoples on these days never use this old “copy” command anymore (they even don’t recognize that this command in fact is still exist). The same principal is shown on the PICAXE BASIC that we just use a simple command such as readadc to read the ADC value, readtemp to read the DS18B20 digital thermometer, servo to drive the servo motor and pwmout to produce the background PWM pulse.

Although the C and Assembler are still the main language choice when programming the embedded system because of their execution speed; but for many systems that only required low response time from the microcontroller; the PICAXE offer rapid and robust development framework to your embedded system application. The other alternative is; you could use the PICAXE microcontroller as your co-microcontroller to support your main microcontroller to do many various tasks such as servo controller, keypad reading, LCD or seven segment displayer or as the PWM source for your DC motor.

ermicroblog

Integrating Wiznet W5100, WIZ811MJ network module with Atmel AVR Microcontroller

Embedded Web Server

AVRJazz Mega328 and WIZ811MJ

Embedded Web Server

AVRJazz Mega328 and WIZ811MJ

Embedded Web Server

Stepping Into the 16-bit World with the Microchip 16-bit PIC24F16KA102 Family Microcontroller

Building your own Simple Laser Projector using the Microchip PIC12F683 Microcontroller

Working with the Comparator Circuit

Build Your Own Simple and Easy PICAXE Microcontroller Based Photovore Robot

Make your own Microcontroller Printed Circuit Board (PCB) using the Toner Transfer Method

The 2009 Year End Notes

“Glory to God in the highest, and on earth peace to men on whom his favor rests - Luke 2:14″

Merry Christmas 25 December 2009 and Happy New Year 1 January 2010

God Bless You

PIC18 Pulse Width Modulation (PWM) DC Motor Speed Controller with the RPM Counter Project

PIC18 Microcontroller Analog to Digital Converter with Microchip C18 Compiler

Introduction to the Embedded System with PICAXE Microcontroller

“Glory to God in the highest,
and on earth peace to men on whom his favor rests - Luke 2:14″