A 16x2 monochrome LCD module is a widely used display in microcontroller projects. It can show two lines of text, each up to 16 characters long, making it ideal for simple user interfaces. These LCDs are based on the HD44780 controller (or compatible), which accepts commands and data via an 8-bit or 4-bit parallel interface.

The LCD works by receiving control signals (RS, R/W, E) and data signals (D0–D7 or D4–D7 for 4-bit mode). In this tutorial, we’ll use 8-bit mode for simplicity. The PIC16F84A will send initialization commands to the LCD, followed by ASCII characters to be displayed.

Understanding the control lines:

• RS (Register Select):
  • 0 = Instruction/command (e.g., clear display).
  • 1 = Data (character to display).
• R/W (Read/Write):
  • 0 = Write to LCD.
  • 1 = Read from LCD (rarely needed, we’ll keep it  0.
• E (Enable):
  • A high-to-low pulse latches the data/command into the LCD.

Once initialized, the LCD can display text by sending ASCII codes as data.

Materials

• PIC16F84A microcontroller
• 16x2 HD44780-based monochrome LCD module
• 4 MHz crystal oscillator + 2 × 22pF capacitors
• 10kΩ potentiometer (for LCD contrast adjustment)
• Breadboard and jumper wires
• 5V regulated power supply

Code (Assembly for PIC16F84A)

We’ll walk through the full code, then explain each part.

Full Program

;===========================================================
; Program: LCD 16x2 Display with PIC16F84A
;===========================================================

    list p=16F84A
    include <p16f84a.inc>

    __CONFIG _FOSC_HS & _WDTE_OFF & _PWRTE_ON & _CP_OFF

;-------------------------------
; Pin connections
; LCD Data -> PORTB
; RS -> RA0
; RW -> RA1 (tied low, write only)
; EN -> RA2
;-------------------------------

    cblock 0x20
        temp
    endc

;-------------------------------
; Reset vector
;-------------------------------
    org 0x00
    goto main

;-------------------------------
; Subroutines
;-------------------------------
delay_ms
    movlw   d'250'
    movwf   temp
d1  nop
    nop
    decfsz  temp, f
    goto d1
    return

lcd_pulse
    bsf     PORTA,2      ; E=1
    call    delay_ms
    bcf     PORTA,2      ; E=0
    call    delay_ms
    return

lcd_cmd
    bcf     PORTA,0      ; RS=0
    movwf   PORTB        ; Send command
    call    lcd_pulse
    return

lcd_data
    bsf     PORTA,0      ; RS=1
    movwf   PORTB        ; Send data
    call    lcd_pulse
    return

lcd_init
    ; Function Set: 8-bit, 2 line, 5x8 font
    movlw   0x38
    call    lcd_cmd

    ; Display ON, Cursor OFF
    movlw   0x0C
    call    lcd_cmd

    ; Clear display
    movlw   0x01
    call    lcd_cmd

    ; Entry mode: auto-increment
    movlw   0x06
    call    lcd_cmd
    return

;-------------------------------
; Main Program
;-------------------------------
main
    bsf     STATUS, RP0
    movlw   0x00
    movwf   TRISB       ; PORTB = output
    movlw   0xF8
    movwf   TRISA       ; RA0-RA2 output, RA3-RA4 input
    bcf     STATUS, RP0

    call    lcd_init

    ; Write "HELLO"
    movlw   'H'
    call    lcd_data
    movlw   'E'
    call    lcd_data
    movlw   'L'
    call    lcd_data
    movlw   'L'
    call    lcd_data
    movlw   'O'
    call    lcd_data

endless
    goto endless

    end

Simulate this code in PICSimulator

Code Explanation

1. Configuration and Setup

list p=16F84A
    include <P16F84A.inc>
    __CONFIG _FOSC_HS & _WDTE_OFF & _PWRTE_ON & _CP_OFF

• Sets processor type and includes the register definitions.
• Configures the microcontroller for High-Speed crystal oscillator, watchdog timer off, power-up timer on, and code protection off.

2. LCD Pin Mapping

• PORTB is used for LCD data (D0–D7).
• RA0 = RS, RA1 = R/W (grounded), RA2 = E.
• Only writing to the LCD is needed, so R/W is tied to ground.

3. Delay Routine

delay_ms
    movlw d'250'
    movwf temp
d1: decfsz temp, f
    goto d1
    return

A simple software delay loop to let the LCD process commands.

4. LCD Enable Pulse

lcd_pulse
    bsf PORTA,2   ; E=1
    call delay_ms
    bcf PORTA,2   ; E=0
    call delay_ms
    return

The LCD latches commands/data on the falling edge of E.

5. Sending Commands and Data

lcd_cmd
    bcf PORTA,0   ; RS=0 (command)
    movwf PORTB
    call lcd_pulse
    return

lcd_data
    bsf PORTA,0   ; RS=1 (data)
    movwf PORTB
    call lcd_pulse
    return

These subroutines separate instructions (clear, cursor) from characters (ASCII).

6. LCD Initialization

movlw 0x38   ; Function set: 8-bit, 2-line, 5x8 font
movlw 0x0C   ; Display ON, cursor OFF
movlw 0x01   ; Clear display
movlw 0x06   ; Entry mode: auto-increment

These commands are required at startup to prepare the LCD.

7. Writing Text

movlw 'H'
call lcd_data

Each ASCII character is written sequentially to the LCD.

Conclusion

In this tutorial, we connected a 16x2 monochrome LCD to a PIC16F84A microcontroller using an 8-bit parallel interface. We wrote initialization and display routines in assembly, giving full control of the LCD at a low level.

This project demonstrates how to:

• Initialize the LCD in 8-bit mode.
• Send commands and data separately.
• Display custom strings of text.

With this foundation, you can extend the program to display sensor data, menu options, or real-time feedback for embedded projects.

The post Using a 16x2 Monochrome LCD with the PIC16F84A (Assembly Tutorial) appeared first on Microcontroller Tutorials.

What You’ll Need

• Flame sensor module
• Microcontroller (Arduino or NodeMCU ESP8266 or PIC)
• Power source
• Output device (buzzer or smartphone)

Flame Sensor Module

The star of this project is this flame sensor module:

This module contains a phototransistor and signal conditioning electronics. A phototransistor conducts more electrical current when exposed to light. Physics taught us that (visible) light comprises of all colors, from red to violet. By coating the phototransistor with black epoxy, it becomes more sensitive to red or even invisible below red or infrared. Interestingly, flame emits infrared radiation. Thus, when this sensor sees flame, it conducts more current.

Microcontrollers read voltage, not current. Thus, the signal conditioning circuit in the module converts the current into levels of voltage that is considered safe for the microcontroller (typically, the maximum voltage should be the supply voltage to the microcontroller).

The flame sensor module also contains indicator LEDs. One LED lights up (PWR-LED) when the module is powered up while another lights up (D0-LED) when the sensor detects fire.

Moreover, the voltage from the D0 pin falls to zero in the vicinity of fire and rises to the supply voltage when there is none. We use this as a trigger for the microcontroller.

Arduino - Flame Sensor Interface

I aim to use three different kinds of microcontroller for this project. First, I’ll show how to build an Arduino flame sensor with a buzzer as indicator.

Since the module only provides two values, on and off, we don’t need to use any of the analog pins of the Arduino. The wiring diagram below shows that the D0 pin of the module connects to the digital pin 2 of the Arduino UNO:

Moreover, the VCC or + pin connects to 5V and the G pin is connected to GND. Note that the fire detector module can also run on 3.3V. Finally, the buzzer’s red wire is connected to pin 5 while its black pin is wired to GND. In this project, I am using a buzzer that can run from voltages 3 to 24 V.

The sketch is straightforward:

const int sensor_pin = 2;
const int buzzer = 5;

void setup() {
  pinMode(sensor_pin,INPUT_PULLUP);
  pinMode(buzzer,OUTPUT);
}

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

I gave pins 2 and 5 appropriate aliases:

const int sensor_pin = 2;
const int buzzer = 5;

Inside setup(), we declare sensor_pin as an input pin while buzzer is an output pin:

pinMode(sensor_pin,INPUT_PULLUP);
pinMode(buzzer,OUTPUT);

In loop(), we check if the sensor_pin voltage is zero. If it is, we sound the buzzer. If not, then turn off the buzzer.

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

The fire sensor can detect flame within its 60 degree capture angle. The distance of the flame varies with ambient light. In my tests, the sensor was able to detect a match’s flame from around 5 cm.

Using the Flame Sensor with PIC16F877A

The difference here is that we are using a different microcontroller and thus, a different compiler. Nevertheless, the concept is the same: the PIC16F877A reads the D0 pin and if its low, fire up the buzzer and so on.

Here’s the wiring diagram:

The D0 pin of the fire detector module connects to RB0 while the buzzer’s red wire is connected to RB1.

The C code (XC8) for the circuit above is shown below:

#define _XTAL_FREQ 4000000
#include <xc.h>

void main(void) {
    
    TRISBbits.TRISB0 = 1;
    TRISBbits.TRISB1 = 0;
    while(1){
        if(PORTBbits.RB0 == 0){
            PORTBbits.RB1 = 1;
        }else{
            PORTBbits.RB1 = 0;
        }
    }
    return;
}

The pin RB0 is an input pin while RB1 is an output pin. Hence their corresponding TRIS bits should be:

TRISBbits.TRISB0 = 1; 
TRISBbits.TRISB1 = 0;

We then use simple if-else statements to check if the sensor detects a fire and then turn on or off the buzzer:

while(1){
 if(PORTBbits.RB0 == 0){
    PORTBbits.RB1 = 1; 
 }else{ PORTBbits.RB1 = 0; 
 } 
}

There's no loop() function in XC8 so we create our own infinite loop using the while(1) statement.

That's it for interfacing the flame detector with a PIC microcontroller.

Flame Sensor and ESP8266

Finally we are down to our last microcontroller, the ESP8266. Of course, we will be using the flame sensor with the ESP8266 according to the latter’s capabilities. In this version, the user will receive a push notification on his or her smartphone everytime the fire detector is triggered.

Here’s the wiring diagram:

This diagram is the simplest since we don’t need the buzzer anymore. Note that I am using a NodeMCU ESP8266 board for this project. If this is your first time using the NodeMCU, please follow the instructions to program it using the Arduino IDE.

Here is the full sketch:

/*
 *  This sketch sends push notifications via Pushbullet App through PushingBox.
 *
 *  You need to create a service and scenario at pushingbox.com to acquire
 *  a device ID. Also change lines 12 and 13 to your own WiFi SSID and password
 *
 */
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

const char* host = "api.pushingbox.com";
const char* devid = "vADAB279A6A4DA5A";

const int sensor_pin = 14;

void setup()
{
    pinMode(sensor_pin,INPUT_PULLUP);
    pinMode(buzzer,OUTPUT);
    
    Serial.begin(115200);
    delay(10);

    // We start by connecting to a WiFi network

    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
}

int value = 0;

void loop()
{
    delay(5000);

    if(digitalRead(sensor_pin) == LOW){  //flame sensor triggered

    Serial.print("connecting to ");
    Serial.println(host);

    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
        Serial.println("connection failed");
        return;
    }

    // We now create a URI for the request
    String url = "/pushingbox";
    url += "?devid=";
    url += devid;
    
    Serial.print("Requesting URL: ");
    Serial.println(url);

    // This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
        if (millis() - timeout > 5000) {
            Serial.println(">>> Client Timeout !");
            client.stop();
            return;
        }
    }

    // Read all the lines of the reply from server and print them to Serial
    while(client.available()) {
        String line = client.readStringUntil('\r');
        Serial.print(line);
    }

    Serial.println();
    Serial.println("closing connection");
    }else{;}
}

