STM32F3 Microcontroller

GPIO Applications
27/02/2014

Dr. Cuauhtmoc Carbajal

1

Agenda

3V-5V interfacing
STM32F3 Electrical Characteristics
I/O Device Categories
GPIO Interfacing to External Devices

The need for interfacing between 3V

and 5V systems

Many reasons exist to introduce 3V systems, notably the

lower power consumption for mobile applications and the
introduction of parts that use technologies with such fine
geometries that 5V is simply not allowed any more.
There is a gradual transition from 5V to 3V, since not always
are all required components available, or the system is
rather complex so that 3V is introduced in part of a system.
Because many devices still are 5V devices, and most modern
sensors, displays, and flash cards are 3V-only, many makers
find that they need to perform level shifting/conversion.
We obviously want a reliable signal transfer from the 5V
system to the 3V system and vice versa. This implies that the
output voltages should be such that the input levels are
satisfied.
3

The need for interfacing

Interfaces Between a 3V Microcontroller and 5V Systems

4

Noise margins
Important characteristics are:
VIHmin min value input recognized as a 1
VOHmin min value of output generated as a 1
VILmax max value of input recognized as a 0
VOLmax max value of output generated as a 0
Values outside the given range are not allowed.

TTL and CMOS Switching Levels

Digital circuits normally come in two versions:
TTL levels: VIL = 0.8V, VIH = 2.0V
CMOS levels: VIL= 0.3*VCC, VIH = 0.7*VCC.

Level Shifting
5V to 3V
All 5V families have an output voltage
swing that is large enough to drive 3V
reliably. Outputs may be as high as
3.5V for many TTL output stages, to
the full 5V for many CMOS outputs.
Therefore, as far as switching levels
are concerned, there are no problems
in interfacing from 5V to a 3V system.

3V to 5V
All 3V logic families deliver practically
the full output voltage swing of 3V, so
they can drive TTL switching levels
without problems.
However, a 3V system cannot reliably
drive a 5V one that has CMOS input
levels, even when using pull-up
resistors.
7

Voltage level conversion methods

Discrete
You can do voltage level conversion using discrete
bipolar transistors.
The circuit shown converts from a voltage swing of
0-3V to a voltage swing of 0-5V.
The resistor values may have to be modified
depending on the switching speed required. At the
same time, the resistor connected to the collector
should be as large as possible in low power
applications, since static current will be drawn when
the output from the circuit is low.
Also note that this circuit inverts, i.e. it will drive the
output low when the input is high and vice versa.
You can use the same circuit with an NMOS, but in
this case you do not need a resistor in series with
the gate. Make sure that you select a transistor with
an appropriate threshold voltage.
http://www.daycounter.com/Circuits/Level-Translators/Level-Translators.phtml

Voltage level conversion methods

Passive voltage divider
If you are only concerned with avoiding
violation of the absolute maximum
ratings of the 3V circuit, you can use a
resistor voltage divider to divide down
the 5V signal to 3V. With an appropriate
choice of resistors, this will work fine, but
it will draw static current all the time.
Typical resistor values for the figure
below can be R1=22k, R2=33k. If the
5V device has a low enough threshold
voltage that it will function with a 3V
input voltage, this can be a good
approach for bi-directional signals, as the
voltage divider only divides down the
voltage in one direction.
Note: Can work on bi-directional signals if
5V system has low enough threshold
voltage (VIH5V<VOH3V)

Voltage level conversion methods

Dual VCC level shifters

The 74LVC4245 and 74ALVC164245 ( 8
and 16 bits resp.) are CMOS transceivers
fed from both 3V and 5V supplies. The
level shifting is done internally and the
parts have full output voltage swings at
both sides, making them ideal for level
shifting purposes, especially when
driving 5V CMOS levels.
Dual VCC level shifters are superior
alternatives to the sometimes used input
pull-up resistors, blocking diodes and
other circuits that normally degrade
speed and/or noise margins.
Only problem is that they are only good
in one direction which can be a problem
for some specialty bi-directional
interfaces and also makes wiring a little
hairy.
swra071.pdf

10

Voltage level conversion methods

Logic Level Converter BOB-08745

