In this tutorial, we’ll walk through the steps to use an Arduino as a PIC programmer, upload code, and troubleshoot common issues.

Why Use an Arduino to Program PICs?

• Low cost: Any spare Arduino Uno, Nano, or Pro Mini will do.
• Simplicity: Just a handful of jumper wires.
• Flexibility: Works with a wide range of popular 8-bit PIC microcontrollers.
• Open-source: The firmware and host software are freely available and regularly tested.

What You’ll Need

Hardware

• Arduino Uno/Nano/Pro Mini (ATmega328P-based)
• Target PIC microcontroller (e.g., PIC16F1829, PIC12F1840 — see supported list)
• Breadboard or target board with ICSP pins
• Jumper wires
• Optional: 470–1 kΩ resistors (recommended if the target is self-powered or uses 3.3 V logic)
• USB cable for Arduino

Software

• Arduino IDE
• pp3 host utility (from the a-p-prog repo)
• A compiler toolchain for PIC (e.g., MPLAB X + XC8, SDCC) to generate .hex files

Step 1: Wiring Arduino to PIC (ICSP)

The Arduino acts as an ICSP programmer using three main pins:

If your target board is already powered, or runs at 3.3 V, add 470–1 kΩ resistors in series with MCLR/PGC/PGD. This prevents back-power issues.

Step 2: Flash the Arduino Programmer Firmware

1. Clone or download the a-p-prog repository.
2. Open Arduino IDE.
3. Load the sketch from fw/pp/pp.ino.
4. Select your Arduino board and COM port, then Upload.

At this point, your Arduino is no longer a normal Arduino — it’s a PIC programmer.

Step 3: Build the Host Tool

The host software, pp3, runs on your PC and sends commands to the Arduino over USB.

On Linux/macOS:

gcc -Wall pp3.c -o pp3

On Windows (using MinGW):

gcc -Wall pp3.c -o pp3.exe

Or simply use the prebuilt pp3.exe included in the repo.

Keep the file pp3_devices.dat in the same folder as pp3 — it contains the device database.

Step 4: Test Communication

Before flashing your firmware, test if the Arduino can talk to your PIC:

Linux/macOS:

./pp3 -c /dev/ttyACM0 -p -n -t 16f1829

pp3.exe -c COM7 -p -n -t 16f1829

Replace 16f1829 with your target device name.

Expected output:

Opening serial port 
Device ID 0x27E4 
Releasing MCLR

Step 5: Program Your HEX File

Now flash your compiled PIC firmware (firmware.hex).

Linux/macOS:

./pp3 -c /dev/ttyACM0 -t 16f1829 firmware.hex

Windows:

pp3.exe -c COM7 -t 16f1829 firmware.hex

If successful, you’ll see programming and verification messages for FLASH and config memory.

Step 6: Troubleshooting

Problem: Device ID reads 0x0000

• Check wiring (PGC A0, PGD A1, MCLR A3).
• Ensure target power and common ground are connected.
• Try adding a bootloader delay:

pp3.exe -c COM7 -s 1700 -t 16f1829 firmware.hex

Problem: Verify failed

• Add series resistors.
• Shorten jumper wires.
• Confirm the correct device name (-t).

Problem: No COM port

• On Windows, check Device Manager for COM port.
• On Linux/macOS, your device may appear as /dev/ttyUSB0 or /dev/ttyACM0.

Supported PIC Devices

The project supports many 8-bit PIC microcontrollers, including:

• PIC12F1822 / 12F1840 / 12F1501 / 12F1612
• PIC16F1455 / 16F1503 / 16F1507 / 16F1509
• PIC16F1829 (tested extensively)
• And more (see repo for full list)

Tips for Reliable Programming

• Keep your wiring short.
• Always share ground between Arduino and target.
• Use external power for large boards.
• Add -v 1 to -v 4 to increase verbosity for debugging.

Conclusion

Using an Arduino as a PIC programmer is a cost-effective and educational alternative to commercial tools. With just a few jumper wires, the open-source firmware, and the pp3 host utility, you can program many popular PIC microcontrollers right from your computer.

Whether you’re experimenting with PICs for the first time or just need a quick DIY programmer, this method is reliable, flexible, and well-documented by the community.

The post How to Program a PIC Microcontroller Using an Arduino appeared first on Microcontroller Tutorials.

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.

The RETLW Opcode

Lookup tables are possible in assembly primarily because of the RETLW opcode. This instruction means “return with a literal in w” and is used like this:

RETLW 0x04

Here, 0x04 is the literal value placed inside the W register before returning. Since the opcode returns to something, it is usually inside a subroutine.

