Experiments with PIC16F628A

Development board for PIC16F628A, PIC16F88, PIC16F1827, and PIC16F1847 microcontrollers

2011-06-24T12:51:00.000-07:00

I recently made a second version of my old 18-pin PIC development board with much more peripheral chips.This board is best suitable for doing experiments with enhanced mid-range PIC microcontrollers, such as PIC16F1827 and PIC16F1847. The board has I/O port expander, external EEPROM, temperature sensor, Quad OpAmp, digital potentiometer chips, and many more features.

Check out the details of the development board HERE.

Sensirion's SHT1x and SHT7x series of humidity sensors interfaced to PIC Microcontroller

2011-05-29T07:16:00.000-07:00

Sensirion's SHT series of humidity sensors integrate sensor elements with all the required signal processing circuits on chip, and provide fully calibrated digital outputs for relative humidity and temperature measurements. This tutorial explains how you can interface a SHT1x/7x sensor to a PIC microcontroller to measure ambient temperature and relative humidity. The tutorial described in full detail about the sensors, their specifications and interface, and the implementation of communication protocol using mikroC compiler.

Two sensors are simultaneously interfaced to PIC and the consistency between the two sets of results are also explored.

Read the project in detail

Fundamentals of LED dot matrix display

2011-05-11T11:08:00.000-07:00

LED dot matrices are very popular means of displaying information as it allows both static and animated text and images. This tutorial describes the basic architecture of a LED dot matrix display and its interfacing with a microcontroller (PIC18F2550) to display static characters and special symbols.

Read rest of the article

Multi-functional power supply with built-in voltage, current, and frequency meters

2011-03-27T07:35:00.000-07:00

While prototyping your new project, you might want to know how much power your designed circuit will draw from the source voltage. One way to find it is to connect an ammeter in series with the circuit and determine the current drawn from the source. Then, knowing the source voltage you can easily determine the power. But doing this may not be always convenient. This project describes a special power supply unit that has built-in features for measuring the source voltage and current. Therefore, you can monitor both the parameters continuously while experimenting your circuit.

Check the details of the project HERE.

555 timer could reduce number of pins in keypad interfacing

2011-02-20T11:39:00.000-08:00

A 4x3 matrix keypad requires 7 I/O pins of microcontroller for interfacing. But you could reduce the required number of connections to two by using a 555 timer IC. If you want to know how, visit Embedded Lab's new post "2-Wire Keypad Interfacing using 555 Timer".

Heart rate measurement through optical sensors

2011-02-05T12:26:00.000-08:00

Resting heart rate is an very important health parameter that is directly related to the soundness of human cardiovascular system. This project describes a digital method of measuring heart rate through fingertip. The blood volume inside the finger artery fluctuates with heartbeats. This fluctuation can be measured by transmitting an IR light through the finger. A portion of this light is reflected back. The amount of light reflected back depends upon the blood volume. This small change in the reflected light is amplified through proper signal conditioning circuit and converted into a pulse. Later, a PIC16F628A microcontroller is used to count the pulses at the output of the signal conditioner and display the heart rate on seven segment LEDs.

The signal conditioning circuit uses two operational amplifiers to build a two-stage active low-pass filter with a gain of about 10000, and a cut-off frequency close to 2.5 Hz.

PIC Micro, H-bridge and DC motor

2011-01-11T06:59:00.000-08:00

H-Bridge is a very popular application circuit for dc motor control. It uses BJTs or MOSFETs to switch on the dc motor in clockwise or counterclockwise direction. This tutorial describes the classical H-bridge circuit and how to interface it with a PIC microcontroller to operate a DC motor.

Read

Programmable digital timer with a relay switch

2011-01-05T11:47:00.000-08:00

This project shows how to make a simple programmable digital timer switch with a PIC16F628A microcontroller. The timing schedule for the relay switch can be programmed through 4 push buttons. The program menu, the status of the relay switch and time information is shown on a character LCD.

The circuit details and firmware are available to download at www.embedded-lab.com in the Projects section.

Running message display board for Christmas decoration

2010-12-08T17:53:00.000-08:00

This is a Christmas decoration project using LEDs and PIC microcontroller. The red color LEDs are used to construct a Christmas greeting and the letters in the message are individually controlled through the microcontroller's I/O pins.

For the circuit diagram and test program, visit PIC16F628A Breadboard Module.
Check the details of the project HERE.

PIC16F628A breadboard module for quick prototyping

2010-12-03T08:50:00.000-08:00

This breadboard module is for PIC16F628A microcontroller and it provides access to the I/O ports and the power supply pins through male headers that can be easily inserted into a breadboard. This board will make protyping easier as the external oscillator, reset, and ICSP circuits are already implemented in the module. The layout of the module is shown below.

You can construct this board on a general purpose prototyping circuit board.

For the circuit diagram and test program, visit PIC16F628A Breadboard Module.

PIC based Diode and BJT tester

2010-11-09T09:26:00.000-08:00

If your digital multimeter does not have features for testing diodes and transistors, hold on, here's a project that describes how you can construct one by yourself. This project is based on a PIC16F688 microcontroller and uses the simple concept of unidirectional conduction of PN juction to find if the diode or transistor is good or bad. The test results are displayed on a character LCD. It also shows the type of the transistor (NPN or PNP) as well as which of the PN junctions are open or short in a faulty transistor.

Source: http://embedded-lab.com/blog/

The firmware is developed using MikroC Pro for PIC compiler. For the details of the circuit diagram and firmware, visit here.

Contact less tachometer using PIC16F628A

2010-10-28T17:43:00.000-07:00