It safely steps down 5V signals to 3.3V
and steps up 3.3V to 5V. This level
converter also works with 2.8V and
1.8V devices. Each level converter has
the capability of converting 4 pins on
the high side to 4 pins on the low side.
Two inputs and two outputs are
provided for each side.
Can be used with normal serial, I2C,
SPI, and any other digital signal. It does
not work with an analog signal.

https://www.sparkfun.com/products/8745
http://www.adafruit.com/datasheets/BSS138.pdf

11

Voltage level conversion methods

8-channel Bi-directional Logic
Level Converter - TXB0108

3V side

5V side

This chip perform bidirectional

level shifting from pretty much
any voltage to any voltage and
will auto-detect the direction.
Only thing that doesn't work well
with this chip is i2c (because it
uses strong pullups which confuse
auto-direction sensor).
If you need to use pullups, you
can but they should be at least
50K ohm - the ones internal to
the STM32F3 are about 100K ohm
so those are OK!

http://www.adafruit.com/products/395
http://www.ti.com/lit/ds/symlink/txb0108.pdf

12

Voltage level conversion methods

ULN2003A are high-voltage
high -current Darlington
transistor arrays. It consists of
seven NPN Darlington pairs
that feature high-voltage
outputs with common-cathode
clamp diodes for switching
inductive loads.
The collector-current rating of
a single Darlington pair is 500
mA.
The Darlington pairs can be
paralleled for higher current
capability.

parasitic
diode

13

Voltage level conversion methods

ULN2003A applications include relay drivers, hammer drivers, lamp

drivers, display drivers (LED and gas discharge), line drivers, and logic
buffers.

Interfaces With High-Current Output Buffers ULN2003

14

Voltage level conversion methods

Optocoupler
It can be used to control a
circuit that is completely
isolated from your uC.
In this case, imagine that
the LED and battery pack
are a hacked toy which
you're turning on and off
with the uC.

http://www.siongboon.com/projects/2006-06-19_switch/

4N28

15

STM32F3
I/O structure

Free I/O
5V tolerant I/O

PIN
PA0
PA1
PA2
PA3
PA4
PA5
PA6
PA7
PA8
PA9
PA10
PA11
PA12
PA13
PA14
PA15

Str
TTa
TTa
TTa
TTa
TTa
TTa
TTa
TTa
FT
FTf
FTf
FT
FT
FT
FTf
FTf

PIN
PB0
PB1
PB2
PB3
PB4
PB5
PB6
PB7
PB8
PB9
PB10
PB11
PB12
PB13
PB14
PB15

Str
TTa
TTa
TTa
FT
FT
FT
FTf
FTf
FTf
FTf
TTa
TTa
TTa
TTa
TTa
TTa

PIN
PC0
PC1
PC2
PC3
PC4
PC5
PC6
PC7
PC8
PC9
PC10
PC11
PC12
PC13
PC14
PC15

Str
TTa
TTa
TTa
TTa
TTa
TTa
FT
FT
FT
FT
FT
FT
FT
TC
TC
TC

PIN
PD0
PD1
PD2
PD3
PD4
PD5
PD6
PD7
PD8
PD9
PD10
PD11
PD12
PD13
PD14
PD15

Str
FT
FT
FT
FT
FT
FT
FT
FT
TTa
TTa
TTa
TTa
TTa
TTa
TTa
TTa

PIN
PE0
PE1
PE2
PE3
PE4
PE5
PE6
PE7
PE8
PE9
PE10
PE11
PE12
PE13
PE14
PE15

Str
FT
FT
FT
FT
FT
FT
FT
TTa
TTa
TTa
TTa
TTa
TTa
TTa
TTa
TTa

PIN
PF0
PF1
PF2
PF3
PF4
PF5
PF6
PF7
PF8
PF9
PF10
PF11
PF12
PF13
PF14
PF15

Str
FT
FT
TTa
TTa
FTf

FT
FT

Fast mode: up to 400 kHz

Fast mode plus: up to 1 MHz

16

STM32F3 Absolute maximum ratings

Voltage Characteristics

STM32F3DISCOVERY BOARD:
VSS : 0 volts
VDD: 3 volts

17

STM32F3 Absolute maximum ratings