Take note that RETLW reads the stack for the address to which to return. So a GOTO followed by RETLW will result in a stack underflow error.

Lookup Table Example

The most common lookup table is the one for seven segment displays. Frugal engineers don’t want to use decoders in using seven segment displays and so connect them directly to PIC pins. A lookup table is used to convert the numbers to their equivalent for seven segment displays.

Below is an example table:

table addwf PC
      retlw b’00111111’
      retlw b’00000110’
      retlw b’01011011’
      retlw b’01001111’
      retlw b’01100110’
      retlw b’01101101’
      retlw b’01111100’
      retlw b’00000111’
      retlw b’01111111’
      retlw b’01100111’

The binaries in this code are the seven-segment equivalent for digits zero to nine, assuming a common cathode displays and LSB at segment ‘a’.

Now if I want to display the digit seven (connected to PORTB), for example, I would do it like this:

movlw 0x07
call table
movwf PORTB

What this does is move a literal value 7 to W then call the lookup table. On the table, the value 7 adds to the current value of the program counter which is the first line of the table. The program then jumps 7 lines towards

retlw b’00000111’

The program now returns to the caller with W equal to the seven segment equivalent for the digit 7.

Example Project: Decade Counter

Let’s say we use two seven segment displays to count from zero to ninety-nine. One way to implement this is to assign variables to the ones and tens digits. As the ones digit go past 9, the tens digit increments by one. Using lookup tables make this project easier.

#include <P16F877A.inc>

__CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_OFF & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF

RES_VECT  CODE    0x0000         ; processor reset vector
    GOTO START                   ; go to beginning of program

INT_VECT CODE      0x0004        ; interrupt vector
    GOTO ISR                     ; go to interrupt service routine

MAIN_PROG CODE                      ; let linker place main program

CBLOCK 0x20
    micros
    ones
    tens
    count
ENDC

START
    bsf STATUS,RP0
    movlw 0x00
    movwf TRISB
    movlw 0x00
    movwf TRISC
    movlw 0x07
    movwf OPTION_REG
    bcf STATUS,RP0
    bsf INTCON,GIE
    bsf INTCON,TMR0IE
    clrf ones
    clrf tens
    clrf micros

MAIN
    movlw 0x02
    movwf PORTC
    movf ones, W
    call TABLE
    movwf PORTB
    call DELAY
    movlw 0x01
    movwf PORTC
    movf tens, W
    call TABLE
    movwf PORTB
    call DELAY
    goto MAIN
   
ISR
    bcf INTCON,GIE
    bcf INTCON,TMR0IE
    incf micros,1
    movf micros,0
    sublw 0x0F
    btfsc STATUS,Z
    goto inc_ones
    goto ret
inc_ones
    clrf micros
    incf ones, 1
    movf ones, 0
    sublw 0x0A
    btfsc STATUS,Z
    goto inc_tens
    goto ret
inc_tens
    clrf ones
    incf tens, 1
    movf tens, 0
    sublw 0x0A
    btfsc STATUS,Z
    clrf tens
    goto ret
ret bcf INTCON,TMR0IF
    bsf INTCON,GIE
    bsf INTCON,TMR0IE
    retfie

DELAY
    LOOP DECFSZ count,F
    GOTO LOOP
    RETURN
  
TABLE   addwf PCL
        retlw b'00111111'    ;digit 0
        retlw b'00000110'    ;digit 1
        retlw b'01011011'    ;digit 2
        retlw b'01001111'    ;digit 3
        retlw b'01100110'    ;digit 4
        retlw b'01101101'    ;digit 5
        retlw b'01111101'    ;digit 6
        retlw b'00000111'    ;digit 7
        retlw b'01111111'    ;digit 8
        retlw b'01101111'    ;digit 9    

    END

The post How to Use Lookup Tables in PIC Assembly appeared first on Microcontroller Tutorials.

What is POV?

Persistence of vision (POV) is a technique to reduce the microcontroller pins used without adding extra components. Basically, it’s a form of optical illusion wherein our perception of an object is not as fast as how the object is changing. A basic non-electronic example of POV is how a pencil seemed rubbery when wiggled.

POV With Seven-Segment Displays

I will be using common cathode (CC) seven-segment displays for this tutorial. I believe this is enough to grasp the basics of POV and lay the path for using other devices like sixteen-segment displays, dot matrices, etc.

Recall that a seven-segment display is wired like this:

To light up one segment, the anode of that segment must have a higher voltage than the cathode. Each segment can be assigned to a microcontroller pin and the cathode is connected to the ground.

Numbers are displayed by setting (make high) certain segments. If the wiring connection below is followed, then digit one is displayed when RB.1 and RB.2 of the PIC16F84A are set while the rest are cleared (make low).