Before uploading this sketch, we need to configure Pushingbox and Pushbullet for this project to work. 

First, go to Pushingbox and signup or login to your account. You will then be redirected to the Dashboard page:

Click the My Services tab and click “Add a service”:

Next, look for the Pushbullet service:

However, before your press the “Select this service” button, you need to have a Pushbullet account first.

Go to Pushbullet:

Sign up or login to your account. After that, find Settings on the dashboard. There you’ll find your access token:

Go back to Pushingbox, click add a service again and this time click the “Select this service” button for pushbullet. A window appears:

Give the configuration a name, paste your Pushbullet token then click submit.

Next, click the My Scenarios tab to add a scenario linked to the service just created:

After creating the scenario, add an action:

Make sure you select the appropriate scenario:

A window appears; give the action title, push notification message and then click submit.

Finally, copy the device ID whose location is shown:

Now on the sketch, locate line 16 and change the device ID:

const char* devid = "vADAB279A6A4DA5A";

Also, don’t forget to provide your own WiFi’s SSID and password on lines 12 and 13:

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

Upload the sketch and you're good to go! Now, install the Pushbullet app on your smartphone and login to your account. Everytime the fire detector is triggered, you will receive a push notification!

Conclusion

The flame sensor project here is limited in capture angle and range. However, there's a special module that contains five phototransistors:

This 5-way fire detector module has a capture angle of 120°. Check prices here.

Hopefully, this article helps you in any way. For any questions, reactions or suggestions, kindly drop comments below.

The post Flame Sensor Project: Comprehensive Guide appeared first on Microcontroller Tutorials.

Introduction

This a good PIC project for beginners. All that is needed is four LEDs, four buttons and a dual 7 segment display. This project is coded using XC8. Here’s a video of the project simulated on Proteus ISIS:

Materials Needed

• PIC16F877A
• Dual Seven-segment Display - Common Cathode
• 74LS48
• 5 x SPST Pushbuttons
• 4 x LEDs
• 5 x 10k ohm, 1/4 W Resistors
• 5 x 200 ohm, 1/4 W Resistors
• 4 MHz Crystal
• 2 x 22pF Ceramic Capacitor

Schematic Diagram

I wanted to use RB change interrupt for faster reaction time. And since this interrupt triggers via four pins (RB4 to RB7), this project is limited to four buttons and, consequently, four LEDs. More LEDs and more buttons is possible but you can’t use interrupts anymore.

Code

/*
 * File:   catch_the_light.c
 * Author: Roland
 * 
 * Catch the Light Game
 * 
 * 
 * Created on April 19, 2018, 1:02 PM
 */

#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