Introduction
Tachometer is a device that gives you the information about the rotational speed of any shaft or disc. It usually measures the speed in revolutions per minute (RPM). Today we are going to make a simple tachometer that could measure the rotation speed of a disk without making any physical contact (that's why it is contact less) with the rotating object. The range of this tachometer is 0 - 9999 RPM and displays the RPM on a multiplexed 4-digit seven-segment display. Of course, we are going to do this project on our usual PIC16F628A development board.

Infrared sensor
Contact-less measurement of RPM will be achieved through an IR sensor. An IR diode will send a beam of infrared towards the rotating disc, and any reflected pulse will be received by a photo diode. The resistance of a photo diode drops drastically when exposed to infrared. An infrared is reflected by a white surface and absorbed by the dark ones. The test disc for this project is shown below. You can see the disc is black and will absorb any infrared falling upon it. A small piece of white paper sticked to the disc as shown is just enough to reflect the infrared back. This will give one reflected IR pulse per rotation which is sensed by the photo diode.

The IR transmitter and receiver circuit is very simple. The IR sensor module built for this purpose is shown below followed by the circuit diagram.

IR Tx is the control signal to turn On and Off the IR transmission. The PIC16F628A microcontroller will turn the IR diode on for 1 sec, and will count the reflected pulse during this interval through IR Rx Pulse output. During normal condition, the photo diode (IR Rx diode) offers high impedance (tens of K) and so the voltage across it will make the BC557 transistor in the receiver part (right) cut off. The IR Rx Pulse will be at logic low. When there is a reflected pulse, the resistance of the photo diode (IR Rx diode) will drop down and allow BC557 transistor to saturate. This gives a logic high at IR Rx Pulse output. The PIC 16F628A will count the pulses within the 1 sec interval to determine the RPM of the disc. Actually, it takes 3 samples of RPM and gives the average. So, the measuring time is 3 sec. The pulses will be counted by Timer0 counter.

Microcontroller Circuit

I suggest to see the circuit diagram of the development board (PIC16F628A Dev Board) first and then follow the instructions below.

Seven segment displays used are common cathode type. The seven segments (a-g) are driven through RB0-RB6 respectively. The 4 common cathodes are controlled by RA0 (units digit) through RA3 (thousands digit).
IR Tx is connected to RB7
IR Rx Pulse is connected to RA4/T0CKI

Software

Compile this code with mikroC. I am using 4.0MHz external crystal for clock and MCLR is enabled.

* Project name: Contact less digital tachometer

* Copyright:

* Test configuration:

MCU: PIC16F628A runs @ 4.0 MHz external crystal oscillator

The common cathodes of the four seven segment dispalys are

controlled by RA0, RA1, RA2 and RA3

//-------------- Function to Return mask for common cathode 7-seg. display

unsigned short mask(unsigned short num) {

switch (num) {

case 0 : return 0x3F;

case 1 : return 0x06;

case 2 : return 0x5B;

case 3 : return 0x4F;

case 4 : return 0x66;

case 5 : return 0x6D;

case 6 : return 0x7D;

case 7 : return 0x07;

case 8 : return 0x7F;

case 9 : return 0x6F;

} //case end

}

sbit IR_Tx at RB7_bit;

sbit DD0_Set at RA0_bit;

sbit DD1_Set at RA1_bit;

sbit DD2_Set at RA2_bit;

sbit DD3_Set at RA3_bit;

unsigned short i, DD0, DD1, DD2, DD3;

unsigned int Sample1, Sample2, Sample3, RPM;

void main() {

TRISB = 0b00000000; // Set PORTB direction to be output

TRISA = 0b00110000; // Set PORTA direction to be output

PORTB = 0x00; // Turn OFF LEDs on PORTB

CMCON = 7 ; // Disable comparators

RPM = 0; // Initial Value of Counter

OPTION_REG = 0b00111000; // TOCS=1 for Counter mode, PSA=1 for 1:1

IR_Tx = 0; // Turn OFF IR

do {

DD0 = RPM%10;

DD0 = mask(DD0);

DD1 = (RPM/10)%10;

DD1 = mask(DD1);

DD2 = (RPM/100)%10;

DD2 = mask(DD2);

DD3 = (RPM/1000);

DD3 = mask(DD3);

for (i = 0; i<=100; i++) {

PORTB = DD0;

DD0_Set = 1;

DD1_Set = 0;

DD2_Set = 0;

DD3_Set = 0;

delay_ms(5);

PORTB = DD1;

DD0_Set = 0;

DD1_Set = 1;

DD2_Set = 0;

DD3_Set = 0;

delay_ms(5);

PORTB = DD2;

DD0_Set = 0;

DD1_Set = 0;

DD2_Set = 1;

DD3_Set = 0;

delay_ms(5);

PORTB = DD3;

DD0_Set = 0;

DD1_Set = 0;

DD2_Set = 0;

DD3_Set = 1;

delay_ms(5);

}

DD3_Set = 0;

// First Sample

TMR0=0;

IR_Tx = 1;

Delay_ms(1000); // Delay 1 Sec

IR_Tx = 0;

Sample1 = TMR0*60;

// Second Sample

TMR0=0;

IR_Tx = 1;

Delay_ms(1000); // Delay 1 Sec

IR_Tx = 0;

Sample2 = TMR0*60;

// Third Sample

TMR0=0;

IR_Tx = 1;

Delay_ms(1000); // Delay 1 Sec

IR_Tx = 0;

Sample3 = TMR0*60;

RPM = Sample1 + Sample2 + Sample3;

RPM = RPM/3;

} while(1); // endless loop

}

Output

The tachometer is tested for various speeds of the rotating disc. The speed is varied by varying the voltage across the motor driving the disc. I got this motor-disc assembly from my old broken printer.

Setup

Slow speed

Fast speed

PIC16F688 based Digital Voltmeter

2010-10-22T10:37:00.000-07:00

Actually this is the another version of my older DVM project that was based on PIC12F683. The older version displays the measured voltage on a LCD that is driven serially by PIC12F683 using 3 I/O pins. The new one uses PIC16F688 microcontroller that doesn't require the serial driver as it has got enough pins to drive a LCD directly in 4-bit mode. The theory and math is just the same. You can read my PIC12F683 version of this project here.

Circuit Diagram

Circuit on breadboard

Important: You need a regulated +5V supply for accuracy of the output. The ADC uses Vdd as the reference for conversion, and all computations are done with Vdd = 5V. You can get a regulated +5V using a LM7805 linear regulator IC.

My source for a regulated +5V using LM7805

My variable power supply source for testing the DVM

Read the detail theory and math involved in this project here.

Software
Use mikroC compiler to compile this code. Use options Internal Clock @ 4 MHz, MCLR Enabled, and Power-Up Timer Enabled.

/*
Digital Voltmeter based on PIC16F688
Rajendra Bhatt, Oct 12, 2010
*/

// LCD module connections
sbit LCD_RS at RC4_bit;
sbit LCD_EN at RC5_bit;
sbit LCD_D4 at RC0_bit;
sbit LCD_D5 at RC1_bit;
sbit LCD_D6 at RC2_bit;
sbit LCD_D7 at RC3_bit;
sbit LCD_RS_Direction at TRISC4_bit;
sbit LCD_EN_Direction at TRISC5_bit;
sbit LCD_D4_Direction at TRISC0_bit;
sbit LCD_D5_Direction at TRISC1_bit;
sbit LCD_D6_Direction at TRISC2_bit;
sbit LCD_D7_Direction at TRISC3_bit;
// End LCD module connections

char Message1[] = "DVM Project";
unsigned int ADC_Value, DisplayVolt;
char *volt = "00.0";

void main() {
ANSEL = 0b00000100; // RA2/AN2 is analog input
ADCON0 = 0b00001000; // Analog channel select @ AN2
ADCON1 = 0x00;
CMCON0 = 0x07 ; // Disbale comparators
TRISC = 0b00000000; // PORTC All Outputs
TRISA = 0b00001100; // PORTA All Outputs, Except RA3 and RA2
Lcd_Init();        // Initialize LCD
Lcd_Cmd(_LCD_CLEAR);             // CLEAR display
Lcd_Cmd(_LCD_CURSOR_OFF);        // Cursor off
Lcd_Out(1,1,Message1);
Lcd_Chr(2,10,'V');

do {

   ADC_Value = ADC_Read(2);
   DisplayVolt = ADC_Value * 2;
   volt[0] = DisplayVolt/1000 + 48;
   volt[1] = (DisplayVolt/100)%10 + 48;
   volt[3] = (DisplayVolt/10)%10 + 48;
   Lcd_Out(2,5,volt);
   delay_ms(100);
} while(1);

}

Output
The DVM has been tested with various input voltages ranging from 0-20 V and found to be very accurate. Here are some of the pictures of testing.

EnerJar: A Digital Energy Meter

2010-10-05T17:23:00.000-07:00

This project won the grand prize of 2008 Green Gadgets Design competition. It measures the power consumption of an electrical gadget with high accuracy. The project uses PIC16F877A microcontroller to compute the power and shows the output on a 4-digit multiplexed seven segment display.

The power consumed by an electrical appliance is simply the product of voltage across the appliance and the current drawn by it. Voltage measurement is pretty straight forward. Using a resistor divider network, 120 V can be converted down to below 5 V, and can be read through ADC port. However, PIC cannot measure the current directly, it must be converted to voltage first. This is done by a low shunt resistance. This voltage drop across the shunt resistance is too small and requires a precision instrumentation amplifier to boost it to appropriate level.

The firmware for PIC is available to download.

Read Rest of the Project

Digital Voltmeter using PIC12F683

2010-10-03T15:15:00.000-07:00

This is a digital voltmeter project based on PIC12F683 microcontroller. It measures and displays input voltage from 0 to 20V with high accuracy. You cannot feed 20V directly to PIC port, so a simple resistor divider network is used for this purpose. A 5.1V zener diode is used to prevent any damage to PIC port in case the input voltage goes way above 20V.

Since PIC12F683 does not have sufficient pins to drive a LCD, 3-wire serial discussed before is used to display the measured voltage.

Read Rest of the Project

My PIC Projects

2010-10-02T16:46:00.000-07:00

Here's the list of all of my PIC Projects posted so far:

Centigrade and Fahrenheit Scale Digital Thermometer with LCD Display

2010-09-28T18:15:00.000-07:00

Digital thermometers are cool devices as they show temperatures in human readable formats. This digital thermometer project is based on a PIC16F688 microcontroller and a DS1820 temperature sensor, and it displays temperature on a character LCD screen in both Celsius and Fahrenheit scales. I selected PIC16F688 for this project because it is cheap (I bought one for $1.50). DS1820 is a 3-pin digital temperature sensor from Dallas semiconductors (now Maxim) which is designed to measure temperatures ranging from -55 to +125 °C in 0.5 °C increments. The firmware I have written is able to read and display the entire temperature range of DS1820. In order to test for temperature measurements below 0°C, I put the sensor inside my freezer. While trying this, don’t put the whole unit inside the freezer as LCD display unit may stop working at the freezer temperature. Similarly, bringing a soldering iron tip close to the sensor can do testing for the higher range temperature values.

About DS1820
I suggest reading my previous articles on DS1820 for getting details about this 1-wire temperature sensor. The firmware that I wrote works only for DS1820 (it may work for DS18S20 making some change in the temperature conversion time, read http://www.maxim-ic.com/datasheet/index.mvp/id/3021). It will definitely not work for DS18B20.

DS1820 converts temperature in to a 9-bit digital word, which is read by PIC16F688 as two bytes (TempH and TempL). The value of the least significant bit is 0.5°C. For positive temperature, the next eight bits after the LSB gives the integer part of the temperature. For example, 000110011 represents 25.5°C. Further, the floating-point math can be avoided during C to F conversion by using a scale factor of 10. Therefore, 25.5°C (scaled 255) is converted to F as,

TempinF = 9*TempinC/5 + 320 = 9*255/5 +320 = 779 (which is 76.9 F)

However, the negative temperatures are stored in 2's complement form. So the most significant bit of the 2-byte temperature reading from DS1820 is 1 if the temperature is below 0°C. The firmware takes care of all negative temperature readings (in both C and F scales). The computed temperature is displayed on LCD as a 5-digit string array, xxx.x (e.g., 24.5, 101.0, -12.5, etc).

Circuit Diagram
The circuit diagram of this project is shown below. DS1820 sensor output is read by PIC16F688 through RA5 port. The computed temperature is converted to a string and sent to the LCD to display. The LCD is operating in 4-bit mode, and ports RC0-RC3 serves D4-D7 data pins of the LCD. The Register Select (RS) and Enable (E) signals for LCD are provided through ports RC4 and RC5. The Read/Write pin of the LCD is permanently grounded, as there is no data read from the LCD in this project. The contrast adjustment of LCD is done with the 10K potentiometer shown in the circuit diagram.

Besides, there are two tact switches in the design. The first one serves as the system reset that is to reset the whole system and reinitialize the LCD. The another tact switch is connected to the external interrupt pin of PIC16F688. This is the toggle switch for the LCD back light. This is helpful in reading the temperature display in low illumination conditions. An interrupt service routine is written for back light toggling. When the system is first turned ON, the LCD back light turns ON by default.

The following circuit can be used to get +5V regulated power supply required for the circuit.

Firmware
The firmware was developed with mikroC compiler from mikroelektronika. The in-built library routines for DS1820 make the firmware development easier. The code is provided with adequate comments so that the reader won't have much difficulty in understanding programming logic.

Digital Room Thermometer using PIC16F688

July 13, 2010

// LCD module connections

sbit LCD_RS at RC4_bit;

sbit LCD_EN at RC5_bit;

sbit LCD_D4 at RC0_bit;

sbit LCD_D5 at RC1_bit;

sbit LCD_D6 at RC2_bit;

sbit LCD_D7 at RC3_bit;

sbit LCD_RS_Direction at TRISC4_bit;

sbit LCD_EN_Direction at TRISC5_bit;

sbit LCD_D4_Direction at TRISC0_bit;

sbit LCD_D5_Direction at TRISC1_bit;

sbit LCD_D6_Direction at TRISC2_bit;

sbit LCD_D7_Direction at TRISC3_bit;

// End LCD module connections

// Back Light Switch connected to RA1

sbit BackLight at RA1_bit;

// Define Messages

char message0[] = "LCD Initialized";

char message1[] = "Room Temperature";

// String array to store temperature value to display

char *tempC = "000.0";

char *tempF = "000.0";

// Variables to store temperature register values

unsigned int temp_whole, temp_fraction, temp_value;

signed int tempinF, tempinC;

unsigned short C_Neg=0, F_Neg=0, TempH, TempL;

void Display_Temperature() {

// convert Temp to characters

if (!C_Neg) {

if (tempinC/1000)

// 48 is the decimal character code value for displaying 0 on LCD

tempC[0] = tempinC/1000 + 48;

else tempC[0] = ' ';

}

tempC[1] = (tempinC/100)%10 + 48; // Extract tens digit

tempC[2] = (tempinC/10)%10 + 48; // Extract ones digit

// convert temp_fraction to characters

tempC[4] = tempinC%10 + 48; // Extract tens digit

// print temperature on LCD

Lcd_Out(2, 1, tempC);

if (!F_Neg) {

if (tempinF/1000)

tempF[0] = tempinF/1000 + 48;

else tempF[0] = ' ';

}

tempF[1] = (tempinF/100)%10 + 48; // Extract tens digit

tempF[2] = (tempinF/10)%10 + 48;

tempF[4] = tempinF%10 + 48;

// print temperature on LCD

Lcd_Out(2, 10, tempF);

}

// ISR for LCD Backlight

void interrupt(void){

if (INTCON.INTF == 1) // Check if INTF flag is set

{

BackLight =~BackLight; // Toggle Backlight

Delay_ms(300) ;

INTCON.INTF = 0; // Clear interrupt flag before exiting ISR

}

void main() {

TRISC = 0x00 ;

TRISA = 0b00001100; // RA2, RA3 Inputs, Rest O/P's

ANSEL = 0b00000000;

PORTA = 0b00000000; // Start with Everything Low

PORTC = 0b00000000; // Start with Everything Low

CMCON0 = 0b00000111;

Lcd_Init(); // Initialize LCD

Lcd_Cmd(_LCD_CLEAR); // CLEAR display

Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off

BackLight = 1;

Lcd_Out(1,1,message0);

Delay_ms(1000);

Lcd_Out(1,1,message1); // Write message1 in 1st row

// Print degree character

Lcd_Chr(2,6,223);

Lcd_Chr(2,15,223);

// different LCD displays have different char code for degree

// if you see greek alpha letter try typing 178 instead of 223

Lcd_Chr(2,7,'C');

Lcd_Chr(2,16,'F');

// Interrupt Setup

OPTION_REG = 0x00; // Clear INTEDG, External Interrupt on falling edge

INTCON.INTF = 0; // Clear interrupt flag prior to enable

INTCON.INTE = 1; // enable INT interrupt

INTCON.GIE = 1; // enable Global interrupts

do {

//--- perform temperature reading

Ow_Reset(&PORTA, 5); // Onewire reset signal

Ow_Write(&PORTA, 5, 0xCC); // Issue command SKIP_ROM

Ow_Write(&PORTA, 5, 0x44); // Issue command CONVERT_T

INTCON.GIE = 1; // 1-wire library disables interrpts

Delay_ms(600);

Ow_Reset(&PORTA, 5);

Ow_Write(&PORTA, 5, 0xCC); // Issue command SKIP_ROM

Ow_Write(&PORTA, 5, 0xBE); // Issue command READ_SCRATCHPAD

// Read Byte 0 from Scratchpad

TempL = Ow_Read(&PORTA, 5);

// Then read Byte 1 from Scratchpad

TempH = Ow_Read(&PORTA, 5);

temp_value = (TempH << 8)+ TempL ;

// check if temperature is negative

if (temp_value & 0x8000) {

C_Neg = 1;

tempC[0] = '-';

// Negative temp values are stored in 2's complement form

temp_value = ~temp_value + 1;

}

else C_Neg = 0;

// Get temp_whole by dividing by 2

temp_whole = temp_value >> 1 ;

if (temp_value & 0x0001){ // LSB is 0.5C

temp_fraction = 5;

}

else temp_fraction = 0;

tempinC = temp_whole*10+temp_fraction;

if(C_Neg) {

tempinF = 320-9*tempinC/5;

if (tempinF < 0) {

F_Neg = 1;

tempF[0] = '-';

tempinF = abs(tempinF);

}

else F_Neg = 0;

}

else tempinF = 9*tempinC/5 + 320;

//--- Format and display result on Lcd

Display_Temperature();

} while(1);

}

Snapshots of temperature measurements

Back Light ON

Back Light OFF

Freezer Temperature

Soldering Iron Temperature

Make your own Serial LCD for PIC Microcontrollers

2010-09-27T17:22:00.000-07:00

HD44780 based character LCD displays are very popular among hobbyists. They are easy to interface with microcontrollers and most of the present day high-level compilers have in-built routines for them. However, the bad part is at least 6 I/O pins of microcontroller are required to use them in your project. Therefore, they are not applicable for 8-pin devices like PIC12F series microchips. The aim of this project is to allow LCD interfacing to such devices using 3-wires. I am going to demonstrate this with PIC12F683 microcontroller. The character data or command from the microcontroller will be transferred serially to an 8-bit serial-in parallel-out shift register (74HC595), and the parallel output will be fed to the LCD driver pins.

Read rest of the project.

Using PIC Timer1 Module for Counting Frequency of an External Clock Source

2010-09-25T19:39:00.000-07:00

The Timer1 module inside PIC12F683 is a 16-bit timer/counter. If used as an asynchronous counter, this module can be used for counting the frequency of an external clock source applied to its GP5/T1CKI port. The following example is a 0-65535 Hz frequency counter using Timer1 module of PIC12F683. The Timer1 module is reset first and then turned ON for 1 sec to count the clock pulses arrived at its T1CKI port during that period. The number of pulses arrived in second is frequency itself. The measured frequency value is sent to PC through serial port and displayed on a hyperterminal receiver window. If the external clock frequency is over 65535 Hz, Timer1 overflows and an interrupt is generated. In case of the overflow, "Frequency out of range " message is displayed on the window. A 555 Timer IC running as an astable multivibrator is used as the external clock source.

Read rest of the project here.

00-99 Minutes Timer

2010-09-20T16:44:00.000-07:00

Introduction
This project describes how to program PIC16F628A to function as a 00-99 min programmable timer. User can set any time between 00-99 minutes and can turn ON a device for that period. The device will be automatically turned OFF after the time expires. For demonstration, the ON/OFF condition of device is simulated by switching LED ON and OFF. With the use of three input switches (unit, ten, start/stop) the user can set ON time of the timer and can also control Start/Stop operation. The two time set switches are for selecting unit and tens digit of minute time interval (00-99). Once you set the value of minute interval, pressing the Start/Stop will turn the timer ON (LED will glow), and pressing the same button again at any point of time during timer operation will interrupt the process (LED will turn OFF) and the timer will be reset. LCD display will provide timer status and user interface for setting time.

Setup
Connect SW1, SW2, and SW3 to RB0, RB1, and RB2 respectively. SW1 will serve Start/Stop, SW2 as unit minute, and SW3 as tens minute. Connect a LED to RA3 port.

Software

/*
  ############################################
  Project: 00-99 Minutes Timer
  Designed By: Rajendra Bhatt
  Date: Sep 03, 2010
  ############################################

  LCD Data D4-D7 connected to RB4-RB7
  LCD RS -> RA0
  LCD E -> RA1
  Start/Stop Time Select -> RB3
  Unit Min Switch -> RB0
  Tens Min Switch -> RB1
  Cancel Switch -> RB2
  Relay -> RA3
*/

// LCD module connections
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections

// Tact switches and Relay ports
sbit Relay at RA3_bit;
sbit SS_Select at RB0_bit; // Start Stop Time Select
sbit Unit_Button at RB1_bit;
sbit Ten_Button at RB2_bit;

// Messages
char Message1[]="00-99 min Timer";
char Message2[]="Device ON";
char Message3[]="Device OFF";
char Message4[]="Set Time: min";
char Message5[]="Time Left: min";
unsigned short i, j, unit=0, ten=0, ON_OFF=0, index=0, clear, time;
char *digit = "00";
// 300ms Delay
void Delay_300(){
Delay_ms(300);
}

void Display_Digits(){
digit[1]=unit+48;
digit[0]=ten+48;
Lcd_Out(2,11,digit);
}

void start_timer(unsigned short tmin){
unsigned short temp1, temp2;
Relay = 1;
ON_OFF = 1;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,1,Message2);
Lcd_Out(2,1,Message5);
OPTION_REG = 0x80 ;
INTCON = 0x90;
for (i=0; i< tmin; i++){
  temp1 = (tmin-i)%10 ;
  temp2 = (tmin-i)/10 ;
  Lcd_Chr(2, 12, temp2+48);
  Lcd_Chr(2, 13, temp1+48);
  j=1;
  do {
  Delay_ms(1000);
  j++;
  } while(((j<=60) && (Clear ==0)));
  if (Clear) {
   Relay = 0;
   Delay_ms(500);
   Lcd_Out(1,1,Message3);
   INTCON = 0x00;
   goto stop;
   }
}
stop: Relay = 0;
ON_OFF = 0;
unit = 0;
ten = 0;
clear = 1;
}

void interrupt(void){

   if (INTCON.INTF == 1) // Check if INTF flag is set
   {
   Clear = 1;
   INTCON.INTF = 0; // Clear interrupt flag before exiting ISR
   }
   }

void main() {
  CMCON |= 7; // Disable Comparators
  TRISB = 0b00001111;
  TRISA = 0b11110000;
  Relay = 0;

  Lcd_Init(); // Initialize LCD
start:
  clear = 0;
  Lcd_Cmd(_LCD_CLEAR); // Clear display
  Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
  Lcd_Out(1,1,Message1);
  Lcd_Out(2,1,Message4);
  Display_Digits() ;
do {

   if(!Unit_Button){
   Delay_300();
   unit ++;
   if(unit==10) unit=0;
   Display_Digits();
   } // If !Unit_Button

   if(!Ten_Button){
   Delay_300();
   ten ++;
   if(ten==10) ten=0;
   Display_Digits();
   } // If !Ten_Button

   if(!SS_Select){
   Delay_300();
   time = ten*10+unit ;
   if(time > 0) start_timer(time);
   } // If !SS_Select

   if(clear){

   goto start;
   }

   } while(1);
}

Output

When the power is first turned on, you will see this on LCD screen.

Use SW2 and SW3 to chose time between 00-99 min.

When you press SW1 (Start/Stop), the LED connected at RA3 will be turned ON and you will see the time left message on the screen too.

When the time is UP, or you press SW1 again, the timer will be interrupted, LED will turn OFF, and the timer is reset to original condition.

Neat LED Chaser for Hobbyists

2010-09-14T16:56:00.000-07:00

Besides just turning ON and OFF, there are lot of other stuff that you can do with LEDs. In one of my experiments, I showed how to control the intensity of an LED using PWM. Here's a project that uses the similar concept to generate 8-channel PWM signals through PIC16F628A ports and drive 8 LEDs with 4 levels of intensity. A number of visual effects and chase sequences are programmed into the firmware. Enjoy watching this video!

Read rest of the project.

Experiment No. 12: Timer0 Counting AC Line Frequency

2010-09-12T15:53:00.000-07:00

Introduction
The Timer0 module in PIC16F628A is both 8-bit Timer and Counter. When used as Counter, the Timer0 module will increment on every rising or falling edge of the T0CKI (RA4, pin 3) pin. The incrementing edge is determined by the T0SE bit of the OPTION register.

Counter mode is selected by setting the T0CS bit to 1 in the OPTION register. You can see from the above table that the minimum prescaler is 1:2 for TMR0. In order to get 1:1 prescaler for Timer0, the prescaler must be assigned to the WDT module. So for our purpose, the value of OPTION register could be 0b00101000 (28h). Now, the Timer0 will work as an 8-bit counter, counting the pulses arrived at RA4/T0CKI pin at low-to-high transition.

Setup

In this experiment we are going to measure the mains AC frequency by using Timer0 as counter. The mains AC frequency is 120V, so we cannot directly feed it to PIC port. We need to first step down the 120V AC first to appropriate level. I am going to use a 12V transformer for this purpose. The 12V AC sine wave output from the transformer will be further converted to 5V square waves (approximately) using a BJT switch. I built this additional circuit on a breadboard. The 5V square waves will be fed to T0CKI port of PIC16F628A. The number of pulses arrived at port T0CKI within 1 second will be the frequency of the input signal.

Note: Don't forget to connect the emitter ground to the ground of PIC16F628A development board.

Now connect the collector of BC547 transistor to T0CKI port (pin 3). Put the 16x2 character LCD module on its socket on the board.

Software

/*
  Project Name: Use of Timer 0 as counter
  * Copyright:   (c) Rajendra Bhatt, 2010.
* Description:  Timer0 counter reads mains frequency and
   display on LCD

* Test configuration:
   MCU: PIC16F628A
   Oscillator: XT, 4.0 MHz
  */
  // LCD module connections
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections

// Define Messages
char message1[] = "Frequency= Hz";
char *freq = "000";
void Display_Freq(unsigned int freq2write) {
  freq[0] = (freq2write/100) + 48; // Extract hundreds digit
  freq[1] = (freq2write/10)%10 + 48; // Extract tens digit
  freq[2] = freq2write%10 + 48; // Extract ones digit
  // print temperature on LCD
  Lcd_Out(1, 11, freq);
}

void main() {
  CMCON |= 7; // Disable Comparators
  TRISB = 0b00000000; // set direction to be output
  Lcd_Init();
  Lcd_Cmd(_LCD_CLEAR); // Clear display
  Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
  Lcd_Out(1,1,message1); // Write message1 in 1st row
  OPTION_REG = 0b00101000; // TOCS=1 for Counter mode, PSA=1 for 1:1 prescaler

  do {
   TMR0=0;
   Delay_ms(1000); // Delay 1 Sec
   Display_Freq(TMR0);
  } while(1); // Till PORTB < 15
}

Output
You will see the mains AC frequency displayed on the LCD.

PIC16F628A Experiments

2010-09-11T05:51:00.000-07:00

Here's the list of all the experiments I have posted on this blog. I have performed these experiments on my PIC16F628A development board.
(First read about my PIC16F628A Development Board)

More experiments will be added to this section in future.

PIC16F628A + DS1820 + 4-Digit Seven Segment C/F Thermometer

2010-09-07T19:01:00.000-07:00

Introduction
This project describes how to read temperature from a DS1820 sensor with a PIC16F628A microcontroller and display the temperature value in a multiplexed 4-digit seven segment display. The temperature will be displayed in both Centigrade and Fahrenheit units switching back and forth. The temperature resolution is 1 degree in both the units. Out of 4-digits, the most significant three digits will display numeric temperature values from 00 to 125. The most significant digit will show '-' for negative temperatures, and the least significant digit will display C or F.

On my PIC16F628A board, connect D1 to RA2, D2 to RA1, D3 to RA0, and D4 to RA3. DS1820 data will be read at RA4 port. The seven segments a-g will be driven by RB0-RB6.

Software

/* Project name:
   Seven-segment display digital thermometer
* Copyright:
   (c) Rajendra Bhatt, 2010.
   MCU: PIC16F628A
   Oscillator: XT, 4.0 MHz
*/

// Temperature digits
unsigned short i, DD0=0x3f, DD1=0x3f,DD2=0x3f, CF_Flag=0xff, CF=0x3f, N_Flag;
// CF_Flag = 0: F, 1: C
// Variable to store temperature register value
unsigned temp_value=0, temp_whole;
unsigned int temp_fraction=0;
float temp_F;

//-------------- Function to Return mask for common cathode 7-seg. display
unsigned short mask(unsigned short num) {
  switch (num) {
   case 0 : return 0x3F;
   case 1 : return 0x06;
   case 2 : return 0x5B;
   case 3 : return 0x4F;
   case 4 : return 0x66;
   case 5 : return 0x6D;
   case 6 : return 0x7D;
   case 7 : return 0x07;
   case 8 : return 0x7F;
   case 9 : return 0x6F;
   case 10 : return 0x40; // Symbol '-'
   case 11 : return 0x39; // Symbol C
   case 12 : return 0x71; // Symbol F
   case 13 : return 0x00; // Blank
  } //case end
}

void display_temp(short DD0, short DD1, short DD2, short CF) {
   for (i = 0; i<=200; i++) {
   PORTB = DD0;
   RA0_bit = 1; // Select Ones Digit
   RA1_bit = 0;
   RA2_bit = 0;
   RA3_bit = 0;
   delay_ms(5);
   PORTB = DD1;
   RA0_bit = 0;
   RA1_bit = 1; // Select Tens Digit
   RA2_bit = 0;
   RA3_bit = 0;
   delay_ms(5);
   PORTB = DD2;
   RA0_bit = 0;
   RA1_bit = 0;
   RA2_bit = 1; // Select +/- Digit
   RA3_bit = 0;
   delay_ms(5);
   PORTB = CF;
   RA0_bit = 0;
   RA1_bit = 0;
   RA2_bit = 0 ;
   RA3_bit = 1; // Select CF Digit
   delay_ms(5);
   }
   return;
}

void main() {
  CMCON |= 7; // Disable Comparators
  TRISB = 0x00; // Set PORTB direction to be output
  PORTB = 0x00; // Turn OFF LEDs on PORTB
  TRISA0_bit = 0; // RA.0 to RA3 Output
  TRISA1_bit = 0;
  TRISA2_bit = 0;
  TRISA3_bit = 0;

   //--- main loop
  do {

   N_Flag = 0; // Reset Temp Flag
   //--- perform temperature reading
   Ow_Reset(&PORTA, 4); // Onewire reset signal
   Ow_Write(&PORTA, 4, 0xCC); // Issue command SKIP_ROM
   Ow_Write(&PORTA, 4, 0x44); // Issue command CONVERT_T
   display_temp(DD0, DD1, DD2,CF) ;
   Ow_Reset(&PORTA, 4);
   Ow_Write(&PORTA, 4, 0xCC); // Issue command SKIP_ROM
   Ow_Write(&PORTA, 4, 0xBE); // Issue command READ_SCRATCHPAD

   // Next Read Temperature
   // Read Byte 0 from Scratchpad
   temp_value = Ow_Read(&PORTA, 4);
   // Then read Byte 1 from Scratchpad and shift 8 bit left and add the Byte 0
   temp_value = (Ow_Read(&PORTA, 4) << 8) + temp_value;

   if (temp_value & 0x8000) {
   temp_value = ~temp_value + 1;
   N_Flag = 1; // Temp is -ive
   }
   if (temp_value & 0x0001) temp_value += 1; // 0.5 round to 1
   temp_value = temp_value >> 1 ;
   if (CF_Flag == 0) {
   if (N_Flag ==1) {
   temp_F = (32.0-9.0*temp_value/5.0)*10 + 6;
   if (temp_F < 0){
   N_Flag=1;
   temp_value = abs(temp_value);
   }
   else N_Flag = 0;
   }
   else temp_F = (9.0*temp_value/5.0+32.0)*10 + 6; //If decimal is greater or equal
   // to 0.5, add 0.5
   temp_value = temp_F/10;
   CF = 12;
   }

   if (CF_Flag == 0xff) CF = 11;

   DD0 = temp_value%10; // Extract Ones Digit
   DD0 = mask(DD0);
   DD1 = (temp_value/10)%10; // Extract Tens Digit
   DD1 = mask(DD1);
   DD2 = temp_value/100; // Extract Hundred digit
   CF = mask(CF);
   if (N_Flag == 1) DD2=10;
   else if (DD2 == 0) DD2 = 13 ;
   DD2 = mask(DD2) ;

   PORTB=0x00;
   CF_Flag =~CF_Flag;

   } while (1);
}

Output Pictures

Over 99F temperature reading (touched the sensor with a hot soldering iron )

Gear Clock Controlled by PIC16F628A

2010-09-03T19:06:00.000-07:00

I was browsing internet for PIC16F628A related projects and I saw this. This guy came up with an amazing idea. He made some wooden gears, tied them up, and drove with a stepper motor from a floppy drive, and turn it into a Gear Clock. The stepper motor is controlled by a PIC16F628A Microchip that also keeps track of time. You can set time with the help of two switches that control clockwise and anti-clockwise motion of the minute gear. If both the switches are pressed, the stepper motor is de-energized and the minute gear is free to rotate by hand.

Source: http://alan-parekh.com/projects/gear-clock/

Read rest of the project.

Digital Thermometer on a Nokia LCD Screen

2010-09-01T07:25:00.000-07:00

If you have an old Nokia 3310 cell phone, don't throw it away. You can use its LCD screen for this cool project. This project describes the use of such a LCD to display temperature. It uses PIC12F629 microchip as a brain that reads temperature measurement from a DS18B20 sensor, and displays it on a Nokia 3310 LCD screen.

Source: http://www.ivica-novakovic.from.hr/Nokia%20Lcd%20Termometar-eng.htm

The Nokia LCD has 84x84 resolution and runs on 2.7-3.3 V supply, and PIC12F629 can also be operated within this voltage range. The best thing is to operate this with 2 AA batteries. For circuit diagram and firmware, Visit Here.

A tiny Temperature Data Logger using PIC12F683 and DS1820

2010-08-27T09:03:00.000-07:00

For past few days, I have been working on a PIC12F683 based temperature data logger. I just finished this project and the product is available on my PIC12F683 blog page.This is how the finished product looks like.

It reads temperature values from a DS1820 sensor and stores in its internal EEPROM. It has 3 selectable sampling intervals (1 sec, 1 min, and 10 min). Three tact switches provides 7 functions, and this runs with 3 AAA batteries. It can be interfaced to a PC through serial port, and also has an ISCP header for firmware upgrade.

Read rest of the project.

MSP430 LaunchPad: Super Cheap Embedded Design Tool for just $4.30

2010-07-30T15:25:00.000-07:00

Texas Instrument is going to make a big move into the hobbyist microcontroller market by introducing MSP430 Launchpad, a development platform for 16-bit MSP430 microcontrollers. Can you guess its price? Yes, $4.30 with free FedEx shipping. It is unbelievable!

"What is LaunchPad?
LaunchPad is an easy-to-use development tool intended for beginners and experienced users alike for creating microcontroller-based applications. At $4.30, the LaunchPad offers everything you need to get started with your projects.

The LaunchPad development kit is a part of the MSP430 Value Line series. LaunchPad has an integrated DIP target socket that supports up to 20 pins, allowing MSP430 Value Line devices to be dropped into the LaunchPad board. Also, an on-board flash emulation tool allows direct interface to a PC for easy programming, debugging, and evaluation. Included are free and downloadable software development environments for writing and debugging software. LaunchPad can be used to create interactive solutions thanks to its on-board push buttons, LEDs, and extra input/output pins for easy integration of external devices."

What is included in the package?

LaunchPad Development board (MSP-EXP430G2)
Mini USB cable
2x MSP430 flash devices
MSP430G2211IN14 flash device
MSP430G2231IN14 flash device (preloaded with sample program)
10-pin PCB Connectors (2 male & 2 female)
32kHz crystal (MS3V-T1R 32.768kHz CL: 12.5pF +/-20ppm, www.microcrystal.com)
Quick Start Guide
2x LaunchPad stickers

Source: http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_(MSP-EXP430G2)

Watch Demo Application

Hurry up, I have already ordered two of them. Order Here.
For more details, CLICK HERE!

Variable DC Power Supply (1.25 - 18V) using LM350 IC

2010-07-11T07:52:00.000-07:00

Introduction
A variable DC power supply is one of the most important tools for an electronics hobbyist. In order to carry out an experiment you need a reliable DC power source that can be varied according to the need of the experiment. Last week I felt I must have one on my workbench, and thought to make one for myself. This design is very simple but is great for powering almost all kinds electronic projects. It uses LM350 (a 3-pin IC) to generate a variable DC power supply. I would recommend to read the datasheet before doing this project.

The LM350 is an adjustable 3-terminal positive voltage regulator that is capable of supplying in excess of 3A over a 1.2V to 33V output range. They are exceptionally easy to use and require only 2 external resistors to set the output voltage.

Main Features

Adjustable output down to 1.2V
Guaranteed 3A output current
Guaranteed thermal regulation
Output is short circuit protected

Requirements
You need following things to make this variable power supplies.

A 120/24V transformer
A bridge rectifier IC or four general purpose diodes.
Capacitors: 1000 uF, 50 V electrolyte (1), 0.1 uF ceramic (1), 1 uF, 50 V electrolyte (1)
Resistors: 360 Ohm (1), 5 K potentiometer (1), 4.7K (1)
A Rocker Switch for AC ON/OFF
A voltmeter display (I used an analog one)
An LED for power on indication.
A heat sink for LM350
Wires, prototyping board, soldering iron, box, etc as per required.

Circuit Diagram

First of all you need to generate an unregulated 24V DC using the step-down transformer and the rectifier circuit. Use the 1000uF capacitor at the output to reduce the ripples. The circuit is shown below.

Fig. Bridge Rectifier Circuit using 4 Diodes

Next comes LM350 IC that takes in this unregulated 24V DC and with the use of two resistors (R1 = 360 Ohm, R2 = 5K Potentiometer) you can derive variable DC voltage. The circuit diagram along with the equation for output voltage is shown below. I took this circuit from LM350 datasheet and it shows R1 = 240 Ohm, but I am gonna use 360 Ohm as I am generating 18V DC at maximum.

The value of IAdj is about 100uA, so the error term is almost negligible.
Other things that are not included in the circuits above are a power on LED and the analog voltmeter display. I connected the LED to the output unregulated 24V DC through 4.7K resistor. This indicates the power switch is ON. Also connect the voltmeter to final output voltage terminals to display what voltage is being generated. Remember the heat sink for LM350.

Assembly

Here are some of the pictures that I took while making this power supply.

Finalized product.

I hope this project will be helpful to you and you have enjoyed reading this.

External Interrupt Demonstration with PIC12F683

2010-07-08T13:48:00.000-07:00

PIC12F683 has got one external interrupt input which is edge triggered. If you want to learn how to write an Interrupt Service Routine (ISR) using mikroC compiler, check this out. When an interrpt arrives, the PIC12F683 displays the interrupt arrival information as a part of ISR on a windows PC hyper-terminal through software UART.

Click here for more details.

Using ADC in mikroC

2010-06-26T13:15:00.000-07:00

With mikroC built-in library, use of ADC on PIC microcontrollers has become more simple. PIC16F628A doesn't have in-built ADC in it, so I am going to demonstrate this with my PIC12F683 development board. The analog input will be given through a potentiometer, and the 10-bit digital output will be displayed on a hyperterminal window on PC.

See details of this HERE

PIC12F683 Development Board

2010-02-17T14:46:00.000-08:00

I have recently made a new PIC development board for PIC12F683. It is an 8-pin microcontroller with a lot of good features including 10-bit ADC and PWM. The development board has following features:

1. A Regulated +5V power supply.

2. 3 Red LED outputs which can be connected to any GPIO pins using jumper wires.

3. An ON/OFF power supply switch.

4. A Green LED as a power ON indicator.

5. An 8-pin IC socket for PIC12F683 microcontroller.

6. Two potentiometers: one for providing Vref, and other for simulating analog input to ADC.

7. An ICSP header connector.

8. Two tactile switches for input operation.

9. A TTL to RS232 level shifter using a transistor circuit.

10. A piezo buzzer.

11. A DC motor with driving circuit.

12. Access to individual pins of PIC12F683 through female header pins.

For further details, visit Read My Blog

Experiment No. 11: Temperature Data Logger Using PIC16F628A Microcontroller

2010-02-13T15:01:00.000-08:00

This project is the combination of the two experiments that we already did in past: Experiment No. 4 and 10. In experiment 4, we demonstrated how to use the mikroC 1-wire library to read temperature data from a digital sensor DS1820, and display the value on a LCD screen. Now we are going to use the hardware UART to transfer the temperature data from the PIC to a PC (Exp. No. 10). The Hyper-Terminal program running on a PC will receive the temperature values and display on screen. The temperature data from the microcontroller will be sent in every 15 sec.

Experimental Setup:

The setup for this experiment is same as the Experiment no. 10 with a DS1820 inserted in its 3-pin female header receiver on the board. The data output of DS1820 is connected to RB.0 (see articles Exp. No. 4 and 1-Wire Protocol for detail). You need to rebuild the same TTL to RS232 level shifter circuit on a breadboard and set up a hyper-terminal to receive data at 9600 baud rate.

Software:

/*
* Project name:
Temperature Data Logger

PIC16F628A reads digital temperature data from a DS1820 chip, and

send it to a PC through RS232 port to display on hyperterminal window.
* Copyright:
(c) Rajendra Bhatt, 2009.
*/

// String array to store temperature value to display
char *temp = "000.00";

// Temperature Resolution : No. of bits in temp value = 9
const unsigned short TEMP_RES = 9;

// Variable to store temperature register value
unsigned temp_value;

void Display_Temperature(unsigned int temp2write) {
const unsigned short RES_SHIFT = TEMP_RES - 8;

// Variable to store Integer value of temperature
char temp_whole;

// Variable to store Fraction value of temperature
unsigned int temp_fraction;

// check if temperature is negative
if (temp2write & 0x8000) {
     temp[0] = '-';
     // Negative temp values are stored in 2's complement form
     temp2write = ~temp2write + 1;
     }

// Get temp_whole by dividing by 2 (DS1820 9-bit resolution with
// 0.5 Centigrade step )
temp_whole = temp2write >> RES_SHIFT ;

// convert temp_whole to characters
if (temp_whole/100)
// 48 is the decimal character code value for displaying 0 on LCD
     temp[0] = temp_whole/100 + 48;
else
     temp[0] = '0';

temp[1] = (temp_whole/10)%10 + 48;             // Extract tens digit
temp[2] = temp_whole%10     + 48;             // Extract ones digit

// extract temp_fraction and convert it to unsigned int
temp_fraction = temp2write << (4-RES_SHIFT);
temp_fraction &= 0x000F;
temp_fraction *= 625;

// convert temp_fraction to characters
temp[4] = temp_fraction/1000    + 48;         // Extract tens digit
temp[5] = (temp_fraction/100)%10 + 48;         // Extract ones digit

// Send temperature to RS232
UART1_Write(10); // Line Feed
UART1_Write(13); // Carriage Return
UART1_Write_Text("Temperature= ");
UART1_Write_Text(temp);

}

//unsigned char _data = 0x1E;
void main() {
CMCON = 7;       // Disable Comparators
UART1_Init(9600);
Delay_ms(100);
//--- main loop
do {
    //--- perform temperature reading
    Ow_Reset(&PORTB, 0);      // Onewire reset signal
    Ow_Write(&PORTB, 0, 0xCC);   // Issue command SKIP_ROM
    Ow_Write(&PORTB, 0, 0x44);   // Issue command CONVERT_T
    Delay_ms(600);
    // If this delay is less than 500ms, you will see the first reading on LCD
    //85C which is (if you remember from my article on DS1820)
    //a power-on-reset value.

    Ow_Reset(&PORTB, 0);
    Ow_Write(&PORTB, 0, 0xCC);    // Issue command SKIP_ROM
    Ow_Write(&PORTB, 0, 0xBE);    // Issue command READ_SCRATCHPAD

    // Read Byte 0 from Scratchpad
    temp_value = Ow_Read(&PORTB, 0);
    // Then read Byte 1 from Scratchpad and shift 8 bit left and add the Byte 0
    temp_value = (Ow_Read(&PORTB, 0) << 8) + temp_value;

    //--- Format and display result on Lcd
    Display_Temperature(temp_value);
    Delay_ms(30000);

    } while (1);
}

Output:

Experiment No. 10: Use of UART Library to Communicate with PC

2010-01-23T09:22:00.000-08:00

MikroC has two sets of built-in library functions for UART communications: Software UART and Hardware UART. Since PIC16F628A has a built-in hardware USART module, we are going to use the Hardware UART library. Some PICs don't have hardware USART, such as PIC16F84A. In such cases, any digital I/O pins of PIC can be used for Asynchronous Serial Data Transfer using mikroC Software UART libraries.

Experimental Setup

The UART Rx and Tx pins in PIC16F628A are multiplexed with RB1 and RB2 pins. In this experiment, we are just sending some character data from PIC to a PC as demonstration of the technique. On PC, the HyperTerminal program should be running to receive data from the PIC16F628A. Since our PIC board does not have a TTL to RS232 voltage level shifter, we are going to construct it on a breadboard. Here is my Level Shifter Circuit:

Connect Tx on PIC side to RB2 pin and leave Rx open, as we are not receiving any data from PC. And, the same circuit on breadboard is shown below. I am using BC557 transistor. The diode in the circuit is any general purpose diode.

BC557 Transistor Pins	Relevant Links

I have one COM Port on my PC to which I have connected a RS232 DB9 female connector. We need to make a common ground between RS232 and our experiment board. So connect pin 5 (which is ground) of DB9 connector to our circuit ground.

Male DB9 Connector Pin descriptions. (Source:http://tk5ep.free.fr/tech/ts850/if232/img/db9_pinouts.gif )

The same signal pins for a female DB9 connector. See, how the pins are flipped around horizontal.

Complete Setup for this Experiment

We are going to set 9600 baud rate for data transfer, so next step is to setup the Hyperterminal on PC. I am running this on Windows XP.

Go to Start-> All Programs -> Accessories -> Communications -> Hyper Terminal
Setup a New Connection to a proper COM port number with

bps : 9600
Databits: 8
Parity : None
Stop Bits : 1
Flow Control : Hardware

Click OK and now the HyperTerminal is ready to receive data from PIC.

Software
As mentioned earlier, mikroC has in-built library functions for hardware UART. Check out the manual here.

/*
* Project name:
Asynchronous Serial Data Transfer from PIC16F628A to a PC HyperTerminal
* Copyright:
(c) Rajendra Bhatt, 2009.

*/

void main() {
CMCON = 7;       // Disable Comparators
UART1_Init(9600);     // Baud Rate 9600
Delay_ms(100);
while(1) {
//UART1_Write(_data);
UART1_Write_Text(" UART Test Successful! ");   // Character Message to be Sent
UART1_Write(10); // Line Feed
UART1_Write(13); // Carriage Return
delay_ms(2000);     // Send the message every 2 seconds
}
}

Experimental Output

Experiment No. 9: DC Motor Speed Control using PWM

2010-01-06T18:28:00.000-08:00

This is an extension of Experiment No. 8 (Click Here). The PWM output is here connected to power a DC motor through a NPN driving transistor. The motor driving circuit is built in a breadboard, as shown below. The circuit is pretty straight forward, the PWM output from PIC pin drives the BC547 transistor ON and OFF, and the current to drive the motor is provided by the collector current in the transistor. The diode is for back EMF protection. I am using a small 6V DC motor from an old cassette player. For motors that require more current to drive, a darlington transistor pair or high power transistor is recommended.

Experiment No. 8: Use of PWM to control the brightness of a LED.

2009-11-18T17:50:00.000-08:00

Introduction:
A PIC16F628A has an in-built Capture/Compare/PWM (CCP) module for which the I/O pin is served by RB.3 (Pin No. 9). In this experiment we are going to use the CCP as a PWM to control the power to a LED. PWM stands for the Pulse Width Modulation where the width of a digital waveform is varied to control the power delivered to a load. The underlying principle in the whole process is that the average power delivered is directly proportional to the modulation duty cycle. The term duty cycle describes the proportion of on time to the regular interval or period of time; a low duty cycle corresponds to low power, because the power is off for most of the time. Duty cycle is expressed in percent, 100% being fully on.

Image Source: http://www.micromouseinfo.com/introduction/images/intro_hardware/PWMod.gif

The mikroC has an in-built library functions for PWM hardware module. Click here for details.

Experimental Setup:

In this experiment, we are going to have 11 different intensities (including complete turn OFF) of a LED by varying the duty cycle. We will connect a LED to RB.3, and two Push Buttons to RB.0 and RB.1. The two buttons are for Increment/Decrement the intensity of the LED.

Software:

Project Name: Use of Timer 0 and Interrupt

* Copyright:

* Description:

Use of CCP module as a Pulse Width Modulation

* Test configuration:

MCU: PIC16F628A

Oscillator: XT, 4.0 MHz

unsigned short new_DC, current_DC;

void main() {

PORTB = 0; // Initial state of port B

TRISB = 3; // RB0, RB1 input, RB3 (PWM1) output

PWM1_Init(5000); // PWM module initialization (5KHz)

new_DC = 0; // Initial value of variable Duty Cycle

current_DC = 0;

PWM1_Start(); // Start PWM1 module with Zero DC

PWM1_Set_Duty(current_DC);

while (1) {

if (Button(&PORTB, 0,1,0)) { // If the button connected to RB0 is pressed

if (new_DC < 250) // Don't go above 250

new_DC = new_DC + 25 ; // increment Duty Cycle by 25

}

if (Button(&PORTB, 1,1,0)) { // If the button connected to RB1 is pressed

if (new_DC !=0) // Don't go below 0

new_DC= new_DC - 25 ; // decrement Duty Cycle by 25

}

if (current_DC != new_DC) {

current_DC = new_DC ;

PWM1_Set_Duty(current_DC); // Change the current DC to new value

}

Delay_ms(150);

}

Experimental Output Video:

Experiment No. 7: Timers and Interrupts

2009-11-02T17:52:00.000-08:00

Background
Many microcontroller applications like generating periodic signals, measuring time interval, keeping date and time, use time as their variable. Therefore, microcontrollers need to have some internal resources to accurately measure time. The PIC16F628A has 3 timer modules which are known as Timer0, Timer1, and Timer2. The basic unit of a timer is a free-run 8-bit or 16-bit incrementing synchronous counter which can be programmed to count internal or external pulses. The count number stored by each counter can be read or modified by accessing the special function register associated with that timer. Some of the bits in these registers are also the indicators of timer overflow, which, therefore, can generate interrupt request to the microcontroller. The use of timer modules to keep record of time elapsed allows the microcontroller to carry on with its other operations like controlling outputs, reading inputs, etc.

Timers can also have another asynchronour counter, known as prescaler, which can be configured to divide the number of pulses received by the timer register to be divided by a factor of 2, 4, 8, 16, 32, 64, 128 or 256.

1. Timer0 Module

The Timer0 module is an 8-bit timer/counter which can be configured to count machine cycles or external pulses. When counting machine cycles, it is known to operate as a timer, and when counting the external pulses, it is called to operate as a counter. The external pulses are given to RA4/T0CKI pin. The Timer0 also consists of an 8-bit prescaler which is a programmable division factor.

The operation of the timer is set up by moving a suitable control code into the OPTION register. Timer mode is selected by clearing the T0CS bit (OPTION<5>). In Timer mode, the TMR0 register value will increment every instruction cycle (without prescaler). Counter mode is selected by setting the T0CS bit. In this mode, the TMR0 register value will increment either on every rising or falling edge of pin RA4/T0CKI pin. The incrementing edge is determined by the source edge (T0SE) control bit (OPTION<4>). Clearing the
T0SE bit selects the rising edge.

Timer0 interrupt is generated when the TMR0 register timer/counter overflows from FFh to 00h. This overflow sets the T0IF bit of INTCON register. The interrupt can be masked by clearing the T0IE bit (INTCON<5>). The T0IF bit (INTCON<2>) must be cleared in software by the Timer0 module interrupt service routine before reenabling this interrupt.

The prescalar value can be set using the PSA and PS<2:0> bits of OPTION register.

2. Timer1 and Timer2
Refer to datasheet.
So in this experiment, we are going to use Timer0 to generate delay for a 4-bit up counter. Connect RB0-RB3 to the 4 LEDs on the board using jumpers.

Software:

/*
Project Name: Use of Timer 0 and Interrupt
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This code is an example of using Timer 0 and Interrupt for delay.

* Test configuration:
     MCU:             PIC16F628A
     Oscillator:      XT, 4.0 MHz
*/

unsigned cnt, num;
void interrupt() {   // Interrupt routine
    num ++;            // Interrupt causes Num to be incremented by 1
    if(num == 20) {
    cnt ++;           // 20 Interrupts causes cnt to be incremented by 1
    num = 0;
    }
    TMR0 = 0;        // Timer (or counter) TMR0 returns its initial value
    INTCON = 0x20;   // Bit T0IE is set, bit T0IF is cleared
}

void main() {
cnt=0;
num=0;
OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
TMR0 = 0;          // Timer T0 counts from 0 to 255
INTCON = 0xA0;     // Enable interrupt TMR0
TRISB = 0x00;          // set direction to be output
PORTB = 0;         // Turn OFF LEDs on PORTB
do {
    PORTB =cnt ;
} while(PORTB < 0x0f); // Till PORTB < 15
}

Experiment No. 6: Read/Write Internal EEPROM Memory

2009-10-20T18:58:00.000-07:00

An EEPROM (Electrically-Erasable Programmable ROM) data memory is one of the important features of flash-based PIC microcontrollers. It is called non-volatile to indicate that it retains the data even when the power is down. Practically speaking, if you want to design a digital lock system, then the password to unlock the system can be saved into the EEPROM, so that when the power is down, the password will still be saved. And other good thing is that the data can be easily modified or overwritten with software control. In this experiment, I am going to show you how to read and write in to the internal EEPROM memory of PIC16F628A using mikroC EEPROM library functions. Here is what we are going to do:

We will write 0s to 10 EEPROM locations. We will read them first, then write 0-9 to these locations, and turn the power off. We will turn the power on, and read the data in those locations and see. I have created a simple menu on LCD with Read, Write and Delete functions.

Experimental Setup:
Connect the three push buttons on the board to RB.0, RB.1, and RB.2, and plug-in the LCD module.

Software:

/*
Project Name: Read/Write Internal EEPROM
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This code is an example of accessing internal EEPROM.

* Test configuration:
     MCU:             PIC16F628A
     Oscillator:      XT, 4.0 MHz
*/

// LCD module connections
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections
// Define Messages
char message1[] = "1.READ";
char message2[] = "2.WRITE";
char message3[] = "3.Delete";
char message4[] = "WRITE COMPLETED";
char message5[] = "Read Data";
char message6[] = "Data Deleted";

char digits[] = "0000000000";
unsigned short i, NUM ;
unsigned int ADD = 0x00, temp; // Start EEPROM Location

void main() {
CMCON |= 7;      // Disable Comparators
TRISB = 0x0F;
PORTB = 0x00;
Lcd_Init();
start:
Lcd_Cmd(_LCD_CLEAR);               // Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
Lcd_Out(1,1,message1);             // Write message1 in 1st row
Lcd_Out(1,8,message2);
Lcd_Out(2,1,message3);
do {
// Read Operation
if (Button(&PORTB, 0, 1, 0)) { // Detect logical one to zero
      Delay_ms(300);
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1,message5);
      for (i=0; i<=9; i++) {
      temp = ADD+i;
      NUM = EEPROM_Read(temp);
      digits[i] = NUM+48;
      }
      Lcd_Out(2,1,digits);
      delay_ms(3000);
      goto start;
   }
// Write Operation
if (Button(&PORTB, 1, 1, 0)) { // Detect logical one to zero
      Delay_ms(300);
      for (i=0; i<10; i++) {
      temp = ADD + i;
      EEPROM_Write(temp,i);
      }
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1,message4);
      delay_ms(2000);
      goto start;
}

// Delete Operation
if (Button(&PORTB, 2, 1, 0)) { // Detect logical one to zero
      Delay_ms(300);
      Lcd_Cmd(_LCD_CLEAR);
      Lcd_Out(1,1,message6);
      for (i=0; i<=9; i++) {
      temp = ADD+i;
      EEPROM_Write(temp, 0);
      }
      delay_ms(2000) ;
      goto start;
   }

} while(1);
}

Experimental Output Video:

Experiment No. 5: Multiplexed Seven Segment Displays

2009-10-10T16:09:00.000-07:00

In this experiment, we are going to learn how to interface more than one 7-segment LED display to a PIC Port using multiplexing technique. We are going to interface a 4-digit common cathode seven segment display to our PIC board. The multiplexing circuit is already built up in the board using 4 transistors and few resistors (Read Make Your Own PIC Development Board). The basic idea of multiplexing is that all seven segment displays are connected to the microcontroller in parallel and the microcontroller alternately prints ones, tens, hundreds, and thousands digits, selecting one at a time. The switching among the digits is so fast that it gives an impression of simultaneous light emission.

Experimental Setup:

1. Connect RA0 through RA3 to 7-Segment Digit Select headers DG1, DG2, DG3, and DG4 using jumper wires.
2. Insert 7FR5641AS 4-Digit Seven Segment module in to its place on the board.

Software:
/*
* Project name:
     4-Digit UP Counter with Four 7-Segment Display Multiplexing
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This code is an example of multiplexing 4 Seven Segment Displays.

* Test configuration:
     MCU:             PIC16F628A
     The common cathode of four seven segment dispalys are
     connected to RA0, RA1, RA2 and RA3
*/
//-------------- Function to Return mask for common cathode 7-seg. display
unsigned short mask(unsigned short num) {
switch (num) {
    case 0 : return 0x3F;
    case 1 : return 0x06;
    case 2 : return 0x5B;
    case 3 : return 0x4F;
    case 4 : return 0x66;
    case 5 : return 0x6D;
    case 6 : return 0x7D;
    case 7 : return 0x07;
    case 8 : return 0x7F;
    case 9 : return 0x6F;
} //case end
}
unsigned short i, DD0, DD1, DD2, DD3, NUM ;
void main() {
CMCON |= 7;      // Disable Comparators
TRISB = 0x00;    // Set PORTB direction to be output
PORTB = 0xff;    // Turn OFF LEDs on PORTB
TRISA0_bit = 0; // RA.0 to RA3 Output
TRISA1_bit = 0;
TRISA2_bit = 0;
TRISA3_bit = 0;
TRISA4_bit = 1;      // RA.4 is Input only

NUM   =    0; // Initial Value of Counter

do {
DD0 = NUM%10; // Extract Ones Digit
DD0 = mask(DD0);
DD1 = (NUM/10)%10; // Extract Tens Digit
DD1 = mask(DD1);
DD2 = (NUM/100)%10; // Extract Hundreds Digit
DD2 = mask(DD2);
DD3 = (NUM/1000); // Extract Thousands Digit
DD3 = mask(DD3);

for (i = 0; i<=50; i++) {
      PORTB = DD0;
      RA0_bit = 1;          // Select Ones Digit
      RA1_bit = 0;
      RA2_bit = 0;
      RA3_bit = 0;
      delay_ms(5);
      PORTB = DD1;
      RA0_bit = 0;
      RA1_bit = 1;        // Select Tens Digit
      RA2_bit = 0;
      RA3_bit = 0;
      delay_ms(5);
      PORTB = DD2;
      RA0_bit = 0;
      RA1_bit = 0;
      RA2_bit = 1;         // Select Hundreds Digit
      RA3_bit = 0;
      delay_ms(5);
      PORTB   = DD3;
      RA0_bit = 0;
      RA1_bit = 0;
      RA2_bit = 0;
      RA3_bit = 1;         // Select Thousands Digit
      delay_ms(5);
      }
      NUM = NUM + 1 ;
} while(1);                             // endless loop
}

Experimental Output Video:

Experiment No. 4 : Reading Temperature Values from DS1820 using 1-Wire Protocol

2009-09-30T19:09:00.000-07:00

In this experiment, we are going to build a digital temperature meter using DS1820 connected to our PIC16F628A development board. The temperature value will be displayed on the LCD display. I have modified the sample program that comes with the compiler according to our PIC board requirements. Also I have elaborated comments in the program so that every step will be more clear to the readers.

Experimental Setup:
The experimental setup is very straight-forward. Place DS1820 device on the three-pin female header that we recently added to our board. And also connect the data pin of DS1820 to RB.0 pin of PIC16F628A using a jumper wire.

Circuit Diagram

Software:
Here is the program written in microC that reads temperature values from DS1820 device using OneWire Library.
/* Project name:
     One Wire Communication Test between PIC16F628A and DS1820
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This code demonstrates how to use One Wire Communication Protocol
     between PIC16F628A and a 1-wire peripheral device. The peripheral
     device used here is DS1820, digital temperature sensor.
     MCU:             PIC16F628A
     Oscillator:      XT, 4.0 MHz
*/
// LCD connections definitions
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD connections definitions

// String array to store temperature value to display
char *temp = "000.00";

// Temperature Resolution : No. of bits in temp value = 9
const unsigned short TEMP_RES = 9;

// Variable to store temperature register value
unsigned temp_value;

void Display_Temperature(unsigned int temp2write) {
const unsigned short RES_SHIFT = TEMP_RES - 8;

// Variable to store Integer value of temperature
char temp_whole;

// Variable to store Fraction value of temperature
unsigned int temp_fraction;
unsigned short isNegative = 0x00;

// check if temperature is negative
if (temp2write & 0x8000) {
     temp[0] = '-';
     // Negative temp values are stored in 2's complement form
     temp2write = ~temp2write + 1;
   isNegative = 1; // Temp is -ive
     }

// Get temp_whole by dividing by 2 (DS1820 9-bit resolution with
// 0.5 Centigrade step )
temp_whole = temp2write >> RES_SHIFT ;

// convert temp_whole to characters
if (!isNegative) {
   if (temp_whole/100)
   // 48 is the decimal character code value for displaying 0 on LCD
     temp[0] = temp_whole/100 + 48;
   else
     temp[0] = '0';
}

temp[1] = (temp_whole/10)%10 + 48;             // Extract tens digit
temp[2] = temp_whole%10     + 48;             // Extract ones digit

// extract temp_fraction and convert it to unsigned int
temp_fraction = temp2write << (4-RES_SHIFT);
temp_fraction &= 0x000F;
temp_fraction *= 625;

// convert temp_fraction to characters
temp[4] = temp_fraction/1000    + 48;         // Extract tens digit
temp[5] = (temp_fraction/100)%10 + 48;         // Extract ones digit

// print temperature on LCD
Lcd_Out(2, 5, temp);
}

void main() {
CMCON |= 7;                       // Disable Comparators
Lcd_Init();                                    // Initialize LCD
Lcd_Cmd(_LCD_CLEAR);                           // Clear LCD
Lcd_Cmd(_LCD_CURSOR_OFF);                      // Turn cursor off
Lcd_Out(1, 3, "Temperature:   ");
// Print degree character, 'C' for Centigrades
Lcd_Chr(2,11,223);
// different LCD displays have different char code for degree
// if you see greek alpha letter try typing 178 instead of 223

Lcd_Chr(2,12,'C');

//--- main loop
do {
    //--- perform temperature reading
    Ow_Reset(&PORTB, 0);      // Onewire reset signal
    Ow_Write(&PORTB, 0, 0xCC);   // Issue command SKIP_ROM
    Ow_Write(&PORTB, 0, 0x44);   // Issue command CONVERT_T
    Delay_ms(600);
// If this delay is less than 500ms, you will see the first reading on LCD
    //85C which is (if you remember from my article on DS1820)
    //a power-on-reset value.

    Ow_Reset(&PORTB, 0);
    Ow_Write(&PORTB, 0, 0xCC);    // Issue command SKIP_ROM
    Ow_Write(&PORTB, 0, 0xBE);    // Issue command READ_SCRATCHPAD

    // Read Byte 0 from Scratchpad
    temp_value = Ow_Read(&PORTB, 0);
    // Then read Byte 1 from Scratchpad and shift 8 bit left and add the Byte 0
    temp_value = (Ow_Read(&PORTB, 0) << 8) + temp_value;

    //--- Format and display result on Lcd
    Display_Temperature(temp_value);

    } while (1);
}

Experimental Output:
The temperature reading will be displayed on the LCD screen and will be updated every 600ms. Look at some snapshots below showing output.

DS18S20 : 1-Wire Digital Thermometer and mikroC OneWire Library

2009-09-29T12:25:00.000-07:00

Introduction
The DS18S20 is a 1-Wire digital thermometer device from MAXIM that provides 9-bit Celsius temperature measurements and communicates over a 1-Wire bus with a central microprocessor. It also has in-built alarm function with nonvolatile user-programmable upper and lower trigger points. The operating temperature range of the device is –55°C to +125°C with an accuracy of ±0.5°C over the range of –10°C to +85°C. Each DS18S20 has a unique 64-bit serial code, which allows multiple DS18S20s to function on the same 1-Wire bus. Thus, it is simple to use one microprocessor to control many DS18S20s distributed over a large area.

Device Overview
The figure below shows a block diagram of the DS18S20. The 64-bit ROM stores the device’s unique serial code. The scratchpad memory contains the 2-byte temperature register that stores the digital output from the temperature sensor. In addition, the scratchpad provides access to the 1-byte upper and lower alarm trigger registers (TH and TL). The TH and TL registers are nonvolatile (EEPROM), so they will retain data when the device is powered down.

Operation

The core functionality of the DS18S20 is its direct-to-digital temperature sensor. The temperature sensor output has 9-bit resolution, which corresponds to 0.5°C steps. The output data is calibrated in degrees centigrade and is stored as a 16-bit sign-extended two’s complement number in the temperature register. The power-on-reset value of the temperature register is +85°C. The sign bits (S) indicate if the temperature is positive or negative: for positive numbers S = 0 and for negative numbers S = 1. A table below shows some examples of digital output data and corresponding temperature reading.

Step-by-Step Operation Sequence
Now we will discuss one of the simplest ways for accessing the DS18S20. We assume that there is only one such device on bus, and say the bus is connected to RB.0 pin of a PIC16F628A. We will also discuss the built-in OneWire library functions available in mikroC for PIC 2009.

1) All transactions on the wire bus should begin with an initialization sequence. The bus master (microcontroller) should transmit a reset pulse first, and in its response, the DS18S20 will send the presence pulse indicating that it is on the bus and ready to operate. During the initialization sequence the bus master transmits (TX) the reset pulse by pulling the 1-Wire bus low for a minimum of 480μs. The bus master then releases the bus and goes into receive mode (RX). When the bus is released, the 4.7kΩ pullup resistor pulls the 1-Wire bus high. When the DS18S20 detects this rising edge, it waits 15μs to 60μs and then transmits a presence pulse by pulling the 1-Wire bus low for 60μs to 240μs.
The mikroC function to reset the DS18S20 is Ow_Reser(&PORTB, 0).

2) Since there is only one device on the bus, no need to search, read and match the 64-bit ROM address. Rather, the master device can skip the whole ROM sequence by sending SKIP ROM [CCh] command. If there were more than one device on the bus, the master can use SEARCH ROM [F0h], READ ROM [33h], and MATCH ROM [55h] commands to address one specific device on the same bus. The mikroC function to issue SKIP ROM command is Ow_Write(&PORTB, 0, 0xCC).