Displaying digits 0 to 9 is done by following the table below:

But what if we use more than one seven-segment display? This is where POV comes in handy. The concept is tricking the eye as if two displays are simultaneous although they are actually just alternating.

Consider this connection:

Here we see that the cathodes for the displays are now connected to a pin. The segments for both displays are connected to the same pins! We can turn on the left display if its cathode is low and turn it off if its cathode is high. The same is true for the right display.

Now if we want to display the digit 13 on these two displays, what we do is turn on the left display and turn off the right display. Then, we make the segments display the digit one:

After this, we turn off the left digit and turn on the right digit. Then, we make the segments display the digit three:

Now, we make this loop in a speed that is fast enough to trick the eye that they are simultaneous:

via GIPHY

That’s POV!

Example Project with POV

We can extend this to as many seven-segment displays as our chosen microcontroller can permit. The limiting factor is the number of available pins for the cathode of each display.

In the video above, I used POV to create a digital clock out of six seven-segment displays and one PIC microcontroller. To further reduce the pin count, I used a BCD to seven-segment driver.

The post Persistence of Vision (POV) with Seven-segment Displays appeared first on Microcontroller Tutorials.

Capture Mode

When in capture mode, the value of Timer1 is copied to the CCPRx register when any of these four events happen:

• rising edge on CCP pin
• falling edge on CCP pin
• 4th rising edge on CCP pin
• 16th rising edge on CCP pin

Note that there are two CCP pins, CCP1 on RC2 and CCP2 on RC1. Each CCP pin corresponds to a CCPxCON register:

In short, to capture on CCP1 pin (RC2) use CCP1CON. Otherwise, to capture on CCP2 pin (RC2) use CCP2CON.

To enable capture mode, you must follow these steps:

1. Adjust the value of bits 3 to 0 of CCPxCON register to the desired capture mode: 0100 for every falling edge, 0101 for every rising edge, 0110 for every 4th rising edge and 0111 for every 16th rising edge.
2. Make CCP pin input by setting the corresponding TRISC pin.
3. Read the CCPRx register. Note that both Timer1 and CCPRx registers are 16-bit registers and is subdivided into TMR1H, TMR1L and CCPRxH, CCPRxL respectively.

Here is an example ASM code that captures the Timer1 value and displays it on PORTB:

#include <P16F877A.INC>
    
RES_VECT  CODE    0x0000            ; processor reset vector
    GOTO    START                   ; go to beginning of program

; TODO ADD INTERRUPTS HERE IF USED

MAIN_PROG CODE                      ; let linker place main program

START
    MOVLW b'00000100'
    MOVWF CCP1CON	    ;Capture Mode, every falling edge on RC2
    BSF STATUS,RP0	    ;Bank 1
    BSF TRISC,2		    ;Make RC2 input
    CLRF TRISB		    ;Make PORTB output
    BCF STATUS,RP0	    ;Bank 0
    BSF T1CON,TMR1ON	    ;Turn on Timer1
MAIN
    BTFSS PIR1,CCP1IF
    GOTO MAIN
    MOVF CCPR1L,W
    MOVWF PORTB
    GOTO MAIN

    END

What this code does is capture the value of Timer1 every time a falling edge pulse is detected at RC2. Since Timer1 and consequently, CCPR1, are 16-bit registers, we cannot copy their values to PORTB, which is an 8-bit register. What I did here is just copy the low byte (CCPR1L) to PORTB.

Compare Mode

In compare mode, the CCPR1 value is continuously compared to the Timer1 value. When the CCPR1 value is equal to the Timer1 value, the CCP1 pin (RC2) is either driven low, high or remain unchanged but with other effects. The event on match condition can be set using the same CCP1CON register.

To enable compare mode, follow these steps:

1. Adjust the value of bits 3 to 0 of CCPxCON register to the desired event on match: 1000 to set CCP pin, 1001 to clear CCP pin,  1010 to generate an interrupt and 1011 to start A/D conversion.
2. Make CCP pin output by clearing the corresponding TRISC pin.
3. Load a value to CCPRx register that will be compared to the Timer1 value.

#include <P16F877A.INC>
    
RES_VECT  CODE    0x0000            ; processor reset vector
    GOTO    START                   ; go to beginning of program

; TODO ADD INTERRUPTS HERE IF USED

MAIN_PROG CODE                      ; let linker place main program

START
    MOVLW b'00001000'
    MOVWF CCP1CON	    ;Compare mode, set RC2 on match
    BSF STATUS,RP0	    ;Bank 1
    BCF TRISC,2		    ;Make RC2 output
    BCF STATUS,RP0	    ;Bank 0
    MOVLW 0xFF
    MOVWF CCPR1L            ;Let CCPR1 = 255
    BSF T1CON,TMR1ON	    ;Turn on Timer1