#define _XTAL_FREQ 4000000
#include <xc.h>

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int rand_num;
int old_rand_num;
int score;
int score_tens;
int score_ones;
int shifter;
int delay;

//a function that varies the delay. Because passing variables to __delay_ms() doesn't work
void someDelay(){
    switch(delay){
        case 500:
            __delay_ms(500);
            break;
        case 200:
            __delay_ms(200);
            break;
        case 100:
            __delay_ms(100);
            break;
        case 50:
            __delay_ms(50);
            break;
    }
    return;
}
void main(void) {
    
    T1CON = 0b00000001;             //turn on TMR1
    INTCON = 0b10101000;            //use global, TMR0 and RB change interrupts
    OPTION_REG = 0b00000100;        //use 1:32 prescale for TMR0
    TRISB = 0xF0;                   //inputs on RB4 to RB7, outputs for RB0 to RB3
    TRISC = 0;                      //all PORTC are outputs
    TRISD = 0;                      //all PORTD are outputs
    
    delay = 500;                    //default delay
   
    loop:
    while(1){
        srand(TMR1);                //use TMR1 value as seed for random
        rand_num = rand() % 9;      //generate random numbers from 0 to 9
        //filter out consecutive numbers, 0 and those that has at least two bits high (011 = 3, 101 = 5, 110 = 6, 111 = 7)
        if(rand_num == old_rand_num || rand_num == 0 || rand_num == 3 || rand_num == 5 || rand_num == 6 || rand_num == 7){ 
            goto loop;
        }
        PORTD = rand_num;           
        old_rand_num = rand_num;    //
        someDelay();                //a function that varies the delay. Because passing variables to __delay_ms() doesn't work 
    }
    
    return;
}

void interrupt isr(void){
    if(TMR0IF){
         //switch digits for every interrupt. Read about POV for better understanding
            shifter++;        
            switch(shifter){
                case 1:
                    PORTB = 0b11111110;
                    PORTC = score_ones;
                    break;
                case 2:
                    PORTB = 0b11111101;
                    PORTC = score_tens;
                    break;
                case 6:
                    shifter = 0;
                    break;
            }
            TMR0IF = 0;     //manual clearing of interrupt flag
    }
    if(RBIF){
        int dummy = PORTB;          //read PORTB to clear mismatch condition
        int masked = (PORTB & 0xF0) >> 4;   //acquire pressed buttons
        if(~masked == (PORTD + 0xFFF0)){
            score++;
            score_tens = score/10;
            score_ones = score - score_tens*10;
            //adjust speed according to score
            if(score <= 5){ 
                delay = 500;
            }else if(score > 5 && score <= 10){
                delay = 200;
            }else if(score > 10 && score <= 20){
                delay = 100;
            }else if(score > 20 && score <= 30){
                delay = 50;
            }else if(score > 99){
                score = 99;
            }else{
                delay = 500;
            }
        }
        RBIF = 0;
    }
}

The post Catch the Light PIC Game appeared first on Microcontroller Tutorials.

Introduction

Materials Needed

• PIC16F877A
• Dual Seven-segment Display - Common Cathode
• Single Seven-segment Display - Common Cathode
• 74LS48 IC
• 5 x SPST Pushbutton
• 5 x 10k ohm, 1/4 W Resistors
• 4 MHz Crystal
• 2 x 22p Ceramic Capacitor

Schematic Diagram

One 2-digit common cathode 7-segment display is used to count the customer number while 1 7-segment display is used to indicate the current counter. To prevent debounce on the button, I added some delays after each button press. You may need to push the button for about half a second to update the displays

Code

/*
 * File:   e_queue.c
 * Author: Roland
 * XC8 Code for Electronic Queuing System
 * Published on Teach Me Microcontrollers!
 * Created on April 13, 2018, 3:36 PM
 */

#define _XTAL_FREQ 4000000
#include <xc.h>

int count_ones;
int count_tens;
int count_val;
int counter_no;
int shifter = 0;
int dummy;

void main(void) {
    TRISB = 0b11111000;
    TRISC = 0;
    TRISD = 0;
    OPTION_REG = 0b00000100;
    INTCON = 0b10101000;
    PORTB = 0;
    PORTD = 0;
    
    while(1){;}
    
    return;
}