3) Next use CONVERT T [44h] command to initiate a single temperature conversion. Following the conversion, the resulting thermal data is stored in the 2-byte temperature register in the scratchpad memory. The mikroC function to issue CONVERT T command is Ow_Write(&PORTB, 0, 0x44).

4) Use READ SCRATCHPAD [BEh] command to read the contents of the scratchpad. The data transfer starts with the least significant bit of byte 0 and continues through the scratchpad until the 9th byte (byte 8 – CRC) is read. The master may issue a reset to terminate reading at any time if only part of the scratchpad data is needed. The mikroC function to issue READ SCRATCHPAD command is Ow_Write(&PORTB, 0, 0xBE). After that you can use Ow_Read(&PORTB, 0) to read one byte of data via the one wire bus. In order to read both the bytes of temperature register, use Ow_Read command twice.

OneWire Library in mikroC for PIC

To explore more about DS18S20 device, read the datasheet.

The 1-Wire Communication Protocol

2009-09-22T08:56:00.000-07:00

The 1-Wire is a registered trademark of Dallas Semiconductor Corp (now Maxim) for a serial communication protocol using a single data line and a ground reference. A 1-Wire Master (a microcontroller) initiates and controls the communication with one or more 1-Wire Slave devices (usually sensors). Each 1-Wire slave device has a unique, factory-programmed , 64-bit identifier, which serves as device address on the 1-Wire bus. This globally unique address is composed of eight bytes divided into three main sections. Starting with the LSB, the first byte stores the 8-bit family codes that identify the device type. The next six bytes store a customizable 48-bit individual address. The last byte, the most significant byte (MSB), contains a cyclic redundancy check (CRC) with a value based on the data contained in the first seven bytes. This allows the master to determine if an address was read without error. With a 248 serial number pool, conflicting or duplicate node addresses on the net are never a problem.