Current characteristics

18

I/O port characteristics

General input/output characteristics

19

I/O port characteristics

Output voltage characteristics

20

I/O Device Categories

Input devices
Sensors, User-input

Output devices
Actuators, Displays

Complex I/O devices (printers, faxes,

coprocessors, etc.)
Analog I/O issues

Voltage levels
Current draw
Sampling frequency
Noise

Digital I/O issues

- Voltage levels
- Synchronization
- Throughput
- Noise
21

Input Examples
Sensors

light
force
sound
position
orientation
proximity
tactile
temperature
pressure
humidity
speed
acceleration
displacement

User input

keyboards
joysticks
mouse
keypad
switches
touchpad
dial
slider

22

Output Examples
Actuators
motors
solenoids
relays
heaters
lights
piezoelectric materials
(buzzers, linear actuator)
speakers

Displays

LED displays
LCD displays
CRT displays
indicator lights
indicator gauges

23

Interfacing with LED Devices

The figure below suggests three methods for interfacing with

LEDs.
Circuit (a) and (b) are recommended for LEDs that need only small
current to light.
Circuit (c) is recommended for LEDs that need larger current to
light.

VOL, min = 0.15V

An LED connected to a CMOS inverter through a current-limiting resistor

24

 LED

http://www.farnell.com/datasheets/553533.pdf

74HC04

http://www.farnell.com/datasheets/1645614.pdf
25

Example: Use PC[7:0] to drive eight LEDs using the circuit

shown in the Figure below. Light each LED for half a second in
turn and repeat assuming the GPIOC has a 72-MHz clock.
STM32

390

To turn on one LED at a time for half a second in turn, one should output the
value $80, $40, $20, $10, $08,$04,$02, and $01 and stay for half a second in
each value.

26
26

The C language version of the program is as follows:

#include "stm32f30x.h"
void delaybyms(unsigned int j);
int main(void) {
unsigned char led_tab[] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01,
0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
char i=0;
RCC->AHBENR

|= RCC_AHBENR_GPIOCEN; // Enable GPIOC clock

// PC[7:0] configuration
GPIOC->MODER
= GPIOC->MODER
GPIOC->OTYPER = GPIOC->OTYPER
GPIOC->OSPEEDR = GPIOC->OSPEEDR
GPIOC->PUPDR
= GPIOC->PUPDR

&
&
&
&

0xFFFF0000 | 0x00005555; // 0b01: Output

0xFFFFFF00;
// 0b0 : PP (R)
0xFFFF0000 | 0x0000FFFF; // 0b11: 50MHz
0xFFFF0000;
// 0b00: no PU/PD (R)

while (1) {
for (i = 0; i < 16; i++) {
GPIOC->ODR = GPIOC->ODR & 0xFFFFFF00 | led_tab[i];
msdelay(500);
}
}
}
void delaybyms(unsigned int j) {
unsigned int k,l;
for(k=0;k<j;k++)
for(l=0;l<1427;l++);
}

gpio_test.c
27

STM32F3DISCOVERY BOARD: SCHEMATIC DETAIL

http://homepage.cem.itesm.mx/carbajal/Microcontrollers/RESOURCES/STM32F3DISCOVERY/stm32f3discovery_sch/MB1035.pdf

28

Driving a Single Seven-Segment

Display

A common cathode seven-segment display is driven by the 74HC244 via resistors.

The output high voltage of the 74HC244 is close to 3V with a 3V power supply.
The segment patterns for 0 to 9 are shown in the table below.
STM32

390

VF = 1.8V
IF = 2mA

TDSL1150

Driving a single seven-segment display

BCD to seven-segment decoder
29

Driving Multiple Seven-Segment Displays

Time multiplexing
technique is often used
to drive multiple
displays in order to save
I/O pins.
One parallel port is used
to drive the segment
pattern and the other
port turns on one
display at a time. Each
display is turned on and
then off many times
within a second. The
persistence of vision
make us feel that all
displays are turned on
simultaneously.

STM32

Port C and Port D together drive six seven-segment display

30
30

Example: Write a sequence of instructions to display 4 on the seven-segment

