PIC18F4550 LCD Interfacing in CCS PICC

A character LCD traditional built with a controller inside especially the HD44780. It's easy to control with some basic LCD instruction. For more technical details and programming interface for this type of LCD controller click here to view. Character LCD are available from as single to multiple lines and multiple characters.

x2

x1.5

x1

x0.5

00:00 / 00:00

• Pause
• Unmute
• Fullscreen
• Fluid Player 3.51.0

A running Program

In CCS PIC an LCD software driver is ready to use in side the compiler. The LCD.C driver could control a character LCD only for two line character LCD. Within this driver there are a lot of functions lists below.

1. lcd_init() - must be called before calling other function
2. lcd_putc() - send one character to LCD
3. lcd_gotoxy(x,y) - set write position on LCD, start from 1,1
4. lcd_getc(x,y) - return character at the position x,y on  LCD
5. lcd_cursor_on(int1 on) - turn on cursor
6. lcd_set_cgram_char(w,*p) - write custom character to CGRAM

In this example, the LCD prints the duration of MCU started up time. The C printf function could be use to send the character to LCD by adding the LCD_PUTC stream to this function.

	#include<18f4550.h>
	/*Use high speed clock no PLL prescaler
	no system clock post scaler */
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20M)
	#define LCD_ENABLE_PIN PIN_B2
	#define LCD_RS_PIN PIN_B0
	#define LCD_RW_PIN PIN_B1
	#define LCD_DATA4 PIN_B4
	#define LCD_DATA5 PIN_B5
	#define LCD_DATA6 PIN_B6
	#define LCD_DATA7 PIN_B7
	#include<lcd.c>
	void main(){
	char secondCount=0;
	lcd_init();
	//First Line
	lcd_gotoxy(1,1);
	//Send characters to LCD
	printf(LCD_PUTC,"Power Up Time:");
	while(1){
	//Second Line
	lcd_gotoxy(1,2);
	//Send character to LCD
	printf(LCD_PUTC,"%u seconds ",secondCount);
	delay_ms(1000);
	secondCount++;
	}
	}

view raw lcdExample.c hosted with ❤ by GitHub

Click here to download this example in zip file.

Schematic Diagram

ADC vs Analog Voltage Displaying with PIC18F4550 in CCS PICC

In previous posts, I have shown about using the ADC module of PIC18F4550 programming, and LCD programming interface in CCS PICC. 

In this post, I use PIC18F4550 to read two analog input channels. A character LCD as used in the previous post displays the value of ADC reading of each channel and its analog voltage value. However, here I use the full 10-bit ADC resolution of this device.

ADC reading and its value displaying

Source code from GitHub gist:

	#include<18f4550.h>
	#device ADC=10
	/*Use high speed clock no PLL prescaler
	no system clock post scaler */
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20M)
	#define LCD_ENABLE_PIN PIN_B2
	#define LCD_RS_PIN PIN_B0
	#define LCD_RW_PIN PIN_B1
	#define LCD_DATA4 PIN_B4
	#define LCD_DATA5 PIN_B5
	#define LCD_DATA6 PIN_B6
	#define LCD_DATA7 PIN_B7
	#include<lcd.c>
	void adcConfig(void){
	//RA0 AND RA1 As Input
	set_tris_a(0x03);
	//PORTD as output
	set_tris_d(0x00);
	//Set RA0 To Analog
	setup_adc_ports(AN0_TO_AN1);
	//Select ADC internal RC Clock
	setup_adc(ADC_CLOCK_INTERNAL);
	}
	int16 getAnalog(char channel){
	set_adc_channel(channel);
	delay_ms(1);
	int16 analogValue=read_adc();
	while(!adc_done());
	return analogValue;
	}
	void main(){
	float voltage;
	int16 adcValue;
	lcd_init();
	adcConfig();
	while(1){
	lcd_gotoxy(1,1);
	adcValue=getAnalog(0);
	voltage=(adcValue*5.0)/1024;
	printf(LCD_PUTC,"AN0: %Lu %.2fV ",adcValue,voltage);
	lcd_gotoxy(1,2);
	adcValue=getAnalog(1);
	voltage=(adcValue*5.0)/1024;
	printf(LCD_PUTC,"AN1: %Lu %.2fV ",adcValue,voltage);
	delay_ms(500);
	}
	}

view raw adcLcd.c hosted with ❤ by GitHub

Click here to download zip file of this example.

Schematic Diagram

LM35 and LCD Temperature Displaying with PIC18F4550 in CCS PICC