The 1-Wire protocol uses conventional CMOS/TTL logic levels (maximum 0.8V for logic “zero” and a minimum 2.2V for logic “one”) with operation specified over a supply voltage range of 2.8V to 6V.

A Typical 1-Wire Communication Flow

The first part of any communication involves the bus master issuing a reset, which synchronizes the entire bus. A slave device is then selected for subsequent communications. This can be done by selecting all slaves, selecting a specific slave (using the registration number of the device), or by discovering the next slave on the bus using a binary search algorithm. These commands are referred to collectively as network function or read-only-memory (ROM) commands. Once a specific device has been selected, all other devices drop out and ignore subsequent communications until the next reset is issued.
Once a device is isolated for bus communication, the master can issue device-specific commands to it, send data to it, or read data from it. Because each device type performs different functions and serves a different purpose, each type has a unique protocol once it has been selected. Even though each device type may have different protocols and features, they all have the same selection process and follow the command flow seen in the figure below.

Browse these links for more information on the 1-Wire Protocol.

Example: DS1820 Digital Temperature Sensor

I am going to show you how to connect a DS1820, a 1-Wire digital temperature sensor, to a PIC microcontroller.

We are now going to implement this circuit in our PIC16F628A development board. We will place a 3-pin female header to hold DS1820 and an additional single pin header for a jumper to connect the data pin to a PIC port. Here is the modified board after soldering the female header connections and a 4.7K resistor on the board.