void updateValue(void){
     count_val++;
     count_tens = count_val/10;
     count_ones = count_val - 10*count_tens;
}
void interrupt isr(void){
    if(RBIF){
        __delay_ms(200);
       
   
        dummy = PORTB;   
        if(RB4==0){
            __delay_ms(200);
           // if(RB4==0){
                counter_no = 1;
                updateValue();
           // }
        }
        if(RB5==0){
            __delay_ms(200);
           // if(RB5==0){
             counter_no = 2;
             updateValue();
           // }
        }
        if(RB6==0){
            __delay_ms(200);
           // if(RB6==0){
             counter_no = 3;
             updateValue();
           // }
        }
        if(RB7==0){
            __delay_ms(200);
           // if(RB7==0){
             counter_no = 4;
             updateValue();
           // }
        }
        RBIF = 0;   //manual clearing of interrupt flag
    }
    
     if(TMR0IF){
            //switch digits for every interrupt. Read about POV for better understanding
            shifter++;        
            switch(shifter){
                case 1:
                    PORTC = 0b11111011;
                    PORTD = counter_no;
                    break;
                case 2:
                    PORTC = 0b11111101;
                    PORTD = count_ones;
                    break;
                case 3:
                    PORTC = 0b11111110;
                    PORTD = count_tens;
                    break;
                case 4:
                    shifter = 0;
                    break;
            }
            TMR0IF = 0;     //manual clearing of interrupt flag
    }
}

The buttons are attached to RB4 to RB7 so that I can use RB change interrupt. The POV shifting on the displays is done through timer overflow interrupt. You might need to change the prescale value via the OPTION register if you can still see the shifting between digits.

In XC8, multiple interrupts can be implemented by simply checking the corresponding interrupt flag bit. Here I checked the RBIF flag to check if the buttons RB4 to RB7 were pressed and the TMR0IF flag for shifting the digits in POV.

Design Files

Feel free to download the design files for this electronic queuing system project:

If this was useful to you, a simple thanks through the comments would suffice!

The post Electronic Queuing System appeared first on Microcontroller Tutorials.

This adjustable timer displays seconds, minutes, and hours and is powered by a PIC16F 877A microcontroller. There are five buttons included: start/stop, up for incrementing digits, down for decrementing digits, and left and right for moving between digits during adjustment. I’ve included a relay circuit that will trigger when the timer is finished.

Introduction

Schematic Diagram

I wanted to use the least amount of components possible but I also don’t want to make the code too long. Thus, I settled to use one decoder even if it’s possible not to use one. The POV refresh rate is based on timer0 overflow with x32 prescale. This is using a 4 MHz crystal oscillator. Adjust the prescale through the OPTION register if you are using other oscillator frequencies.

Code

/*
 * File:   timer_relay.c
 * Author: Roland Pelayo
 * For Adjustable Timer with Relay Project
 * See full tutorial at: https://www.teachmemicro.com/adjustable-timer-relay
 * Created on April 5, 2018, 11:25 AM
 */

#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

#define _XTAL_FREQ 4000000
#include <xc.h>

//structs for the digits
struct _digits{
    int ones;
    int tens;
};
struct timer{
    struct _digits digits;          //a struct within a struct just because I wanted to :)
};

//declare struct objects for every tick
struct timer seconds = {9,5};
struct timer minutes = {9,5};
struct timer hours = {9,5};
//declare struct objects for updating
struct timer set_seconds = {9,5};
struct timer set_minutes = {9,5};
struct timer set_hours = {9,5};

bit start_timer;    //flag for starting or stopping the timer
int counter = 0;    //used for counting up/down digits during time adjustment
int shifter = 0;    //used for shifting digits left and right during time adjustment

int dummy;          //used to clear mismatch for RB Change interrupt

//Function for updating time every tick
void runTime(void){
     RB1 = !RB1;                    //make the dots blink for every tick
            seconds.digits.ones--;
            if(seconds.digits.ones < 0){
                seconds.digits.tens--;
                seconds.digits.ones = 9;
                if(seconds.digits.tens < 0){
                    minutes.digits.ones--;
                    minutes.digits.tens = 6;
                    if(minutes.digits.ones < 0){
                        minutes.digits.tens--;
                        minutes.digits.ones = 9;
                        if(minutes.digits.tens < 0){
                            hours.digits.ones--;
                            minutes.digits.tens = 6;
                            if(hours.digits.ones < 0){
                                hours.digits.tens--;
                                hours.digits.ones = 9;
                            }
                        }
                    }
                }
            }
            if(seconds.digits.ones == 0 && seconds.digits.tens == 0 && minutes.digits.ones == 0 && minutes.digits.tens == 0 && hours.digits.ones == 0 && hours.digits.tens == 0){
                RB2 = 1;
                start_timer = 0;
            }       
           set_seconds.digits.ones = seconds.digits.ones;
           set_seconds.digits.tens = seconds.digits.tens;
           set_minutes.digits.ones = minutes.digits.ones;
           set_minutes.digits.tens = minutes.digits.tens;
           set_hours.digits.ones = hours.digits.ones;
           set_hours.digits.tens = hours.digits.tens;
}