MAIN
    BTFSS PIR1,CCP1IF
    GOTO MAIN               ;Do nothing, wait for match
    BCF PORTC,2             ;Match condition, clear RC2
    END

What this code does is wait for a match between the CCP1RL (equal to 255 in this example) and the Timer1 value. When a match occurs, the RC2 pin should set. In order for us visualize the match again, the RC2 must be cleared after the match occured.

Practical Application of Capture and Compare

One good practical application of capture and compare is pulse counting. While pulse counting can be implemented using Timer0's counter mode, it is limited to 8-bit values. The 16-bit Timer1 value has a higher resolution and thus can count faster pulses.

An article on a frequency counter PIC project will be published detailing the practical application of capture and compare.

The post Capture and Compare with PIC16F877A appeared first on Microcontroller Tutorials.

When using development boards for the first time, it's always a good idea to look at its datasheet first. The Curiosity HPC has four properly-labeled LEDs. But I needed to make sure if they were active low or high. Also, I needed to know if the buttons are normally high or normally low.

The schematic of the development board shows this:

So I've confirmed two things: the LEDs will turn on when I set their corresponding pins and the buttons are normally high.

Controlling the On-Board LEDs

Now I will try to create strobe lights out of the four LEDs on the board. With the older PIC16F877A, I only need to manipulate TRIS and PORT registers to control the output pins of that PIC. However, for newer PICs like the PIC16F18875 on the Curiosity HPC, there is now a LAT short for "latch" register.

Manipulating any pin of the PIC requires the use of the LAT or PORT registers. According to the datasheet, writing a value to a PORT actually writes the value into its LAT register. Meanwhile, reading from a PORT returns a value that is the actual state of the I/O pins. This is a consequence of the pins following the read-modify-write operation: when writing to a PORT, the current states of the pins of that PORT are READ, the read values MODIFIED, and is now WRITTEN to the corresponding LAT register.

The existence of PORT and LAT registers is somewhat vague but I have come to understand it like this: write to LAT, read from PORT.

Another peculiarity is that all pins are now analog by default. The corresponding ANSEL bits should be "0" to make a pin digital. For example, writing "0" to ANSA4 makes RA4 digital.

So let's say we want to flash led D2 which is wired to RA4, this is now the code:

#define _XTAL_FREQ 4000000

#include <xc.h>

void main(void) {
    TRISA4 = 0;           //Make RA4 output
    ANSA4 = 0;            //and a digital I/O pin
    
    while(1){            //Make the flashing endless
        LATA4 = 1;       //Set RA4
        __delay_ms(500); //Half a second delay
        LATA4 = 0;       //Clear RA4
        __delay_ms(500); //Another half-second delay
    }
    return;
}

Here, line 7 is how you would make a pin digital. Writing "1" to LATA4 turns on the LED on RA4 and writing "0" turns it off.

I tried changing LATA4 to RA4 and the LED still flashed. I believe the difference between LAT and PORT will not be obvious here because I only wrote to a port, not read it. What you write to RA4 also becomes the value of LATA4.

Now for the strobe light code, I only needed to modify the code above and now include the rest of the LED pins:

#define _XTAL_FREQ 4000000

#include <xc.h>

void main(void) {
    TRISA4 = 0;
    TRISA5 = 0;
    TRISA6 = 0;
    TRISA7 = 0;
    ANSA4 = 0;
    ANSA5 = 0;
    ANSA6 = 0;
    ANSA7 = 0;
    
    while(1){
        LATA = 0b10000000;
        __delay_ms(500);
        LATA = 0b01000000;
        __delay_ms(500);
        LATA = 0b00100000;
        __delay_ms(500);
        LATA = 0b00010000;
        __delay_ms(500);
    }
    return;
}

Something's Wrong with RA7

The code above flashes the LEDs EXCEPT for RA7! I browsed the PIC16F18875 datasheet and found this:

RA7 is also a digital clock input pin (CLKIN) as seen. Based on experience, CLKIN pins tend to be current sinks by default. This may be the reason why RA7 wasn't able to drive the on-board LED.

More datasheet reading led me to this:

This tells me that if FEXTOSC is set to OFF, then I can now use RA7 just like any other I/O pin.

FEXTOSC is in fact part of the configuration word for the microcontroller. To manipulate it, I needed to view the configuration bits via Run > Configuration Bits. The Configuration Bits window now appears at the bottom:

The first row of the field shows FEXTOSC. I just needed to change this to OFF and click the "Generate Source Code to Output". The Config Bits Source will now appear:

I just then copied this source to my code (right after the #insert <xc.h> line).

After that, RA7 is now flashing along with the other LEDs.

https://gfycat.com/JoyousEssentialKinglet

Using the On-board Buttons

Now that I managed to control the on-board LEDs on the Curiosity HPC, it's time to use the two user buttons. I believe this is now a better setting for describing the difference between PORT and LAT.

Consider the code below:

void main(void) {
    TRISA4 = 0;
    TRISC5 = 1;
    ANSELA = 0;
    ANSELC = 0;
    
    LATC5 = 0;
    while(1){
       if(LATC5 ==  1){
           RA4 = 1;
       }else{
           RA4 = 0;
       }
    }
    return;
}

With this code, RA4 stays on regardless if S2 is pressed or not. Why? because I wrote a "0" to LATC5 and unless I read RC5, that pin will remain "0". LATC5 will never look at the current state of pin RC5. Hence, RA4 will also remain 0.

Now if you tweak the code above to this:

void main(void) {
    TRISA4 = 0;
    TRISC5 = 1;
    ANSELA = 0;
    ANSELC = 0;
    
    RC5 = 0;
    while(1){
       if(RC5 ==  1){
           RA4 = 1;
       }else{
           RA4 = 0;
       }
    }
    return;
}

This time, RA4 will turn on or off if ever I press or depress S2. Even though I wrote "0" to RC5, this bit will always be equal to the current state of the pin. This is how I understood LAT and PORT.

So much for that. Now I will modify my LED strobe code above so that the strobe will change direction if I press S1 or S2. Here's my code:

void main(void) {
    TRISA4 = 0;
    TRISA5 = 0;
    TRISA6 = 0;
    TRISA7 = 0;
    TRISB4 = 1;
    TRISC5 = 1;
    ANSA4 = 0;
    ANSA5 = 0;
    ANSA6 = 0;
    ANSA7 = 0;
    ANSB4 = 0;
    ANSC5 = 0;
    
    while(1){
        if(RB4==0){
            LATA = 0b10000000;
            __delay_ms(500);
            LATA = 0b01000000;
            __delay_ms(500);
            LATA = 0b00100000;
            __delay_ms(500);
            LATA = 0b00010000;
            __delay_ms(500);
        }else if(RC5==0){
            LATA = 0b00010001;
            __delay_ms(500);
            LATA = 0b00100000;
            __delay_ms(500);
            LATA = 0b01000000;
            __delay_ms(500);
            LATA = 0b10000000;
            __delay_ms(500);
        }else{
            LATA = 0x00;
            __delay_ms(500);
            LATA = 0xF0;
            __delay_ms(500);
        }
        
    }
    return;
}

And here's the result of the code above (BTW, sorry for the potato quality gif):

https://gfycat.com/DependableFatHarlequinbug

That's it for using the user LEDs and buttons on the Curiosity HPC board. In my next article, I'll try to explore the mikroBUS slots.

The post Using Buttons and LEDs on the Curiosity HPC appeared first on Microcontroller Tutorials.

The PIC16F877A is a 40-pin (DIP) microcontroller which Microchip describes as powerful based on having a 200 nanosecond instruction speed. It’s old and Microchip itself is not recommending it for new designs but its features and price make it still a popular microcontroller.

PIC16F877A Specs

Here are a few of its specifications:

• Bus width - 8 bits
• Pin Count - 40 (PDIP, SOIC) / 44 (QFN, PLCC, TQFP)
• Program Memory - 14.3 kilobytes
• CPU Speed - 5 million instructions per second
• RAM Size - 368 bytes
• EEPROM Size - 256 bytes

Obviously, the PIC16F877A trumps the PIC16F84A based on the numbers above. But what separates this microcontroller are these features:

• 10-bit, up to 8-channel Analog-to-Digital
  Converter (A/D)
• Synchronous Serial Port (SSP) with SPI
  (Master mode) and I2C (Master/Slave)
• Universal Synchronous Asynchronous Receiver
  Transmitter (USART/SCI) with 9-bit address
  detection

We will discuss each of these features as we continue with this tutorial.

LED Blink Code in Assembly

For now, we will create a simple assembly language program using the PIC16F877A.
The code is very similar to the one using PIC16F84A:

#INCLUDE <P16F877A.INC>
    
 __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_OFF & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
   
RES_VECT  CODE    0x0000            ; processor reset vector
    GOTO    START                   ; go to beginning of program

; TODO ADD INTERRUPTS HERE IF USED

    CBLOCK 0x0C
	COUNT1
	COUNT2
    ENDC
    
MAIN_PROG CODE                      ; let linker place main program

START
    BSF STATUS, RP0
    CLRF TRISB
    BSF TRISA,0
    BCF STATUS, RP0
    
MAIN
    BSF PORTA,0
    CALL DELAY
    BCF PORTA,0
    CALL DELAY
    GOTO MAIN
    
DELAY
LOOP1   DECFSZ COUNT1,1
	GOTO LOOP1
	DECFSZ COUNT2,1
	GOTO LOOP1
	RETURN
	
    END

The code above simply toggles the state of pin RB0. So when an LED is attached to this pin, it will blink. You can simulate this code in Proteus using the schematic diagram below:

Of course, the advantage of using this microcontroller is you can attach a lot more LEDs!

Switch an LED in Assembly

For input using a switch, you can freely use any pin except those that have AN labels. These analog pins including all PORTA and PORTE pins are meant for analog-to-digital conversion and need a bit of additional code to make them digital.

To turn these analog pins to digital, we must write 0x07 or 0x06 to the ADCON1 register. Details about this are found in my analog-to-digital conversion tutorial.

Here’s a code that uses a switch to RA0 to turn on/off a LED:

#INCLUDE <P16F877A.INC>
    
 __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_OFF & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
   
RES_VECT  CODE    0x0000            ; processor reset vector
    GOTO    START                   ; go to beginning of program

; TODO ADD INTERRUPTS HERE IF USED

    CBLOCK 0x0C
	COUNT1
	COUNT2
    ENDC
    
MAIN_PROG CODE                      ; let linker place main program

START
    BSF STATUS, RP0
    CLRF TRISB
    MOVLW 0x07
    MOVWF ADCON1
    MOVLW 0x01
    MOVWF TRISA
    BCF STATUS, RP0
    
MAIN
    BTFSC PORTA,0
    GOTO OFF
    GOTO ON
    GOTO MAIN
    
ON  BSF PORTB,0
    GOTO MAIN  
    
OFF BCF PORTB,0
    GOTO MAIN
    
DELAY
LOOP1   DECFSZ COUNT1,1
	GOTO LOOP1
	DECFSZ COUNT2,1
	GOTO LOOP1
	RETURN
	
    END

Here’s the schematic diagram for the code above:

Those are the basic assembly language programs we can do with the PIC16F877A. Up next, we will look at the features that separate this microcontroller from the PIC16F84A, starting with serial communication.

The post PIC16F877A - More Microcontroller Features appeared first on Microcontroller Tutorials.

Introduction

Water level sensors range from educational to industrial. The most common and frequently seen in stores is this one:

This is a conductive-type water level sensor, where the change in resistance of parallel wires over varying depths of water is converted to voltage. This is not ideal for high precision water level monitoring and is only suitable for hobby projects.

The module has three pins: + (5V), - (GND), and S (Signal). The S pin outputs voltage corresponding to water level.

Wiring Diagram

Connecting the water level sensor to a microcontroller is easy: just connect the S pin to any analog pin. Of course, you must connect the and the + and - pin to power and ground. Here's an example wiring diagram with an Arduino:

Arduino Sketch

The sketch for the water level sensor is also simple:

void setup()
{
	Serial.begin(9600);
}

void loop()
{
	Serial.println(analogRead(A0));
	delay(100);
}

This sketch will display varying numbers on the serial monitor as you vary the depth of the water. You cannot display the actual levels unless you do some actual tests. I suggest you use a calibrated container like this one:

Fill up this container with liquid up to each calibration. Then place the water level sensor, open serial monitor and record the number. Add more water reaching each label on the container then record the number again. Continue doing this until you've filled the container.

PIC XC8 Code

To use this water level sensor with a PIC, we can use the code I created in my PIC ADC tutorial:

#include  // include processor files - each processor file is guarded.  
#include 
#include 
#include 
void Serial_init(const long int baudrate){
    BRGH = 1;
    unsigned int x;
    x = (_XTAL_FREQ /(baudrate*16))-1;
    SPBRG = x;
    SYNC = 0;
    SPEN = 1;
    TRISC7 = 1;
    TRISC6 = 1;
    CREN = 1;
    TXEN = 1;
}
void putch(char data) {
    while(!TRMT);
    TXREG = data;
}
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; //ex 1002
    return adval;
}
void main(void) {
    Serial_init(9600);
    int adval = ADC_read(0); //read analog signal at channel 0
    char buf[5];             //buffer to hold conversion result from integer to string
    itoa(buf, adval, 10);    //convert integer ADC result to string and store to buf
    printf("\rValue: %s\n",buf);  //print through Serial port
    __delay_ms(10);
}