A more closer look:

We will discuss about the 1-Wire built in library of mikroC for PIC 2009 compiler in the next article. Our next experiment is going to be about reading the temperature values from a DS1820 sensor using the 1-Wire communication protocol. Till then, good bye.

Experiment No. 3: LCD Interface in 4-bit Mode

2009-09-17T19:52:00.000-07:00

The objective of this experiment is to interface a 16x2 LCD to PIC16F628A in 4-bit mode. This means the data transfer will use only four pins of the microcontroller. There is no additional hardware setup needed for this experiment, as we have a ready-made LCD interface female header. We only need to define the data transfer and control pins in the software. Remember, the LCD interface in our development board uses the following pins of PIC16F628A:

Data Transfer : D4 -> RB4, D5 -> RB5, D6 -> RB6, D7 -> RB7

RS -> RA0, and EN -> RA1

Circuit Diagram:

For those who want to do this on a protoborad, here is the circuit:

Software:

Note: Never forget to disable the comparator functions on PORTA.0, 1, 2, 3 pins if you are going to use those pins as digital I/O.

/*
* Project name:
     Test LCD in 4-bit mode
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This code demonstrates how to display test message on a LCD which
     is connected to PIC16F628A through PORTB. D4-D7 pins of LCD are
     connected to RB4-RB7, whereas RS and EN pins connected to RA0 and RA1
     respectively.
     MCU:             PIC16F628A
     Oscillator:      XT, 4.0 MHz
*/
// LCD module connections
sbit LCD_RS at RA0_bit;
sbit LCD_EN at RA1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISA0_bit;
sbit LCD_EN_Direction at TRISA1_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections
// Define Messages
char message1[] = "Testing LCD";
char message2[] = "using PIC16F628A";
char message3[] = "Test Successful!";
char message4[] = "2009/09/18";
void main() {
CMCON |= 7;                       // Disable Comparators
Lcd_Init();                        // Initialize LCD
do {
Lcd_Cmd(_LCD_CLEAR);               // Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
Lcd_Out(1,1,message1);             // Write message1 in 1st row
Lcd_Out(2,1,message2);             // Write message1 in 2nd row
Delay_ms(2000);
Lcd_Cmd(_LCD_CLEAR);               // Clear display
Lcd_Out(1,1,message3);             // Write message3 in 1st row
Lcd_Out(2,1,message4);
Delay_ms(2000);
} while(1);
}