Referring to ADC module of PIC18F4550, there are many analog output sensor to interfaces with this MCU. LM35 is a simple analog temperature sensor, creating analog voltage output representing its temperature conversion in degree Celsius. The step temperature from this device is 10 mV per degree Celsius. I don't want to put all its details here. For more information about using this device, please see this post.

In this post, LM35 connects to AN2 analog channel of the ADC. The MCU reads the analog voltage, converting it to temperature value in both degree Celsius and degree Fahrenheit.

A temperature reading of 31.2 degree Celsius.

A very simple LM35 comes in a transistor-like TO-92 package.

LM35DZ in TO-92 package.

C source code fed from GitHub.

	#include<18f4550.h>
	#device ADC=10
	/*Use high speed clock no PLL prescaler
	no system clock post scaler */
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20M)
	#define LCD_ENABLE_PIN PIN_B2
	#define LCD_RS_PIN PIN_B0
	#define LCD_RW_PIN PIN_B1
	#define LCD_DATA4 PIN_B4
	#define LCD_DATA5 PIN_B5
	#define LCD_DATA6 PIN_B6
	#define LCD_DATA7 PIN_B7
	#include<lcd.c>
	void adcConfig(void){
	//RA3 As Input
	set_tris_a(0x04);
	//PORTD as output
	set_tris_d(0x00);
	//Set RA0...RA2 To Analog
	setup_adc_ports(AN0_TO_AN2);
	//Select ADC internal RC Clock
	setup_adc(ADC_CLOCK_INTERNAL);
	}
	float getTemperature(void){
	set_adc_channel(2);
	delay_ms(1);
	int16 analogValue=read_adc();
	while(!adc_done());
	float temperature = (analogValue*5.0)/1024;
	temperature*=100;
	return temperature;
	}
	void main(){
	float temp;
	lcd_init();
	adcConfig();
	while(1){
	lcd_gotoXy(1,1);
	printf(LCD_PUTC,"LM35 Temperature");
	lcd_gotoXy(1,2);
	temp=getTemperature();
	printf(LCD_PUTC,"%0.1f%cC %0.1f%cF ",temp,223,((temp*1.8)+32),223);
	delay_ms(250);
	}
	}

view raw lm35Lcd.c hosted with ❤ by GitHub

Click here to download the zip file of this example.

Schematic Diagram

PIC18F4550 PWM Example in CCS PICC

Overview

Creating a varied analog voltage output from an MCU require an analog voltage generator, PWM (pulse width modulation). Making a analog voltage PWM to work, the user needs to know about all relevant register configurations to set the frequency and duty cycle of PWM signal.

However, in a high level embedded language, creating a PWM signal output doesn't need a deep level of low level hardware/register configuration. With a few C functions, the PWM signal output from any MCU could be created in a few minutes.

CCS PICC Basic Pulse Width Modulation Programming

Without using any technical detail of PWM software setting, we can create a PWM output from scratch with this compiler. In this introductory example, I use only a few C code to program the PWM.

1. #use PWM directive
2. pwm_set_duty_percent()

The directive #use PWM has many options, but I list a few commonly use options of this.

• CCPx or PWMx - Select a CCP/PWM module
• FREQUENCY=x - Set the frequency of PWM signal
• PERIOD=x - Set the period of PWM signal
• DUTY=x - The default duty cycle is 50% if it's not set.

For more details about this directive, check the compiler manual.

The pwm_set_duty_percent specifies the duty cycle of PWM output signal. The syntax is pwm_set_duty_percent(stream,value). Where stream is optional, and value is ranges from 0 to 1000. For example when value = 500, the PWM duty cycle is 50% and so on.

In this introductory example, I set a fixed frequency of PWM and a variable duty cycle. Duty cycle is adjusted by the variation of a POT. CCP1 is selected to make the PWM signal.

I adjust the POT to the MAX.