It is assumed that the S pin of the sensor is attached to channel AN0 of the PIC's ADC. Similar to the Arduino example, you still need to do tests and recording to acquire the levels in metric or english units of measurement.

The post Using a Water Level Sensor with Microcontrollers appeared first on Microcontroller Tutorials.

PIR is short for passive infrared which describes how the sensor operates; passive means the device doesn’t emit any energy. Basically, the sensor detects infrared radiation emitted by anything that is warm, including a person.

Most PIR sensors look like this:

This is the HC-SR501 PIR motion sensor. The dome is called a Fresnel lens that focuses the infrared radiation towards the IR sensor in the middle. This is what the module looks like without the dome:

This PIR sensor has a detection range from 100 to 130 degrees and from 3 to 7 meters from the device.

Here’s what the underside looks like:

Here we see the three pins that would be connected to a microcontroller. The DOUT pin toggles high when a warm body is detected within the defined range. It will stay high depending on the time delay and trigger mode settings.

There’s the sensitivity adjust knob that can change the range from a minimum of 3 meters (fully clockwise) or a maximum of 7 meters (full counter-clockwise). The time delay knob adjusts how long will the DOUT pin stays high when the sensor is triggered. The minimum is 3 seconds (fully counter-clockwise) and the maximum is 5 minutes (fully clockwise).