Experiment Output Video:

If you don't see any message on the display, try adjusting the contrast level using Contrast Adjustment Potentiometer.

About PIC16F628A

2009-09-17T12:33:00.000-07:00

PIC16F628A is a powerful (200 nanosecond instruction execution) yet easy-to-program (only 35 single word instructions) CMOS FLASH-based 8-bit microcontroller from Microchip. It comes into an 18-pin package and is upwards compatible with the PIC16F628, PIC16C62XA, PIC16C5X and PIC12CXXX devices.

Features:

Operating speeds from DC - 20 MHz
Interrupt capability
35 single word instructions
Internal and external oscillator options
Programmable weak pull-ups on PORTb
16 I/O pins with individual direction control
Analog comparator module with:
- Two analog comparators
- Programmable on-chip voltage reference
(VREF) module
- Selectable internal or external reference
- Comparator outputs are externally accessible
Capture, Compare, PWM module
- 16-bit Capture/Compare
- 10-bit PWM
128 bytes of EEPROM data memory
2K flash program memory
Addressable Universal Synchronous/Asynchronous
Receiver/Transmitter USART/SCI

I/O Ports:
The PIC16F627A/628A/648A have two ports, PORTA and PORTB. Some pins for these I/O ports are multiplexed with alternate functions for the peripheral features on the device.