//Function for adjusting time
void adjustTime(int direction, int position){
    if(direction == 0){
        //decrement the digits for every button press
        switch(position){
            case 0:
                set_seconds.digits.ones--;
                if(set_seconds.digits.ones < 0){
                   set_seconds.digits.ones = 9;
                }
                break;
            case 1:
                set_seconds.digits.tens--;
                if(set_seconds.digits.tens < 0){
                   set_seconds.digits.tens = 5;
                }
                break;
            case 2:
                set_minutes.digits.ones--;
                if(set_minutes.digits.ones < 0){
                   set_minutes.digits.ones = 9;
                }
                break;
            case 3:
                set_minutes.digits.tens--;
                if(set_minutes.digits.tens < 0){
                   set_minutes.digits.tens = 5;
                }
                break;
            case 4:
                set_hours.digits.ones--;
                if(set_hours.digits.ones < 0){
                   set_hours.digits.ones = 9;
                }
                break;
            case 5:
                set_hours.digits.tens--;
                if(set_hours.digits.tens < 0){
                   set_hours.digits.tens = 9;
                }
                break;
        }
    }else{
       //increment the digits for every button press
       switch(position){
            case 0:
                set_seconds.digits.ones++;
                if(set_seconds.digits.ones > 9){
                   set_seconds.digits.ones = 0;
                }
                break;
            case 1:
                set_seconds.digits.tens++;
                if(set_seconds.digits.tens > 5){
                   set_seconds.digits.tens = 0;
                }
                break;
            case 2:
                set_minutes.digits.ones++;
                if(set_minutes.digits.ones > 9){
                   set_minutes.digits.ones = 0;
                }
                break;
            case 3:
                set_minutes.digits.tens++;
                if(set_minutes.digits.tens > 5){
                   set_minutes.digits.tens = 0;
                }
                break;
            case 4:
                set_hours.digits.ones++;
                if(set_hours.digits.ones > 9){
                   set_hours.digits.ones = 0;
                }
                break;
            case 5:
                set_hours.digits.tens++;
                if(set_hours.digits.tens > 9){
                   set_hours.digits.tens = 0;
                }
                break;
        } 
    }
}

//Function for checking buttons for adjusting time
void checkButtons(){
    __delay_ms(200);
    if(!RB3){
        shifter++;
        if(shifter > 5) shifter = 0;
    }else if(!RB7){
        shifter--;
        if(shifter < 0) shifter = 5;
    }else if(!RB5){
        adjustTime(1, shifter);     
    }else if(!RB6){
        adjustTime(0, shifter);
    }else{;}
    
    //the updating digits must be the same as the adjusted digits
    switch(shifter){
        case 0:
            seconds.digits.ones = set_seconds.digits.ones;
            break;
        case 1:
            seconds.digits.tens = set_seconds.digits.tens;
            break;
        case 2:
            minutes.digits.ones = set_minutes.digits.ones;
            break;
        case 3:
            minutes.digits.tens = set_minutes.digits.tens;
            break;
        case 4:
            hours.digits.ones = set_hours.digits.ones;
            break;
        case 5:
            hours.digits.tens = set_hours.digits.tens;
            break;
    }
}
void main(void) {
    INTCON = 0b10101000;        //Use RB Change interrupt
    OPTION_REG = 0b00000100;    //      Prescale 
    TRISB = 0b11111000;         //RB1, RB2 outputs, RB3-RB7 inputs
    TRISC = 0;                  //All PORTC output
    TRISD = 0;                  //All PORTD output
    RB2 = 0;                    //relay pin is initialized as cleared
    PORTC = 0;                  //initialize PORTC and PORTD as cleared
    PORTD = 0;
    
    while(1){  
        //When Start/Stop is pressed, the start_timer variable is toggled
        
        //Start Timer
        while(start_timer){
            __delay_ms(1000);   //ticks every second
            runTime();          //update digits per the specified delay above
        }
        
        //Stop/Pause Timer
        while(!start_timer){
            checkButtons();    //adjust time
        }
    }
    return;
}