The jumper on the left side sets the trigger mode to either repeatable or non-repeatable. When in repeatable mode, each detection resets the time delay. When in non-repeatable mode, the time delay begins immediately after detection and the next motion will be disregarded. It is worth mentioning that when the DOUT pin goes low after the time delay period, there is a 3 second window in which all motion will not be detected.

Here’s an example timeline if the HC-SR501 PIR sensor is set to non-repeatable mode, with a 3 second time delay:

Here’s an example timeline if the sensor is set to repeatable mode, with the same time delay:

Arduino Implementation

We only need to read the Arduino digital pin to which the DOUT pin of the HC-SR501 is connected to know if a motion is detected. Here’s an example sketch where the DOUT pin is connected to Arduino’s pin 2:

int pirPin = 2; // Input for HC-S501
int pirVal; // Place to store read PIR Value

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);  
}

void loop() {
  pirVal = digitalRead(pirPin);
  if(pirVal){
    Serial.println(“Motion detected!”);
    delay(3000);                                //wait for three seconds 
  }
}

PIC Implementation

A similar code for the PIC using XC8 can be implemented, where the DOUT pin is connected to RB0. Here, an LED connected to RB1 lights up when motion is detected:

#define _XTAL_FREQ 4000000
#include 

int main(){
    TRISB0 = 1;
    TRISB1 = 0;
    while(1){
        if(RB0){
            RB1 = RB0;
            __delay_ms(3000);
        }else{
            RB1 = 0;
        }
    }
}

The post PIR Motion Sensor appeared first on Microcontroller Tutorials.

Introduction

The L298N motor controller follows the H-bridge configuration, which is handy when controlling the direction of rotation of a DC motor. An H-bridge schematic looks like this:

Here, the motor rotates in the direction dictated by the switches. When S1 and S4 are on, the left motor terminal is more positive than the right terminal, and the motor rotates in a certain direction. On the other hand, when S2 and S3 are on, the right motor terminal is more positive than the left motor terminal, making the motor rotate in the other direction.

The other benefit of using an H-bridge is that you can provide a separate power supply to the motors. This is very significant, especially when using an Arduino board where the 5V power source is simply not enough for two DC motors.

The L298N IC

The L298N is an integrated circuit that follows the H-bridge concept. It comes in two IC packages: MultiWatt15 and PowerSO20. Here are the pinouts for each package:

This IC drives two motors through two channels, A and B. For example, if a motor is using channel A, its terminals must be connected to pins Out 1 and Out 2. The Enable A pin must be high to turn on the motor. To drive a motor to a direction, say, clockwise, the pin Input 1 must be high while the pin Input 2 must be low. To drive the motor counterclockwise, the pin Input 1 is low while the pin Input 2 is high.

The diagram above shows an example diagram for using the L298N to drive one DC motor.

Here are the IC's ratings:

The most notable feature here is its high power supply although its input pins follow lower voltage levels. This means you can power high voltage motors while controlling them with microcontrollers.

More information about the L298N IC is found on its datasheet.

For this tutorial, we will be focusing more on the L298N breakout board.

The L298N Motor Controller Board

As already mentioned, the L298N has four inputs corresponding to the four switches in the H-bridge diagram above. All you need to do is apply signals to the inputs to make the motor(s) rotate to a certain direction.

Using a breakout board is easier for prototyping compared to using the IC.

The controller board, shown above, has +12V and +5V terminals. The +12V pin is where the motor power is attached. This pin can accept voltages from +7VDC to +35VDC.