PORTA Functions

PORTB Functions

Note: While using PORTA pins as Digital Input/Output, always remember to disable the comparator functions on PORTA.0, 1, 2, 3 pins. You can do that by programming the CMCON register = 0x07.

For more detail about PIC16F628A, please read the datasheet from Microchip.

Experiment No. 2 : Push Button and Seven Segment Display Interface

2009-09-13T08:21:00.000-07:00

In this experiment, we will program the PIC16F628A as an UP/DOWN Decade Counter. The count value will be displayed on a Seven-Segment Display and will be incremented/decremented by two push buttons on the board.

Experimental Setup:
The board has built in interface for a multiplexed 4-digit seven segment display (HS-5461AS2 from www.futurlec.com).We will select only one digit by connecting a Digit Select pin to Vcc, as shown in figure below. A black jumper wire is used for this purpose. The seven segments will be driven through PORTB (already wired on the board). Connect Push Buttons (PB3 and PB4) to RA1 and RA0 female headers using jumper wires.

Software:

We will use in-built 'Button Library' to detect push button press.

Here is the complete C program written for mikroC for PIC 2009.

* Project name:

UP/DOWN Decimal Counter with Push Button and 7-Segment Interface

* Copyright:

* Description:

This code is an example of Seven Segment Display and Push Button interface.