display #4 in the figure above.
Solution: To display the digit 4 on the display #4, we need to:
Output the hex value $33 to port C
Set the PD4 pin to 1
Clear pins PD5 and PD3...PD0 to 0
In C language:
// Configure PC[6:0] & PD[5:0] as GP output + PP
GPIOC->ODR = GPIOD->ODR & 0xFFFFFF80 | 0x33;
GPIOD->ODR = GPIOD->ODR & 0xFFFFFFC0 | 0x10;

31
31

Example: Write a program to display 123456 on the six

seven-segment displays shown in the figure below.
Solution: Display 123456 on display #5, #4, #3, #2, #1,
and #0, respectively.
The values to be output to Port C and Port D to display
one digit at a time is shown in the table below.

Table of display patterns for this example

32

Time-multiplexed seven-segment display algorithm

33
33

int main (void)

{
char disp_tab[6][2] = {{0x30,0x20},{0x6D,0x10},{0x79,0x08},
{0x33,0x04},{0x5B,0x02},{0x5F,0x01}};
char i;
// configure PC[6:0] for output
// configure PD[5:0] for output
while (1) {
for (i = 0; i < 6; i++) {
// output the segment pattern
GPIOC->ODR = GPIOC->ODR & 0xFFFFFF80 | disp_tab[i][0];
// turn on the display
GPIOD->ODR = GPIOD->ODR & 0xFFFFFFC0 | disp_tab[i][1];
delaybyms(1);
}
}
}

34
34

Stepper Motor Control (1 of 7)

It is digital in nature and provides high degree of
control.
In its simplest form, a stepper motor has a permanent
magnet rotor and a stator consisting of two coils. The
rotor aligns with the stator coil that is energized.
By changing the coil that is energized, the rotor is
turned.
Next four figures illustrate how the rotor rotates
clockwise in full step.
http://homepage.cem.itesm.mx/carbajal/Microcontrollers/ASSIGNMENTS/labs/pas.swf

35
35

Stepper Motor Control (2 of 7)

Stepper motor full step 1

Stepper motor full step 2

Stepper motor clockwise rotation in full step (1 of 2)

36
36

Stepper Motor Control (3 of 7)

Stepper motor full step 3

Stepper motor full step 4

Stepper motor clockwise rotation in full step (2 of 2)

37
37

Stepper Motor Control (4 of 7)

Next figure illustrates how the rotor rotates
counter-clockwise in full step.

Full-step counter-clockwise operation of step motor

38

Stepper Motor Control (5 of 7)

In a four-pole stepper motor shown before, a full step is 90
degrees.
The stepper motor may also operate with half step. A half
step occurs when the rotor (in a four-pole step) is moved to
eight discrete positions (45).
To operate the stepper motor in half steps, sometimes both
coils may have to be on at the same time. When two coils in
close proximity are energized, there is a resultant magnetic
field whose center will depend on the relative strengths of the
two magnetic fields.
The next figure illustrates the half-stepping sequence.

39
39

Stepper Motor Control (6 of 7)

Half-step operation of the stepper motor

40

Stepper Motor Control (7 of 7)

The actual stator of a real motor has more segments than
previously indicated. One example is shown in the next
figure. The step sizes of the stepper motors may vary from
approximately 0.72 to 90. The most common step sizes
are 1.8, 7.5, and 15.

Actual internal construction of stepper motor

41
41

Stepper Motor Drivers (1 of 4)

Driving a step motor involves applying a series of voltages to the coils of the motor.
A subset of coils is energized at a time to cause the motor to rotate one step. The
pattern of coils energized must be followed exactly for the motor to work correctly.
A microcontroller can easily time the duration that the coil is energized, and
control the speed of the stepper motor in a precise manner.
The circuit in the figure below shows how the transistors are used to switch the
current to each of the four coils of the stepper motor.
The diodes in figure below are called fly back diodes and are used to protect the
transistors from reverse bias.
The transistor loads are the windings in the stepper motor. The windings are
inductors, storing energy in a magnetic field.
When the current is cut off, the inductor dispenses its stored energy in the form of
an electric current.
This current attempts to flow through the transistor, reversely biasing its collectoremitter pair. The diodes are placed to prevent this current from going through the
transistors.

42