C Source Code

	#include <18F4550.h>
	#device ADC=10
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20000000)
	#use PWM(CCP1,FREQUENCY=10K,DUTY=0)
	#define LCD_ENABLE_PIN PIN_B2
	#define LCD_RS_PIN PIN_B0
	#define LCD_RW_PIN PIN_B1
	#define LCD_DATA4 PIN_B4
	#define LCD_DATA5 PIN_B5
	#define LCD_DATA6 PIN_B6
	#define LCD_DATA7 PIN_B7
	#include<lcd.c>
	void adcSetUp(void){
	set_tris_a(0x01);
	//Set RA0 To Analog
	setup_adc_ports(AN0);
	//Select ADC internal RC Clock
	setup_adc(ADC_CLOCK_INTERNAL);
	//Select channel 0 for conversion
	}
	void main(void){
	unsigned long temp;
	lcd_init();
	adcSetUp();
	lcd_gotoxy(1,1);
	printf(LCD_PUTC,"PWM EXAMPLE");
	while(1){
	/*Set PWM Duty Cycle*/
	set_adc_channel(0);
	delay_ms(1);
	temp=read_adc();
	while(!adc_done());
	/*Convert from 1024 to 1000*/
	temp=(temp*1000.0)/1024;
	pwm_set_duty_percent(temp);
	lcd_gotoXy(1,2);
	printf(LCD_PUTC,"Duty Cycle %0.2f ",(float)(temp/10.0));
	delay_ms(10);
	}
	}

view raw pwm_example_1.c hosted with ❤ by GitHub

Schematic 

Schematic Diagram

Click here to download this example in zip file.

PIC18F4550 ADC Simple Digital Volt Meter

The ADC module of PIC18F4550 could read an analog input voltage up to 5 V DC with some DC offset. However, the outside analog voltage fed to the ADC could be greater than 5 V DC by adding a simple voltage divider circuit. 

The voltage divider circuit is very simple, built by two resistors in this case. The output voltage from the divider circuit is smaller than the input according to the dividing factor. The factor created by picking up a different resistances of the selected's. The designer may decide and take a little math calculation using voltage divider theorem to get a specific division factor. 

I don't show the overall process of math calculation here. You can see this post to get a full detail.

The MCU reads the analog input voltage fed to RA0.

PICC Source Code

	#include<18f4550.h>
	#device ADC=10
	/*Use high speed clock no PLL prescaler
	no system clock post scaler */
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20M)
	#define LCD_ENABLE_PIN PIN_B2
	#define LCD_RS_PIN PIN_B0
	#define LCD_RW_PIN PIN_B1
	#define LCD_DATA4 PIN_B4
	#define LCD_DATA5 PIN_B5
	#define LCD_DATA6 PIN_B6
	#define LCD_DATA7 PIN_B7
	#include<lcd.c>
	void adcConfig(void){
	//RA0 As Input
	set_tris_a(0x01);
	//Set RA0 To Analog
	setup_adc_ports(AN0);
	//Select ADC internal RC Clock
	setup_adc(ADC_CLOCK_INTERNAL);
	set_adc_channel(0);
	delay_ms(10);
	}
	float getVoltage(void){
	int16 analogValue=read_adc();
	while(!adc_done());
	float voltage = (analogValue*5.0)/1024;
	/*Voltage Divider*/
	voltage*=0.11;
	/*Scale Up*/
	voltage*=100;
	return voltage;
	}
	void main(){
	float voltage;
	lcd_init();
	adcConfig();
	while(1){
	lcd_gotoXy(1,1);
	printf(LCD_PUTC,"Voltage Reading");
	lcd_gotoXy(1,2);
	voltage=getVoltage();
	printf(LCD_PUTC,"%0.2f Volts ",voltage);
	delay_ms(250);
	}
	}

view raw simpleDvm.c hosted with ❤ by GitHub

Schematic Diagram

Schematic Diagram

Click here to download the zip file of this example.

If you want a standard PCB for ATMega32 micro-controller, you can order my AVR Microcontroller project from PCBWay with a reasonable price. Click here to get a free $5 credit for new account.

ATMega16 ATMega32 Experiment Board PCB from PCBWay

 

PIC18F4550 DS1307 I2C RTC LCD Interfacing

PIC18F4550 has a master synchronous serial ports (MSSP) module inside. This module consist of two sub-communication modules - I2C and SPI. An I2C is communication protocol for short range, low data rate requires only two pins - Serial Data(SDA) and Serial Clock(SCL). However, the SPI communication port doesn't lists here.

DS1307 is a real time clock keeper with I2C communication interface. This device keep the time running by an external crystal clock of 32.768 kHz. Even the supply voltage is off, a coin back up battery keep the data RAM synchronizes for future use. Since an I2C is use for communication, there are two communication pins - SDA and SCL. These two pins are open drain, require an individual external pull up resistor. The resistor ranges from 4.7 kOhm to 10 kOhm resistance.

For more technical details about DS1307, please see this post on another blog I wrote.

In this programming example, PIC18F4550 uses its I2C master to write and read timing data from DS1307 I2C slave device. Those data will display on a character display.

Circuit Simulation