A decimal counter value will be displayed on the seven segment display.

The value of the counter can be incremented or decremented through push

buttons.

* Test configuration:

MCU: PIC16F628A

The two push buttons are connected to RA0(Increment) and RA1(Decrement)

and the seven segment display connected to PORTB (Segment a to PB.0,

Segment b to PB.1 and so on)

//-------------- Function to Return mask for common cathode 7-seg. display

unsigned short mask(unsigned short num) {

switch (num) {

case 0 : return 0x3F;

case 1 : return 0x06;

case 2 : return 0x5B;

case 3 : return 0x4F;

case 4 : return 0x66;

case 5 : return 0x6D;

case 6 : return 0x7D;

case 7 : return 0x07;

case 8 : return 0x7F;

case 9 : return 0x6F;

} //case end

}

unsigned int digit; // To Hold Decimal Value

unsigned short number; // To Hold Equivalent Seven Segment Value

void main() {

CMCON |= 7; // Disable Comparators

TRISB = 0x00; // Set PORTB direction to be output

PORTB = 0x00; // Turn OFF LEDs on PORTB

TRISA0_bit = 1; // PA.0 Input for Increment

TRISA1_bit = 1; // PA.1 Input for Decrement

digit = 0; // Initial Value of Counter

number = mask(digit) ;

PORTB = number;

do {

if (Button(&PORTA, 0, 1, 0)) { // Detect logical one to zero

Delay_ms(300);

digit ++; // Increase Counter

number = mask(digit) ;

PORTB = number;

}

if (Button(&PORTA, 1, 1, 0)) { // Detect logical one to zero

Delay_ms(300) ;

digit = digit-1; // Decrease Counter

number = mask(digit) ;

PORTB = number; // Update flag

}

} while(1); // endless loop

}

Experiment Output Video:

PIC microcontrollers: Nebojsa Matic (Free Online Book)

2009-09-09T13:38:00.000-07:00

If you are a beginner to PIC microcontroller, I would recommend you to read this free e-book on PIC16F84 microcontroller. PIC16F84 is one of the most popular PIC family microcontrollers that resembles very much with PIC16F628A.
In this book you will find:

Introduction to microcontrollers

Learn what they are, how they work, and how they can be helpful in your work.

Practical connection samples for Relays, Optocouplers, LCD's, Keys, Digits, A to D Converters, Serial communication etc.
How to write your first program, use of macros, addressing modes...
Instruction Set

Description, sample and purpose for using each instruction...

MPLAB program package

How to install it, how to start the first program, following the program step by step in the simulator...

Ready to read now? Click Here

Experiment No. 1 : 4-Bit Binary Counter

2009-09-09T11:11:00.001-07:00

Experimental Setup:
The first experiment that we are going to do with our PIC16F628A board is a 4-bit binary counter that counts from 0(00h) to 15(0Fh) with 1sec delay between each count. The output will be at RB.0 through RB.3 and will be displayed on 4 LEDs. Use four jumper wires to connect RB.0 through RB.3 to LEDs. The picture below shows these connections.

Figure 1. Jumper Connections for a 4-bit Binary Counter

Software:
Here is the C program written for mikroC for PIC 2009 compiler.

/*
* Project name:
     4-bit Counter
* Copyright:
     (c) Rajendra Bhatt, 2009.
* Description:
     This is a simple 4-bit counter. The output will be displayed on 4 LEDs
     connected to PORT RB.0-RB.3
* Test configuration:
     MCU:             PIC16F628A
     Dev.Board:       PIC16F628A Board
     Oscillator:      XT, 04.0000 MHz

*/
void main() {

TRISB = 0x00;          // set direction to be output
PORTB = 0x00;        // Turn OFF LEDs on PORTB
do {
    Delay_ms(1000);      // 1 second delay
    PORTB ++ ;
} while(PORTB < 0x0F);            // Till PORTB < 15
}

Experiment Output Video:

mikroC PRO for PIC 2009

2009-09-09T11:06:00.000-07:00

mikroC PRO for PIC 2009 is a C compiler for PIC microcontrollers. We are going to use the demo version of this for our PIC board.

Download Here

mikroC PRO for PIC 2009 Manual

Install the Compiler and read the manual before doing experiments.

Read this from Elektor Magazine

Belgrade-based MikroElektronika have recently launched a new C compiler for PIC® microcontrollers: mikroC PRO for PIC 2009. The IDE features project-based design and supports an impressive range of PIC microcontrollers. mikroC PRO for PIC 2009 offers a set of libraries which simplify the initialization and use of PIC MCU and its modules including libraries for ADC, CAN, CANSPI, Compact Flash, EEPROM, Ethernet, Flash Memory, Graphic LCD, I²C, Keypad, LCD, Manchester Code, MMC/SD Card, OneWire, Port Expander, PrintOut, PS/2, PWM, RS-485, Sound, SPI, Graphic LCD, UART, USB HID, Standard ANSI C, T6963C GLCD, Miscellaneous, SPI and more ...

MikroC PRO for PIC also has plenty of practical examples and a comprehensive set of documentation which allows a quick start in programming PIC devices. PIC hardware development tools that completely support mikroC PRO for PIC 2009 are also available. A fully functional demonstration version (hex output is limited to 2k of program words) is available on the mikroElektronika website.

PIC16F628A Development Board

2009-09-02T07:16:00.000-07:00

The development board we are going to make for our experimental microcontroller PIC16F628A will look like this. Here are the features it is going to have:

Access to all I/O pins through female header pins
4 Push Buttons for Input
4 LEDs for Output
An LCD Interface Port
A 4-digit Seven-Segment Display Interface
LCD Backlight Switch and Contrast Adjustment
ICSP Programming (Very Important)

Here is the outline of my design.

Things you need:

A protoboard : I used 116 x 96 mm protoboard from Futurlec.
An 18 pin IC socket for PIC16F628A
A 4.0MHz Crystal
2 22pF capacitors
4 Push Buttons
4 BC547 transistors for multiplexing 4-digit Seven Segment Display
4 Red LEDs
1 Green LED for Power Supply indicator
1 10K Trimmer Potentiometer for LCD Contrast
5 10K resistors
12 220 Ohm resistors
4 4.7K resistors (Driving the base of Multiplexing Transistors)
Connection Header pins Male and Female both as required
A 4-digit common cathode 7-Segment Display (I used 7FR5641AS from Futurlec)
A 2X16 LCD Display Module (Total 16-pins including LED back light)

After you have all these stuff, lets work on the circuit connections. First mark the different areas with a pencil on your protoboard according to the various blocks shown in the outline figure above. We will work one by one.
1. PIC16F628A Power Supply and Crystal Connections

You decide how you gonna supply +5V to the board. I am going to use 4 AAA Size NiCd rechargeable battery for power supply. Use 4.0MHz crystal with two 22pF capacitors. This is a standard circuit for PIC16F628A. Pin 4 should be held high, a low pulse on this pin will reset the PIC. I used a diode in series with 1K resistor to prevent the backward current flow when the programming voltage appears on Pin 4 during ICSP. Remember, Pin 4 of PIC16F628A is used as programming voltage input during ICSP.

2. ICSP Header

ICSP header pins may have different names. I am following what I have got in my PIC Programmer which I bought from mcumall (www.mcumall.com). Connect the ICSP header as shown above.

3. Push Buttons

The standard push button circuit uses a pull up resistor. At normal condition, the output is HIGH (+5V), and when the button is pushed, the output is LOW (GND). I have connected the push button output to female header pin so that I could connect it to any Port of the PIC using a jumper wire. There will be 4 push button circuits like this.

4. 4-Digit Seven Segment Display Interface

4-digit Seven Segment interface will be achieved using multiplexing circuit. I have not connected the Seven Segment Display to the board, rather the circuit is built on the board and the displayy will fit on the 12 pin female headers. I used 7FR5641AS Seven Segment module from Futurlec. The series resistance connected with the seven segments are valued 220 Ohm, and the ones connected to the bases of transistors are 4.7K. Connect a, b, c, d, e, f, g points to PortB.0, B.1, B.2, ..., B.6. Transistors I used were BC547. Connect Aout, Bout, Cout, Dout to a female header pins so that you can later connect to the appropriate PIC port using jumper wires.

5. LED Connection

This is the simplest circuit. Again, the LED connections go to a female header so that it can be connected to the desired port of the PIC using a jumper wire.

6. LCD Interface

I used HD44780 compatible 2x16 LCD panel with backlight. It comes with 16 pin, to which I soldered
16 pin male header. Now place a 16 pin female header on board and connect the pins as shown above. We will use LCD in 4-bit mode to save microcontroller pins. The pins 15 and 16 are Backlight LED pins. I used jumpers to make it ON/OFF.

Here's the complete circuit diagram:

PIC Programmer

I have got a PIC programmer from MCUMALL(www.mcumall.com) named PRG-017 USB PIC programmer. This is a low cost USB based PIC programmer that can be used in Windows Vista platform too. It acquires power from the USB port itself, and works on laptop which has no RS232 serial port. This can program a wide variety of PIC devices. The complete list can be found on the website. The price for this item is $24.99 on their websites, and it comes with a link for software and a USB cable. It has ICSP programming capability but does not come with the cable. I made my own ICSP cable.

Why use the PIC?

2009-09-02T06:07:00.000-07:00

Source: PICmicro MCU C : An introduction to programming the Microchip PIC in CCS C by Nigel Gardner