Important note: remove the +12V jumper shown if you are using powers higher than +12V.

When the +12V jumper is attached, the on-board voltage regulator is now enabled, and you can source +5V from the +5V terminal. This means the +5V terminal is not for powering the board but for connecting a device, say Arduino, that needs a 5V source.

You have Motor A inputs and Motor B inputs. These connect to the microcontroller. The motor terminals connect to Motor Terminals 1, 2, 3, 4. Specifically, motor A connects to terminals 1 and 2 while Motor B connects to terminals 3 and 4.

There are also two other jumpers on the board, as shown. Remove these jumpers if you are using DC motors and keep it for stepper motors. Speed control for Motor A and Motor B is achieved via PWM on these pins. More on that later.

Connecting a DC Motor to the L298N Board

Here is a wiring diagram for connecting two DC motors to the L298N driver board.

Using the L298N is straightforward. If you want the left motor to rotate in one direction, apply a high pulse to IN1 and a low pulse to IN2. To reverse the direction, reverse the pulses to IN1 and IN2. The same applies to the right motor.

Here’s a table that summarizes the pins and corresponding motor direction. This assumes you are following the same Fritzing diagram above.

Speed Control?

Speed control is also possible with the L298N motor driver. All you need is to feed PWM signals to the motor-enable pins. The speed of the motor will vary according to the width of the pulses. The wider the pulses, the faster the motor rotates. How fast the motor rotates for a given pulse width will vary from motor to motor even if they look the same. Thus, the actual pulse width must be derived through experiment.

Using the L298N with Arduino

An example diagram for connecting the L298N motor controller board to an Arduino is shown:

You can attach the control pins to any digital (or even analog) pins. However, for motor speed control, the motor enable pins must be attached to a PWM-enabled pin. Here you see that the motor enable pins connect to pin 10 and pin 5, both of which are PWM pins.

Here’s an example Arduino sketch utilizing the diagram above:

//Motor Connections
//Change this if you wish to use another diagram
#define EnA 10
#define EnB 5
#define In1 9
#define In2 8
#define In3 7
#define In4 6


void setup()
{
  // All motor control pins are outputs
  pinMode(EnA, OUTPUT);
  pinMode(EnB, OUTPUT);
  pinMode(In1, OUTPUT);
  pinMode(In2, OUTPUT);
  pinMode(In3, OUTPUT);
  pinMode(In4, OUTPUT);
}
void goStraight()   //run both motors in the same direction
{
  // turn on motor A
  digitalWrite(In1, HIGH);
  digitalWrite(In2, LOW);
  // set speed to 150 out 255
  analogWrite(EnA, 200);
  // turn on motor B
  digitalWrite(In3, HIGH);
  digitalWrite(In4, LOW);
  // set speed to 150 out 255
  analogWrite(EnB, 200);
  delay(2000);
  // now turn off motors
  digitalWrite(In1, LOW);
  digitalWrite(In2, LOW);  
  digitalWrite(In3, LOW);
  digitalWrite(In4, LOW);
}
void loop()
{
  goStraight();
  delay(1000);
}

You can modify this sketch to include a function for going backward, turning left, and turning right. Just follow the table above.

Using the L298N with PIC 

You can also use a PIC microcontroller with the L298N motor controller board. Here is an example diagram using the PIC16F877A:

And here’s an XC8 code that does the same as the Arduino sketch above:

#define _XTAL_FREQ 4000000
#include <xc.h>
#include "pwm.h"


void goStraight(){
    //turn on motor A
    PORTBbits.RB0 = 1;
    PORTBbits.RB1 = 0;
    startPWM(1);     //pulse motor enable A      
    //turn on motor B
    PORTBbits.RB2 = 1;
    PORTBbits.RB3 = 0;
    startPWM(2);     //pulse motor enable B
    __delay_ms(2000);
    PORTBbits.RB0 = 0;
    PORTBbits.RB1 = 0;
    PORTBbits.RB2 = 0;
    PORTBbits.RB3 = 0;
    
}
void main(void) {
    
    TRISBbits.TRISB0 = 0;   //IN1
    TRISBbits.TRISB1 = 0;   //IN2
    TRISBbits.TRISB2 = 0;   //IN3
    TRISBbits.TRISB3 = 0;   //IN4
    initPWM(500, 50, 1);   //initialize PWM at 50% duty cycle, 500 Hz
    while(1){
        goStraight();
        __delay_ms(1000);
    }
    
    return;
}

You might need to read my PWM tutorial for PICs to understand the code above.

I hope you find this tutorial helpful!

The post How to Use L298N Motor Driver appeared first on Microcontroller Tutorials.