Stepper Motor Drivers (2 of 4)

Driving the stepper motor

43

Stepper Motor Drivers (3 of 4)

The normal full-step sequence

should be used for high-torque
applications.
For lower-torque applications
the half-step mode is used.
The microcontroller outputs the
voltage pattern in the sequence
shown in these tables.
The tables are circular. The
values may be output in the
order as shown in the table,
which will rotate the motor
clockwise; or in the reverse
order, which will rotate the
motor counterclockwise.
A delay of about 5 to 15ms is
required between two steps to
prevent motor from missing
steps.

Full-step sequence for clockwise rotation

Half-step sequence for clockwise rotation

44

Stepper Motor Drivers (4 of 4)

Example: Assuming that pins PP3...PP0 are used to drive the four transistor in the
figure above, write a subroutine to rotate the stepper motor clockwise one cycle using
the half-step sequence.
#include
Solution:
<stm32f30x.h>
const unsigned char sequence[] = {0x05,0x01,0x09,0x08,0x0A,0x02,0x04,0x06};
int main( void ) {
unsigned int i,j;
// Configure GPIOC[3:0] as output, PP, high speed, no pullup/pulldown
RCC->AHBENR
|= 0x00080000; // Activating GPIOC clock source
GPIOC->MODER
|= 0x00000055; // Configuring GPIOC[3:0] as outputs
GPIOC->OSPEEDR &= 0xFFFFFFAA; // Selecting low-speed on GPIOC[3:0]
while (1) {
for (i=0;i<8;i++) {
GPIOC->ODR = sequence[i]; // Sequence number output
for ( j=0;j<10000;j++ ); // Delay loop
}
}
}

45

Interfacing with DIP Switches (1 of 2)

Switches are often grouped together. It is most
common to have four or eight switches in a DIP
package.
DIP switches are often used to provide setup
information to the microcontroller. After power is
turned on, the microcontroller reads the settings of the
DIP switches and performs accordingly.
STM32F3
RPULL-UP=RPULL-DOWN=40k

Connecting a set of eight DIP switches to port D of the MCU

46

Interfacing with DIP Switches (2 of 2)

Example Write a sequence of instructions to read the value
from an eight-switch DIP connected to GPIOD of the STM32
into accumulator A.
Solution
In C language
void main () {
char xx;
RCC->AHBENR |= 1 << 20;
GPIOD->MODER &= 0xFFFF0000;
GPIOD->PUPDR |= 0x00005555;
xx = GPIOD->IDR & 0x000000FF;
}

//
//
//
//

Enable GPIOD clock

PD[7:0] as input (reset value)
Pull-up resistors
clean value

47

Hardware
Debouncing Techniques

VDD
Set

Reset

Set

Reset

R
(a) Set-reset latch

SR latches
Non-inverting CMOS
gates
Integrating debouncer

VDD

4050

Vout

(b) CMOS gate debouncer

VDD
R
Vout
C

H
Threshold level
L
Switch closed

(c) Integrating RC circuit debouncer

Figure 7.42 Hardware debouncing techniques

48
48

Software Debouncing Technique

The most popular and simple one has been
the wait and see method.
In this method, the program simply waits for
about 10 ms and reexamines the same key again
to see if it is still pressed.

49

Interfacing the MCU to a Keypad

A keypad usually consists of 12 to 24 keys and is adequate for many applications.

Like a keyboard, a keypad also needs debouncing.
A 16-key keypad can be easily interfaced to one of the MCU parallel ports.
A circuit that interfaces a 16-key keypad is shown in the figure below (left). Note:
pins PC[7:4] each control four keys.

Sixteen-key keypad row selections

Sixteen-key keypad connected to the MCU

50

GPIOC->IDR
GPIOC->MODER

keypad_dir = (keypad_dir &0xFFFF0000) | 0x00005500; // Configure lower bits[3:0] as input, bits[7:4] as output

GPIOC->ODR &= rmask; // select the current row

Adapted from The HCS12/9S12: An Introduction to Software and Hardware Interfacing, HUANG (2010)

51