PICC Source Code

	#include<18f4550.h>
	/*Use high speed clock no PLL prescaler
	no system clock post scaler */
	#fuses HS,PLL1,CPUDIV1
	#use delay(clock=20M)
	#use i2c(MASTER,SDA=PIN_B0,SCL=PIN_B1,fast=10000)
	#define LCD_ENABLE_PIN PIN_D2
	#define LCD_RS_PIN PIN_D0
	#define LCD_RW_PIN PIN_D1
	#define LCD_DATA4 PIN_D4
	#define LCD_DATA5 PIN_D5
	#define LCD_DATA6 PIN_D6
	#define LCD_DATA7 PIN_D7
	#include<lcd.c>
	void rtcControl(char address,char control){
	i2c_start();
	i2c_write(0xD0);
	i2c_write(address);
	i2c_write(control);
	i2c_stop();
	}
	char rtcGet(char address){
	char dataRam;
	i2c_start();
	i2c_write(0xD0);
	i2c_write(address);
	i2c_stop();
	i2c_start();
	i2c_write(0xD1);
	dataRam=i2c_read(FALSE);
	i2c_stop();
	return dataRam;
	}
	char myDay[3];
	void dayOfWeek(char _day){
	switch(_day){
	case 1: myDay="Sun"; break;
	case 2: myDay="Mon"; break;
	case 3: myDay="Tue"; break;
	case 4: myDay="Wed"; break;
	case 5: myDay="Thu"; break;
	case 6: myDay="Fri"; break;
	case 7: myDay="Sat"; break;
	}
	}
	void main(){
	char s,m,h;
	char _day,_date,_month,_years;
	lcd_init();
	/*Enable 1 second output pin*/
	rtcControl(0x07,0x10);
	while(1){
	s=rtcGet(0x00);
	m=rtcGet(0x01);
	h=rtcGet(0x02);
	_day=rtcGet(0x03);
	_date=rtcGet(0x04);
	_month=rtcGet(0x05);
	_years=rtcGet(0x06);
	/*get day of week in string format*/
	dayOfWeek(_day);
	lcd_gotoxy(1,1);
	printf(LCD_PUTC,"%x:%x:%x %s",h,m,s,myDay);
	lcd_gotoxy(1,2);
	printf(LCD_PUTC,"%x/%x/20%x",_month,_date,_years);
	delay_ms(500);
	}
	}

view raw ds1307Lcd.c hosted with ❤ by GitHub

Schematic Diagram

Schematic Diagram

Click here to download the zip file of this example.

A DIY TWI LCD Using PCF8574AP For Arduino

A character LCD with a 44780 LCD controller generally controlled by an MCU parallel port. Even the data transfer in-used is 4-bit mode, but it still require up to six MCU pins. 

A character LCD with PCF8574AP

PCF8574AP is an 8-bit general purpose digital I/O expanding. We can read and write digital data between this device and a master MCU, or even controlling a parallel LCD module. However using an I2C IC bridge the master MCU uses only two pins of its digital I/O to interface to the LCD.

In online market the PCF8574AP is built in module the a character LCD that cost a few Dollars. For an electronics hobbyist like me, I only bought a single DIP version of this chip. I can program it to read/write digital data before I decide to put it with a character LCD.

I decided to make my own I2C board module for my Arduino Uno board. This design follows the liquidCrystal_I2C LCD library from an author on GitHub. The overall design is not difference from the original one's but I made my own schematic and PCB design for my personal use.

I use Eagle CAD from Auto Desk software due to its richness of symbols and footprints library. The result yield with a small rectangular PCB module wired with PCF8574AP and a character LCD.

Schematic Diagram

PCB View

This design example is fully worked as I have tested it with Arduino Uno using its library.

A zip file of this design could be download here.

Connection Diagram

 

This Arduino sketch is from the library itself with some of my own modification.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// set the LCD address to 0x38 for PCF8574A with A0 A1 A2 wired to GND
LiquidCrystal_I2C lcd(0x38,16,2); 
void setup()
{
  // initialize the lcd
  lcd.init();                     
  lcd.backlight();
  lcd.clear();
  Serial.begin(9600);
  lcd.setCursor(0,0);
  lcd.print("Serial Port LCD");
}

void loop()
{
  // when characters arrive over the serial port...
  if (Serial.available()) {
    // wait a bit for the entire message to arrive
    delay(100);
    // clear the screen
    lcd.clear();
    // read all the available characters
    while (Serial.available() > 0) {
      // display each character to the LCD
      lcd.write(Serial.read());
    }
  }
}

This sketch could be download here, or you can get from the library after the installation.