//Function to turn on the dot as indicator of the digit currently adjusting
void setDot(void){
    if(!start_timer){
        if(shifter == counter-1){
            RB1 = 1;
        }else{
            RB1 = 0;
        }
    }                
}

//Interrupt service routine: The interrupts used are RB Change and Timer Interrupt. The shifting of digits is done every time
// timer0 overflows. The RB change interrupt is used for starting and stopping the timer.
void interrupt isr(void){
    //RB Change interrupt is triggered
    if(RBIF){
        dummy = PORTB;   
        if(!RB4){
            if(!start_timer){
                start_timer = 1;
            }else{
                start_timer = 0;
            }
        }
        RBIF = 0;   //manual clearing of interrupt flag
    }
    //Timer Overflow interrupt is triggered
    if(TMR0IF){
            //switch digits for every interrupt. Read about POV for better understanding
            counter++;        
            switch(counter){
                case 1:
                    PORTC = 0b11011111;
                    PORTD = seconds.digits.ones;
                    setDot();
                    break;
                case 2:
                    PORTC = 0b11101111;
                    PORTD = seconds.digits.tens;
                    setDot();
                    break;
                case 3:
                    PORTC = 0b11110111;
                    PORTD = minutes.digits.ones;
                    setDot();
                    break;
                case 4:
                    PORTC = 0b11111011;
                    PORTD = minutes.digits.tens;
                    setDot();
                    break;
                case 5:
                    PORTC = 0b11111101;
                    PORTD = hours.digits.ones;
                    setDot();
                    break;
                case 6:
                    PORTC = 0b11111110;
                    PORTD = hours.digits.tens;
                    setDot();
                    break;
                case 7:
                    counter = 0;
                    break;
            }
            TMR0IF = 0;     //manual clearing of interrupt flag
    }
}

The project was coded using Microchip XC8. There are some peculiarities with my code, especially the use of structs. You can actually remove the structs and just use simple variables. I just find the structs more readable given the number of variables I had to use.

I used two interrupts in this code: timer overflow and RB change interrupt. The timer overflow interrupt is used for POV while the RB change interrupt is responsible for starting or stopping the timer. The adjustments are not done with interrupts but by simple button testing. The debounce problem is handled by a delay after every button pressed.

The post Adjustable Timer with Relay appeared first on Microcontroller Tutorials.

Introduction

A temperature sensor is a fairly common microcontroller project. The sensing device in this project is a LM35 integrated circuit that gives 10mV per degree celsius and can detect from 0 degree celsius to 100 degree celsius.

The PIC16F877A microcontroller used in this project has 10-bit ADC and a minimum sensible voltage of 4.88 mV. This means the conversion factor for the LM35 should be 10mV/2.88mV or 2.046. This value is used in the code to convert the ADC value to temperature in degree celsius.

The Nokia 3310 LCD uses SPI for interfacing with a microcontroller. I’ve created two libraries for the PIC16F877A to communicate with this LCD and is included in the downloadable design files.

Materials Needed

• PIC16F877A
• Nokia 3310/5110 LCD Breakout Board
• LM35
• 4.7 uF Mylar Capacitor
• SPST Pushbutton
• 4 MHz Crystal
• 2 x 22pF Ceramic Capacitor

Schematic Diagram

This project was tested and simulated using Proteus ISIS. You will need the Nokia 3310 LCD Proteus library to do your own simulations.

Code

/*
 * File:   nokia_thermometer.c
 * Author: Roland Pelayo
 * For Digital Thermometer with Nokia LCD Project
 * 
 * Created on April 4, 2018, 3:55 PM
 */

#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

#define _XTAL_FREQ 20000000
#include <xc.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "pcd8544.h"

int temp = 0;

unsigned int ADC_read(int channel){
    ADFM = 1; //results right justified
    ADCS0 = 0; //conversion speed = 4*Tosc
    ADCS1 = 0;
    ADCS2 = 1;
    ADCON0bits.CHS = channel;  
    ADON = 1; //turn on ADC
    __delay_ms(1);  
    GO_DONE = 1;
    while(ADCON0bits.GO_DONE == 1);
    unsigned int adval = (ADRESH << 8) + ADRESL; //
    return adval;
}

void main(void) {
    lcdBegin();                //initialize LCD
    lcdClear();                //clear LCD screen
    lcdCursor(0, 0);           //place cursor at x=0,y=0
    lcdPrint("Temperature: ");
    while(1){
        int adval = ADC_read(0); //read signal from LM35
        char buf[5];             //buffer to hold ADC value
        itoa(buf, adval/2.046, 10);    //convert integer (now in celsius) to string
        lcdCursor(25, 2);              //place cursor at x=25,y=2
        lcdPrint(buf);                 //print temperature value
        lcdPrint("  C");              
        __delay_ms(1000);              //some delay
    }
    return;
}