Example: Write a C program to read a character from the keypad shown in the figure
above.
This program will perform keypad scanning, debouncing, and ASCII code lookup.
Solution:
void delaybyms (unsigned int); // prototype
char get_key (void) {
RCC->AHBENR |= 1 << 19; // Enable GPIOC clock
GPIOC->MODER |= 0x5500; // configure PC[7:4] for output and PC[3:0] for input
while (1) {
GPIOC->ODR = 0xE0;

// prepare to scan the row controlled by PC4

if (!(GPIOC->IDR & 0x01)) {

delaybyms (10);
if (!(GPIOC->IDR & 0x01))
return 0x30; // return ASCII code of 0
}
if (!(GPIOC->IDR & 0x02)) {
delaybyms (10):
if (!(GPIOC->IDR & 0x02))
return 0x31; // return ASCII code of 1
}
52

if (!(GPIOC->IDR & 0x04)) {

delaytbyms (10);
if (!(PORTC & 0x04))
return 0x32; // return ASCII code of 2
}
if (!(GPIOC->IDR & 0x08)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x08))
return 0x33; // return ASCII code of 3
}
GPIOC->ODR = 0xD0; // set PC5 to low to scan second row
if (!(GPIOC->IDR & 0x01)) {
delayby0ms (10);
if (!(GPIOC->IDR & 0x01))
return 0x34; // return ASCII code of 4
}
if (!(GPIOC->IDR & 0x02)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x02))
return 0x35; // return ASCII code of 5
}
53

if (!(GPIOC->IDR & 0x04)) {

delaybyms (10);
if (!(GPIOC->IDR & 0x04))
return 0x36; // return ASCII code of 6
}
if (!(GPIOC->IDR & 0x08)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x08))
return 0x37; // return ASCII code of 7
}
GPIOC->ODR = 0xB0; // set PC6 to low to scan the third row
if (!(GPIOC->IDR & 0x01)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x01))
return 0x38; // return ASCII code of 8
}
if (!(GPIOC->IDR & 0x02)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x02))
return 0x39; // return ASCII code of 8
}
54

if (!(GPIOC->IDR & 0x04)) {

wait_10ms ( );
if (!(GPIOC->IDR & 0x04))
return 0x41; // return ASCII code of A
}
if (!(GPIOC->IDR & 0x08)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x08))
return 0x42; // return ASCII code of B
}
GPIOC->ODR = 0x70; // set PC7 to low to scan the fourth row
if (!(GPIOC->IDR & 0x01)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x01))
return 0x43; // return ASCII code of C
}
if (!(GPIOC->IDR & 0x02)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x02))
return 0x44; // return ASCII code of D
}
55

if (!(GPIOC->IDR & 0x04)) {

wait_10ms ( );
if (!(GPIOC->IDR & 0x04))
return 0x45; // return ASCII code of E
}
if (!(GPIOC->IDR & 0x08)) {
delaybyms (10);
if (!(GPIOC->IDR & 0x08))
return 0x46; // return ASCII code of F
}
}
}

56

Debouncing User Switch

57

Liquid Crystal Display (LCD)

The most common type of LCD allows the light to pass through
when activated.
An LCD segment is activated when a low frequency bipolar signal in
the range of 30 Hz to 1KHz is applied to it.
LCD can display characters and graphics.
LCDs are often sold in a module with LCDs and controller unit built
in.
The Hitachi HD44780 is the most popular LCD controller being used
today.

Basic construction of an LCD

https://www.youtube.com/watch?v=O3aITfU_UvE

58

A HD44780-Based LCD Kit

Display capability: 4 x 20
Uses the HD44780 as the controller
as shown in the figure below.
Pins DB7~DB0 (data port) are used
to exchange data with the CPU.
E input should be connected to one
of the address decoder output or
I/O pin.
The RS signal selects instruction
register (0) or data register (1).
The VEE signal allows the user to
adjust the LCD contrast.
The HD44780 can be configured to
display 1-line, 2-line, and 4-line
information.
HD44780-based LCD kit

59
59

HD44780 Commands (1 of 3)

HD4478U instruction set

60

HD44780 Commands (2 of 3)

LCD instruction bit names

61

HD44780 Commands (3 of 3)

The HD44780 has a display data RAM (DDRAM) to store data to be