As mentioned, this project requires two libraries, pcd8544.h and SPI.h, to work. They are included in the downloadable files.

The signal from the LM35 is easily converted to readable data using analog to digital conversion. In my code, the reading is done every second. You can adjust the delay for the code according to your needs.

The post Digital Thermometer with Nokia 3310 LCD appeared first on Microcontroller Tutorials.

Introduction

A stepper motor requires pulses in specific pattern to move or “step”. Generally, there are three ways to move a stepper motor.

• Half-step - a single wire is set high while the others are set low. The pulsed wires are alternated to make a full revolution
• Full-step - two wires are set high simultaneously while the others are set low. The paired wires are alternated to make a full revolution.
• Microstepping - half-step and full-step patterns are combined to make finer movements.

This project uses microstepping as it is the most commonly used stepping method.

Materials Needed

• PIC16F877A
• Unipolar 6-wire Stepper Motor
• 5 x SPST pushbuttons
• 4 x BC547 NPN transistor
• 5 x 10k 1/4 W resistor
• 4 MHz crystal
• 2 x 22pF ceramic capacitor

Schematic Diagram

The schematic diagram for the stepper motor controller is shown below:

Basically, each of the wires of the stepper motor is connected to a transistor switch to allow more current through the motor. A pulse from the microcontroller turns on a transistor and effectively shorts the connected wire to ground. Since the common pin is tied to the positive supply (which is separate from the microcontroller supply), the microcontroller pin must be low to make a stepper motor wire high.

I’ve included LEDs to have a visual representation of the stepping patterns. Obviously, omitting them will not have any adverse effect on the project’s performance.

Lastly, the choice of transistor depends on the current draw of your chosen stepper motor. For larger stepper motors, I suggest using darlington pairs.

Code

/*
 * File:   stepper.c
 * Author: Roland Pelayo
 * For Stepper Motor Controller Project published on Teach Me Microcontrollers!
 * Created on April 4, 2018, 1:28 PM
 */
#pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)

#define _XTAL_FREQ 4000000
#include <xc.h>

int mode;         //1 = forward ; 0 = reverse
int ready;        //1 = stop ; 0 = start
int dummy;

//Main Routine
void main(void) {
    
    ready = 1;       //motor is stopped by default;
    TRISB = 0xF0;    //RB4, RB5, RB6, RB7 pins are input
    TRISD = 0;       //all PORTD pins are output
    INTCON = 0x88;   //global interrupts enabled, RB port change interrupt enabled
    PORTB = 0;       //initialize PORTB pins to cleared
    PORTD = 0;       //initialize PORTD pins to cleared
    
    while(1){
        if(ready==0){
            if(mode==1){          //forward direction
                PORTD = 0b11110110;
                __delay_ms(500);
                PORTD = 0b11111110;
                __delay_ms(500);
                PORTD = 0b11111100;
                __delay_ms(500);
                PORTD = 0b11111101;
                __delay_ms(500);
                PORTD = 0b11111001;
                __delay_ms(500);
                PORTD = 0b11111011;
                __delay_ms(500);
                PORTD = 0b11110011;
                __delay_ms(500);
            }         
            if(mode==0){        //reverse direction
                PORTD = 0b11110111;
                __delay_ms(500);
                PORTD = 0b11110011;
                __delay_ms(500);
                PORTD = 0b11111011;
                __delay_ms(500);
                PORTD = 0b11111001;
                __delay_ms(500);
                PORTD = 0b11111101;
                __delay_ms(500);
                PORTD = 0b11111100;
                __delay_ms(500);  
                PORTD = 0b11111110;
                __delay_ms(500);
                PORTD = 0b11110110;
                __delay_ms(500);
            }
      }
    }
    return;
}

//Interrupt Service Routine
void interrupt isr(void){
    if(RBIF){           //check RB change interrupt flag if triggered
      dummy = PORTB;    //read PORTB to clear mismatch condition
      if(!RB6){         //stop button pressed?
          ready = 1;
      }else if(!RB7){   //start button pressed?
          ready = 0;
      }else if(!RB5){   //forward button pressed?
          mode = 0;
      }else if(!RB4){   //reverse button pressed?
          mode = 1;
      }else{;}
    }
    RBIF = 0;
}

The four buttons are purposely tied to RB4, RB5, RB6 and RB7 because I wanted to use RB change interrupt. This allows me to change the stepper motor behavior even if the motor is currently turning. Using an interrupt with buttons also diminishes debounce problems. If you’re having problems understanding the code, kindly refer to my interrupt tutorial.

The post PIC16F877A Stepper Motor Controller appeared first on Microcontroller Tutorials.