displayed on the LCD.
DDRAM address usage for a 2-line LCD

00

01

02

03

04

05

06

07

08

09

0A

0B

0C

0D

0E

0F

40

41

42

43

44

45

46

47

48

49

4A

4B

4C

4D

4E

4F

44

45

46

47

DDRAM address usage for a 1-line LCD

00

01

02

03

04

05

06

07

40

41

42

43

62

Interfacing the HD44780 with the MCU

One can treat the LCD kit as an I/O device and use an I/O port and several
other I/O pins as control signals.
The interface can be 4 bits or 8 bits.
To read or write the LCD successfully, one must satisfy the timing
requirements of the LCD. The timing diagrams for read and write are
shown in the next two figures.

LCD interface example (8-bit bus)

LCD interface example (4-bit bus)

63

HD4478U LCD controller read timing diagram

HD4478U LCD controller write timing diagram

64

HDD4478U bus timing parameters (2 MHz operation)

65
65

Write a function to send a command to the LCD kit

Most LCD commands are completed in 40 ms.
If the function waits for 40 ms after performing the specified operation, then
most commands will be completed when the function returns.

#define
#define
#define
#define
#define

lcdPort
lcdE
lcdRW
lcdRS
lcdCtl

GPIOD->ODR
0x40
0x20
0x10
GPIOC->ODR

//
//
//
//
//

Port D drives LCD data pins

E signal (PC6)
R/W signal (PC5) Connected to ground
RS signal (PC4)
LCD control port direction

66

Send Command to LCD

void cmd2lcd (char cmd) {
char temp;
char xa, xb;
lcdCtl &= ~(lcdRS+lcdRW);
lcdCtl |= lcdE;
lcdPort = cmd;
xa = 1;
xb = 2;
lcdCtl &= ~lcdE;
lcdCtl |= lcdRW;
delayby50us(1);
}

//
//
//
//
//
//
//
//

select instruction register & pull R/W low

pull E signal to high
output command
dummy statements to lengthen E
"
pull E signal to low
pull R/W to high
wait until the command is complete

HD4478U LCD controller write timing diagram

67

Send data to LCD

void putc2lcd(char cx) {
char temp;
char xa, xb;
lcdCtl |= lcdRS;
lcdCtl &= ~lcdRW;
lcdCtl |= lcdE;
lcdPort = cx;
xa = 1;
xb = 2;
lcdCtl &= ~lcdE;
lcdCtl |= lcdRW;
delayby50us(1);
}

//
//
//
//
//
//
//
//

select LCD data register and pull R/W high

pull R/W to low
pull E signal to high
output data byte
create enough width for E
create enough width for E
pull E to low
pull R/W signal to high

HD4478U LCD controller write timing diagram

68

Data String to LCD

Function to output a string terminated by a NULL character

void puts2lcd (char *ptr) {

while (*ptr) {
putc2lcd(*ptr);
ptr++;
}
}

69

8-bit Initialization

n 8-bit and 4-bit initialization

70

LCD Initialization

The function to configure LCD sends four commands to the LCD kit

Entry mode set

Display on/off
Function set
Clear display

void initlcd(void) {
// configure lcdPort port (GPIOD) as output
GPIOD->MODER
|= 0x00005555;
// configure LCD control pins (PC6, PC5, & PC4) as outputs
GPIOC->MODER
|= 0x00001500;
delayby100ms(5); // wait for LCD to become ready
cmd2lcd (0x38); // set 8-bit data, 2-line display, 5x8 font
cmd2lcd (0x0F); // turn on display, cursor, blinking
cmd2lcd (0x06); // move cursor right
cmd2lcd (0x01); // clear screen, move cursor to home
delayby1ms (2); // wait until "clear display" command is complete
}

71

Example Write an C program to test the previous four subroutines by

displaying the following messages on two lines:
hello world!
I am ready!
int main (void) {
char *msg1 = "hello world!";
char *msg2 = "I am ready!";
initlcd();
cmd2lcd(0x80); // move cursor to the 1st column of row 1
puts2lcd(msg1);
cmd2lcd(0xC0); // move cursor to 2nd row, 1st column
puts2lcd(msg2);
}

72

4-bit Initialization

73