Part-2: Mastering microcontroller with embedded driver development

Mastering Microcontroller with
Embedded Driver Development
FastBit Embedded Brain Academy
Check all online courses at
www.fastbitlab.com
PART-2

FastBit Embedded Brain Academy is an online training wing of Bharati Software.
We leverage the power of internet to bring online courses at your fingertip in the domain of embedded
systems and programming, microcontrollers, real-time operating systems, firmware development,
Embedded Linux.
All our online video courses are hosted in Udemy E-learning platform which enables you to
exercise 30 days no questions asked money back guarantee.
For more information please visit : www.fastbitlab.com
Email : contact@fastbitlab.com
About FastBit EBA

Inter–Integrated Circuit(I2C) Protocol
Pronounced as
“I squared C “ or “ I two C “

What is I2C ?
It is just a protocol to achieve serial data communication between integrated
circuits(ICs) which are very close to each other. (but more serious protocol
than SPI because companies have come forward to design a specification )
I2C protocol details ( how data should sent, how data should received, how
hand shaking should happen between sender and receiver, error handling, )
are complex than SPI. ( In other words SPI is simple protocol compared to
I2C)

Difference between SPI and I2C

I2c is based on dedicated specification. The spec you
can download from here
https://www.nxp.com/docs/en/user-guide/UM10204.pdf
For SPI there is no dedicated spec but TI and Motorola have their own
spec
How different than SPI ?
Specification

Multi-Master Capability
I2C protocol is multi-master capable ,
whereas SPI has no guidelines to achieve this, but depends on
MCU designers . STM SPI peripherals can be used in multi
master configurations but arbitration should be handled by
software code.

ACK
I2C hardware automatically ACKs every byte received.
SPI does not support any automatic ACKing.

Pins
I2C needs just 2 pins for the communication
whereas SPI may need 4 pins and even more than that
if multiple slaves are involved

SPI Consumes more
pins when more slaves
are involved

STM32 Accelerometer ADC EEPROM Rasp PI
+vcc
SCL
SDA
Master-1 Slave Slave Slave Master-2
R1 R2
In I2C, you just need 2 pins to connect all the slaves and masters

Addressing
I 2C master talks to slaves based on slave addresses, whereas
in SPI dedicated pin is used to select the slave.

Communication
I2C is half duplex, where is SPI is full duplex

Speed
For I2C the max speed is 4MHz in ultra speed plus .
For some STM microcontrollers the max speed is just 400KHz.
For SPI max speed is its Fpclk/2 . That means if
the peripheral clock is 20MHz, then speed can be 10MHz

Slave’s control over serial clock
In I2C slave can make master wait by holding the clock down if
it's busy , thanks to clock stretching feature of I2C.
But in SPI, slave has no control over clock, programmers may
use their own tricks to overcome this situation .

Data rate
Data rate ( number of bits transferred from sender to receiver in 1 sec )
is very much lesser in I2C compared to SPI.
For example in STM32F4X if you have peripheral clock of 40MHz, then
in I2C you can achieve data rate of 400Kbps but in SPI it is 20Mbps.
So in the above scenario SPI is 50 times faster than I2C.

Part-2: Mastering microcontroller with embedded driver development

STM32 Accelerometer ADC EEPROM Rasp PI
+vcc
SCL
SDA
Master-1 Slave Slave Slave Master-2
R1 R2
In I2C, you just need 2 pins to connect all the slaves and masters
Pull up resistors

SDA and SCL signals
Both SDA and SCL are bidirectional lines connected to a positive supply
voltage via pull-up resistors. When the bus is free, both lines are held at HIGH.
The output stages of devices connected to the bus must have an open-drain
or open-collector configuration
The bus capacitance limits the number of interfaces connected to the bus.

For proper functioning of
the I2C bus , pull up
resistor value has to be
calculated according to
the I2C formula ( will
discuss later)
OD
Enable Pull up Resistor
SCL

OD
Enable Pull up Resistor
SDA
Trouble shooting tip : When the bus is idle, both SDA and SCL are pulled to +Vdd
For proper functioning of
the I2C bus , pull up
resistor value has to be
calculated according to
the I2C formula ( will
discuss later)

3.3V
SDA & SCLGND Tip
Whenever you face
problems in I2C , probe
the SDA and SCL line after
I2C initialization.
It must be held at HIGH
(3.3 V or 1.8V depending
up on IO voltage levels of
your board)

I2C Modes
Mode Data rate Notes
Standard Mode Up to100 Kbits/sec Supported by STMf2F4x
Fast Mode Up to 400Kbits/sec Supported by STMf2F4x
Fast Mode + Up to 1Mbits/sec Supported by some
STMf2F4x MCUs (refer RM)
High Speed mode Up to 3.4 Mbits/sec Not supported by F4x

Standard Mode
 In standard mode communication data transfer rate can reach up to
maximum of 100kbits/sec.
 Standard mode was the very first mode introduced when first i2c spec was
released.
 Standard-mode devices, however, are not upward compatible; They cant
communicate with devices of Fast mode or above.

Fast Mode
 Fast mode is a mode in i2c protocol, where devices can receive and
transmit data up to 400 kbits/s.
 Fast-mode devices are downward-compatible and can communicate with
Standard-mode devices in a 0 to 100 kbit/s I2C-bus system
 Standard-mode devices, however, are not upward compatible; they should
not be incorporated in a Fast-mode I2C-bus system as they cannot follow
the higher transfer rate and unpredictable states would occur.
 To achieve data transfer rate up to 400kbits/sec, you must put the i2c
device in to fast mode

S A7 A6 A5 A4 A3 A2 A1 R/𝑊 ACK D7 D6 D5 D4 D3 D2 D1 ACKD0 P
R/nW = ‘0’ indicates a
transmission (WRITE),
R/nW = ‘1’ indicates request
for data (READ)
Every byte put on the SDA line must be eight bits long.
Each byte must be followed by an Acknowledge Bit
Data is transferred with the Most Significant Bit (MSB) first

All transactions begin with a START (S) and are terminated by a STOP (P)
A HIGH to LOW transition on the SDA line while SCL is HIGH defines a START condition.
A LOW to HIGH transition on the SDA line while SCL is HIGH defines a STOP condition.

I2C Protocol: Start condition timings
Min. Setup Time For a Start Condition (tSU;STA)
Min. Hold Time For Start Condition (tHD;STA)

I2C Protocol: stop condition timings
Min.Setup Time for Stop Condition (tSU;STO)
Setup Time for Stop Condition (tSU;STO) is measured as the time between 70%
amplitude of the rising edge of SCL and 30% amplitude of a rising SDA signal during
a stop condition.

Points to Remember
 START and STOP conditions are always generated by the master. The bus is
considered to be busy after the START condition.
 The bus is considered to be free again a certain time after the STOP condition.
 When the bus is free another master(if present) can get the chance to claim the
bus.
 The bus stays busy if a repeated START (Sr) is generated instead of a STOP
condition.
 Most of the MCU’s I2C peripherals support both master and slave mode. You
need not to configure the mode because when the peripheral generates the start
condition it automatically becomes the master and when it generates the stop
condition it goes back to slave mode.

I2C Protocol: ACK
The Acknowledge signal is defined as
follows:
The transmitter releases the SDA line
during the acknowledge clock pulse so
the receiver can pull the SDA line LOW
and it remains stable LOW during the
HIGH period of this clock pulse
The acknowledge takes place after every byte.
The acknowledge bit allows the receiver to signal the transmitter that the byte was
successfully received and another byte may be sent.
The master generates all clock pulses, including the acknowledge ninth clock pulse

I2C Protocol: NACK
When SDA remains HIGH during this ninth clock pulse, this is defined as the Not
Acknowledge signal.
The master can then generate either a STOP condition to abort the transfer, or a repeated
START condition to start a new transfer.

Data validity
The data on the SDA line must be stable during the HIGH period of the clock. The HIGH Or
LOW state of the data line can only change when the clock signal on the SCL line is LOW .
One clock pulse is generated for each data bit transferred.

1 2 3 4 5 6 7 8
SCL
SDA
A7 A6 A5 A4 A3 A2 A1

1 2 3 4 5 6 7 8 9
SCL
SDA
A7 A6 A5 A4 A3 A2 A1

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8
SCL
SDA
A7 A6 A5 A4 A3 A2 A1 D7 D6 D5 D4 D3 D2 D1 D0

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9SCL
SDA
A7 A6 A5 A4 A3 A2 A1 D7 D6 D5 D4 D3 D2 D1 D0

1 2 3 4 5 6 7 8 9
D7 D6 D5 D4 D3 D2 D1 D0
1 2 3 4 5 6 7 8 9
D7 D6 D5 D4 D3 D2 D1 D0

Master Reading
data from slave

1 2 3 4 5 6 7
A7 A6 A5 A4 A3 A2 A1
SCL
SDA

1 2 3 4 5 6 7 8
A7 A6 A5 A4 A3 A2 A1
SCL
SDA

1 2 3 4 5 6 7 8 9
A7 A6 A5 A4 A3 A2 A1
SCL
SDA

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8
D7 D6 D5 D4 D3 D2 D1 D0A7 A6 A5 A4 A3 A2 A1
SCL
SDA

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
D7 D6 D5 D4 D3 D2 D1 D0A7 A6 A5 A4 A3 A2 A1
SCL
SDA

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
D7 D6 D5 D4 D3 D2 D1 D0
SCL
SDA
D7 D6 D5 D4 D3 D2 D1 D0

Repeated Start(Sr)
(Start again without Stop)

MCU
(Master)
EEPROM
(Slave)
0x45
I2C
Master reading the contents of EEPROM at address 0x45

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
SCL
SDA
A7 A6 A5 A4 A3 A2 A1
A7 A6 A5 A4 A3 A2 A1
D7 D6 D5 D4 D3 D2 D1 D0
D7 D6 D5 D4 D3 D2 D1 D0

I2C peripherals of your MCU
AHB1
APB1
APB2
GPIOA GPIOB GPIOC GPIOD GPIOE …. GPIOI
I2C1 I2C2 I2C3 SPI2 SPI3
USART
2
USART
3
UART4 UART5
SPI1
USART
1
USART
6
EXTI
SYSCF
G

SPIGPIO UARTI2C
STM3F407x MCU
gpio_driver.c , .h
spi_driver.c , .h
i2c_driver.c , .h
uart_driver.c , .h
Stm3f407xx.h
Driver Layer
Sample Applications
(Device header)

Driver API requirements and user
configurable items

I2C Driver
APIs
I2C Initialization
I2C Master TX
I2C Master RX
I2C Slave TX
I2C Slave RX
I2C Error Interrupt handling
I2C Event Interrupt handling

I2Cx Peripheral
I2C_ACKControl
I2C_FMDutyCycle
I2C_DeviceAddress
I2C_SCLSpeed
Configurable items
For user application

Exercise:
1. Create stm32f407xx_i2c_driver.c and stm32f407xx_i2c_driver.h
2. Add I2Cx related details to MCU specific header file
I. I2C peripheral register definition structure
II. I2Cx base address macros
III. I2Cx peripheral definition macros
IV. Macros to enable and disable I2Cx peripheral clock
V. Bit position definitions of I2C peripheral

I2C handle structure and
configuration structure

Create Configuration and Handle structure

Steps for I2C init (Generic)
1. Configure the Mode (standard or fast )
2. Configure the speed of the serial clock (SCL)
3. Configure the device address (Applicable when device is slave)
4. Enable the Acking
5. Configure the rise time for I2C pins (will discuss later )
All the above configuration must be done when the peripheral is disabled in
the control register

I2C Serial clock (SCL) control settings
In STM32F4x I2C peripheral, CR2 and CCR registers are used to control the I2C
serial clock settings and other I2C timings like setup time and hold time

/
APB 1 bus ( 42 Mhz Max)
I2C1
HSI
HSE
PLL
16Mhz
16Mhz
16Mhz
SCLUp to 100KHz in SM
Up to 400Khz in FM
CR2_FREQ
CCR Settings
APB1 prescaler

Thigh(scl) = CCR * TPCLK1
Tlow(scl) = CCR * TPCLK1
Example :
In SM Mode , generate a 100 kHz SCL frequency
APB1 Clock (PCLK1) = 16MHz
1) Configure the mode in CCR register (15th bit )
2) Program FREQ field of CR2 with the value of PCLK1
3) Calculate and Program CCR value in CCR field of CCR register

Example :
In FM Mode , generate a 200 kHz SCL frequency
APB1 Clock (PCLK1) = 16MHz
1) Configure the mode in CCR register (15th bit )
2) Select the duty cycle of Fast mode SCL in CCR register (14th bit)
3) Program FREQ field of CR2 with the value of PCLK1
4) Calculate and Program CCR value in CCR field of CCR register
If DUTY = 0:
Thigh = CCR * TPCLK1
Tlow = 2 * CCR * TPCLK1
If DUTY = 1: (to reach 400 kHz)
Thigh = 9 * CCR * TPCLK1

thigh tlow
thigh tlow
2thigh
thigh
tlow
1.7thigh
I2C Duty Cycle
In STM32f4x I2C
For SM
(Tlow may be equal to Thigh )
For FM
Tlow = 2Thigh
Or
Tlow = 1.8 Thigh
SM
FM

thigh tlow
I2C Duty Cycle
SM
Thigh(scl) = CCR * TPCLK1
Tlow(scl) = CCR * TPCLK1

thigh tlow
2thigh
thigh
tlow
1.7thigh
I2C Duty Cycle
FM
If DUTY = 0:
Thigh = CCR * TPCLK1
If DUTY = 1: (to reach 400 kHz)
Thigh = 9 * CCR * TPCLK1

Implementation
I2C_MasterSendData API

Exercise :
I2C Master(STM) and I2C Slave(Arduino) communication .
When button on the master is pressed , master should send data to the Arduino slave
connected. The data received by the Arduino will be displayed on the Arduino serial
port.
1 . Use I2C SCL = 100KHz(Standard mode )
2. Use internal pull resistors for SDA and SCL lines

Things you need
ST board Arduino boardI2C USB
PC ( Arduino Serial
Monitor )
1 .Arduino board
2. ST board
3. Some jumper wires
4. Bread board
5. 2 Pull up resistors of value 4.4K Ω( only if your pin doesn't
support internal pull up resistors )

I2C1 I2C
SCL(PB6)
SDA(PB9)
A5
A4
GND GNDSTM32F4 discovery Arduino
USER button
Master Slave
USB Logic analyzer
CH0CH1GND
To PC
STEP-1 Connect Arduino and ST board SPI pins as shown

STEP-2
Power your Arduino board and download I2C Slave
sketch to Arduino
Sketch name : 001I2CSlaveRxString.ino

Find out the GPIO pins over which I2C1 can
communicate

I2C pull up resistance , Rise time and Bus
capacitance discussion

Pull-up Resistor(Rp ) Calculation
Rp (min) is a function of VCC, VOL (max), and IOL:
The maximum pullup resistance is a function of the maximum rise time (tr ):
VOL = LOW-level output voltage
IOL = LOW-level output current
tr = rise time of both SDA and SCL
signals
Cb = capacitive load for each bus
line

Image taken from : http://www.ti.com/lit/an/slva704/slva704.pdf

Rise (tr) and Fall (tf) Times
tr is defined as the amount of time
taken by the rising edge to reach
70% amplitude from 30% amplitude
for either SDA and SCL
SDA or SCL
I2C spec cares about tr value and you have to respect it while calculating the pull up resistor value.
Higher value of pull up resistors(weak pull-ups) increases tr value. ( not acceptable if tr crosses max. limit
mentioned in the spec )
Lower value of pull up resistors ( strong pull-ups) decreases tr value ( good) but they also lead higher
current consumption (bad)

VIL
VIH
VDD
Using very high value of pull up resistors may
cause issues like this where the pin may not
able to cross the VIH limit (Input Level High
Voltage)

I2C Bus Capacitance(Cb )
capacitance means that the voltage level on the signal line (data or
clock) can’t change instantaneously
accidental capacitors

I2C Bus Capacitance(Cb )
Bus capacitance is a collection of individual pin capacitance wrt gnd , capacitance
between the sda and scl , parasitic capacitance, capacitance added by the devices
hanging on the bus , bus length (wire) , dielectric material etc.
Bus capacitance limits how long your i2c wiring can be and how many devices you
can connect on the bus.
For maximum allowed bus capacitance check the spec.

Exercise
For Fast-mode I2C communication with the following parameters,
calculate the pullup resistor value. Cb = 150 pF, VCC = 3.3 V

Clock Stretching
 Clock stretching pauses a transaction by holding the SCL line LOW.
 The transaction cannot continue until the line is released HIGH again. Clock stretching
is optional and in fact, most slave devices do not include an SCL driver so they are
unable to stretch the clock.
 Slaves can hold the SCL line LOW after reception and acknowledgment of a byte to
force the master into a wait state until the slave is ready for the next byte transfer in a
type of handshake procedure
 If a slave cannot receive or transmit another complete byte of data until it has
performed some other function, for example servicing an internal interrupt, it can hold
the clock line SCL LOW to force the master into a wait state. Data transfer then
continues when the slave is ready for another byte of data and releases clock line SCL.

1 2 3 4 5 6 7 8 9 1
1 2 3 4 5 6 7 8 9 1
SCL
SDA
SCL
SDA
The slave is not ready for more data, so it buys
time by holding the clock low.
The master will wait for the clock line to be
released before proceeding to the next frame

Implementation
I2C_MasterReceiveData API

Master Receiving data from slave

Master Receiving 1 byte from slave

Master Receiving more than 1 byte

Exercise :
I2C Master(STM) and I2C Slave(Arduino) communication .
When button on the master is pressed , master should read and display data from
Arduino Slave connected. First master has to get the length of the data from the
slave to read subsequent data from the slave.

Things you need
ST board Arduino boardI2C
1 .Arduino board
2. ST board
4. Bread board
Print received data using semihosting

STEP-2
sketch to Arduino
Sketch name : 002I2CSlaveTxString.ino

Master sends command
code 0x51 to read the
length(1 byte) of the data
from the slave
complete data from the
slave
1 2
Procedure to read the data from Arduino Slave

I2C transactions to read the 1 byte
length information from slave

I2C transactions to read “length” bytes
of data from the slave

START
Reset both the boards
Wait for button press on the master
Master first sends command code 0x51 to
slave (to read length)
Master reads “length” from slave
( 1 byte)
Master reads “length” number of bytes from
the slave
Master display the data received using printf
(semihosting)
END

I2C Functional
block and
Peripheral Clock

fpclk (Peripheral Clock Frequency ) must be at least 2MHz to
achieve standard mode I2c frequencies that are up to 100khz
fpclk must be at least 4Mhz to achieve FM mode i2c
frequencies. that is above 100khz but below 400Khz
fpclk must be a multiple of 10Mhz to reach the 400khz max
i2c fm mode clock frequency

I2C IRQs and Interrupt mapping

I2C1 interrupts
NVIC
Processor
Core
I2C1_EV_IRQ_LINE
I2C1_ER_IRQ_LINE
31
32
ARM Cortex M4
Peripheral Processor
IRQn

I2C Interrupting the Processor
31
32
33
34
79
80
IRQ numbers are specific to MCUs. Please check the vector table of your RM

Bus Error
This error happens when the interface detects an SDA rising or falling edge while
SCL is high, occurring in a non-valid position during a byte transfer
Arbitration Loss Error
This error can happen when the interface loses the arbitration of the bus
to another master

ACK Failure Error
This error happens when no ACK is returned for the byte sent
Overrun Error
Happens during reception, when a new byte is received and the data register
has not been read yet and the New received byte is lost.

Under-run Error
Happens when In transmission when a new byte should be sent and the
data register has not been written yet and the same byte is sent twice
PEC Error
Happens when there is CRC mismatch, if you have enabled the CRC feature

Time-Out Error
Happens when master or slave stretches the clock , by holding it low
more than recommended amount of time.

During Txing of a data byte, if TXE=1, then that means data
register is empty.
And if the firmware has not written any byte to data register
before shift register becomes empty(previous byte
transmission), then BTF flag will be set and clock will be
stretched to prevent the under run.
BTF flag in TX and preventing underrun

If RXNE =1, Then it means new data is waiting in the
data register, and if the firmware has not read the data
byte yet before Shit register is filled with another new
data, then also the BTF flag will be set and clock will be
stretched to prevent the overrun.
BTF flag in RX and preventing overrun

I2C sending and receiving
data in interrupt mode

I2C_MasterSendDataIT API
I2C_MasterReceiveDataIT API

Modifying handle structure to store
place holder variables

Implementing
I2C_MasterSendDataIT API

Implementing
I2C_MasterReceiveDataIT API

Implementing
I2C_IRQInterruptConfig();
I2C_IRQPriorityConfig();

I2C ISR handling
Interrupt handling for interrupts
generated by I2C events
Interrupt handling for interrupts
generated by I2C errors
ISR1 ISR2
I2C_ER_IRQHandlingI2C_EV_IRQHandling

When BTF flag is set
EMPTY EMPTY FULL FULL
During Transmission During Reception
SR DR SR DR
TXE=1 RXNE=1

STM32
(Master)
Arduino
(Slave)
I2C

Arduino
(Master)
STM32
(Slave)
I2C

I2C Master I2C SlaveI2C
Read
Write
STAR
T
STOP
Request for data
Receive data

I2C Driver
(Slave mode)
Slave
Application
Callback events
ACK Failure
STOP generation
Request for data
Receive data

Exercise :
I2C Master(Arduino) and I2C Slave(STM32) communication .
Master should read and display data from
STM32 Slave connected. First master has to get the length of the data from the
slave to read subsequent data from the slave.

Things you need
Arduino(M) STM32(Slave)I2C
1 .Arduino board
2. ST board
4. Bread board
Print received data on to Arduino serial port

STEP-2
sketch to Arduino
Sketch name: 003I2CMasterRxString.ino

length(1 byte) of the data
from the slave
complete data from the
slave
1 2
Procedure to read the data from STM32 Slave

I2C transactions to read the 4 bytes of
length information from the slave

If length is <= 32 then only one “READ” Transaction

READ Transaction -1
READ Transaction -2
READ Transaction -3

Common Problems in I2C and
Debugging Tips

3.3V
SDA & SCLGND
Tip
Whenever you face
problem in I2C , probe the
SDA and SCL line after
I2C initialization.
It must be held at HIGH
level.

Problem-1: SDA and SCL line not held HIGH
Voltage after I2C pin initialization
Reason-1:
Not activating the pullup resistors if you are using the internal pull
up resistor of an I/O line
Debug Tip:
worth checking the configuration register of an I/O line to see
whether the pullups are really activated or not, best way is to dump
the register contents.

Problem-2: ACK failure
Reason-1:
Generating the address phase with wrong slave address
Debug Tip:
verify the slave address appearing on the SDA line by using logic
analyser.

Problem-2: ACK failure
Reason-2:
Not enabling the ACKing feature in the I2C control register
Debug Tip:
Cross check the I2C Control register ACK enable field

Problem-3: Master is not producing the clock
Debug Tip 1 :
First Check whether I2C peripheral clock is enabled and set to at
least 2MHz to produce standard mode i2c serial clock frequency
Debug Tip 2 :
Check whether GPIOs which you used for SCL and SDA functionality
are configured properly for the alternate functionality

I2C1 I2C1
SCL(PB6)
SDA(PB9)
SCL(PB6)
SDA(PB9)
GND GNDSTM32F4 discovery STM32F4 discovery
USER button
Master Slave
USB Logic analyzer
CH0CH1GND
To PC

I2C1
SCL(PB6)
SDA(PB9)
GND
STM32F4 discovery
USER button
Master Slave
USB Logic analyzer
CH0CH1GND
To PC

Clock Stretching simply means that holding the clock to 0 or
ground level.
The moment clock is held at low, then the whole I2C
interface pauses until clock is given up to its normal
operation level.
I2C Clock Stretching

So, What is the use of clock stretching ?

I2C devices, either Master or Slave, uses this feature to slow down the
communication by stretching SCL to low, which prevents the clock to
Rise high again and the i2c communication stops for a while
There are situations where an I2C slave is not able to co-operate with the
clock speed given by the master and needs to slow down a little.
If slave needs time, then it takes the advantage of clock stretching , and by
holding clock at low, it momentary pauses the I2C operation.

Modifying I2C application to
send/receive more than 32 bytes

Exploring UART Interrupt
Mapping

UART
Universal
Asynchronous
Receiver
Transmitter
USART
Universal
Synchronous
Asynchronous
Receiver
Transmitter

UART Peripheral supports only asynchronous mode
USART supports both asynchronous and synchronous modes.
You can use USART module both in synchronous mode as well as
in asynchronous mode
There is no specific port for USART communication. They are
commonly used in conjugation with protocols like RS-232, RS-434,
USB etc.
In synchronous transmission, the clock is sent separately from the
data stream and no start/stop bits are used

USART hardware components
 Baud rate generator
 TX and RX shift registers
 Transmit/Receive control blocks
 Transmit/Receive buffers
 First-in, First-out (FIFO) buffer memory

USART is just a piece of hardware in your microcontroller
which transmits and receives data bits either in Synchronous
mode or in Asynchronous mode.
If it is Asynchronous mode, then clock will not be sent along
with the data, instead we use synchronization bits like start
and stop along with the useful data.

UART1
TX
RX
RTS
CTS
Understanding UART pins

UART1
TX
RX
RTS
CTS
10101110101

UART1 UART2
TX TX
RX
RTS
CTS
RX
RTS
CTS

Bit0 Bit1 Bit 2 Bit 3 Bit4 Bit5 Bit6 Bit7
Bit8
Bit0 Bit1 Bit 2 Bit 3 Bit4 Bit5 Bit6
Bit7
Start
bit
Data Frame
Optional
Parity
Bit
Stop
bit
Next
Start
bit
Next Data Frame
9-bit word Length, 1 stop bit
8-bit word Length, 1 stop bit
Start
bit
Data Frame
Stop
bit
Next
Start
bit
Next Data Frame
Optional
Parity
Bit

The significance of baud rate is how fast the data is sent
over a serial line. It’s usually expressed in units of bits-per-
second (bps). If you invert the baud rate, you can find out,
just how long it takes to transmit a single bit. This value
determines how long the transmitter holds a serial line high
or low .

5 to 9 data bits
5 to 9 data bits
5 to 9 data bits
Start
bit
Start
bit
Start
bit
1 Stop Bit
1.5 Stop Bit
2 Stop Bit

Adding Parity bit is a simplest method of error detection. Parity is simply the
number of ones appearing in the binary form of a number.
55(Decimal) 0b00110111
Parity = 5
Parity
Even Parity Odd parity

Even parity
55
Binary
0 0 1 1 0 1 1 1
Odd number of ones
In the data byte
1
Make Parity bit =1
That becomes, Even
number of ones including
parity bit

Even parity
54
Binary
0 0 1 1 0 1 1 0
even number of ones
0
Parity bit =0
Even number of ones
including parity bit

Odd parity
55
Binary
0 0 1 1 0 1 1 1
Odd number of ones
0
Parity bit =0
Maintain odd number of
ones including parity bit

Odd parity
54
Binary
0 0 1 1 0 1 1 0
even number
of ones
1
Parity bit =1
Maintain odd number of
ones including parity bit

Even parity results in even number of 1s, whereas odd
parity results in odd number of 1s, when counted including
the parity bit.
Simply remember

1101011 1
1100011 1
Represents EVEN parity .
i.e even number of 1s
including the parity bit
Here it has a odd number of
1s including the parity bit.
Which implies that data is
corrupted and has to be
discarded.
Data gets corrupted
during transmission

/
APB 2 bus ( 84 MHz Max)
USART1/USAR
T6
HSI
HSE
PLL
16MHz
16MHz
16MHz
FPCLK

/
APB1 bus ( 42 MHz Max)
USART2
USART3
UART4
UART5
HSI
HSE
PLL
16MHz
16MHz
16MHz
FPCLK

 Program the M bit in USART_CR1 to define the word length
 Program the number of stop bits in USART_CR2 register.
 Select the desired baud rate using the USART_BRR register
 Set the TE bit in USART_CR1 to enable the transmit block. .
 Enable the USART by writing the UE bit in USART_CR1
 Now if txe flag is set , then Write the data byte to send , in the
USART_DR register .
 After writing the last data into the USART_DR register, wait until TC=1
Steps to do Data Transmission

TX Line
TXE Flag
DR
TC Flag
F1 F2 F3
Frame 1 Frame 2 Frame 3
Set by hardware
Cleared by software
Set by hardware
Cleared by software
Set by hW
Software
enables the
UART
Software waits until
TXE=1 and writes
F2 to DR
TC is not set
because
TXE=0
TC is not set
because
TXE=0
TC is set
because
TXE=1
Software waits until
TXE=1 and writes
F1 to DR
Software waits
until TXE=1 and
writes F3 to DR
Software waits until TC=1
Line idle

 Program the M bit in USART_CR1 to define the word length
 Program the number of stop bits in USART_CR2 register.
 Select the desired baud rate using the USART_BRR register
 Enable the USART by writing the UE bit in USART_CR1
 Set the RE bit in the USART_CR1 register , which enables the
receiver block of the usart peripheral
 When a character is received, wait till The RXNE bit is set and read the
data byte from the data register
 The RXNE bit must be cleared by reading the data register , before the
end of the reception of the next character to avoid an overrun error.
Steps to do Data Reception

RX Line
RXNE Flag
DR F1
Frame 1 Frame 2 Frame 3
Set by hardware
Cleared by software
Set by hardware
Cleared by software
Reception
started
RXNE is set when
F1 fully received
Software reads
F1 from DR
register
Line idle
F3F2
Line idle
RXNE is set when
F2 fully received
Software reads
F2 from DR
register
RXNE is set when
F3 fully received
Software reads
F3 from DR
register

Over sampling
 What is oversampling
 How does it effect the baudrate

 Using TTL to USB Converter
 Using RS232 cable with DB9 Connector

USART
1
USART
2
USART
3
USART
x
UART Driver
Startup &
CMSIS APIs
Sample Applications
STM32F4xx Microcontroller

Understanding the Requirements

UART Driver APIs
UART initialization
UART Transmission
UART Reception
Interrupt Handling

Exploring different UART
Peripherals and pins of the MCU

U(S)ARTs Pin Pack 1 Pin pack 2 Pin pack 3 Bus
TX RX TX RX TX RX
USART1 PA9 PA10 PB6 PB7 APB2
USART2 PA2 PA3 PD5 PD6 APB1
USART3 PB10 PB11 PC10 PC11 PD8 PD9 APB1
UART4 PA0 PA1 PC10 PC11 APB1
UART5 PC12 PD2 APB1
USART6 PC6 PC7 PG14 PG9 APB2

APB1/APB2
Firmware Write 0xAB Data Register
RX shift register
RDR
TX shift register
TDR
USART_DR

TDR
APB1/APB2
Firmware Write 0xAB Data Register
RX shift register
RDR
TX shift register
Write
USART_DR

APB1/APB2
RX shift register
RDR
TDR
Firmware Read
0xAB
Data Register
TX shift register
Read
USART_DR

Got interrupt from UART
Decode the interrupt using Status
register
Interrupt is due to
setting of RXNE flag
Interrupt is due to
setting of TXE flag
Interrupt is due
Setting of ERROR
flag
Handle RXNE
interrupt
Handle TXE
interrupt Handle Error
Interrupt is due to
setting of TC flag
Handle TC
interrupt

Handle TXE interrupt
Write one byte to
USART_DR
Tx Count--
Tx Count = 0 ?
Wait till TC interrupt to
confirm of last byte sent Wait till another TXE
interrupt
Yes
No
Disable TXE interrupt
Enable TC interrupt

Handle TC interrupt
Disable TC interrupt
Call Application callback to indicate
TX completed
Make tx_state = READY

Handle RXNE interrupt
Is parity used ?
Read USART_DR
register
With out msb
Is RX count = 0 ?? Wait till another RXNE
interrupt
Yes No
RX Count--
Read USART_DR
register
With msb
Disable RXNE interrupt
Disable Error interrupts
Make RX_State = READY
Call Application callback
to indicate RX completed
N
y

MCU
USART2
TX
RX
Debug strings
LED commands

Commands Function
LEDOH Turn ON LED Orange
LEDOL Turn OFF LED Orange
LEDBH Turn ON LED Blue
LEDBL Turn OFF LED Blue
LEDRH Turn ON LED Red
LEDRL Turn OFF LED Red
LEDGH Turn ON LED Green
LEDGL Turn OFF LED Green
LEDAH Turn ON ALL LEDs
LEDAL Turn OFF ALL LEDs

U(S)ARTs Pin Pack 1 Pin pack 2 Pin pack 3 Bus
TX RX TX RX TX RX
USART1 PA9 PA10 PB6 PB7 APB2
USART2 PA2 PA3 PD5 PD6 APB1
USART3 PB10 PB11 PC10 PC11 PD8 PD9 APB1
UART4 PA0 PA1 PC10 PC11 APB1
UART5 PC12 PD2 APB1
USART6 PC6 PC7 PG14 PG9 APB2
Different USART Peripherals and Associated Pin Packs

USB to TTL USB UART
serial port
converter
module

PC
CP2102 USB to
UART Convertor
USART2
TX
RX
RX
TX
PA2
PA3
USB
MCUGND
GND

PC
CP2102 USB to
UART Convertor
USART Master Application
With
uartprintf library
TX
RX
RX
TX
PB10
PB11
USB
GND
GND
Uartprintf library uses USART3 to output debug messages

Implementing UART_PRINTF
By using this printf function you can able to print debug messages
over UART, just like standard printf

write a code for uart printf
uartprintf.c
create a static
library
uartprintf.lib
Use uartprintf.lib in any
application to enable the
prints over UART

Both transmitting as well as receiving devices should operate at the same
rate.
2400 4800 9600 19200 38400
57600 115200

Desired baudrate USARTDIV value Hex conversion
(USART_BRR)
9600bps 104.1875 0x683
115200 bps 8.6875 0x8A
921600 bps(Max) 1.0625 0x11
Fpclk = 16MHz OVER8=0

USART and UART peripherals of your MCU
AHB1
APB1
APB2
GPIOA GPIOB GPIOC GPIOD GPIOE …. GPIOI
I2C1 I2C2 I2C3
USAR
T2
USAR
T3
USART
2
USART
3
UART4 UART5
USAR
T1
USART
1
USART
6
EXTI
SYSCF
G

USARTGPIO UARTI2C
STM3F407x MCU
gpio_driver.c , .h
USART_driver.c , .h
i2c_driver.c , .h
usart_driver.c , .h
Stm3f407xx.h
Driver Layer
Sample Applications
(Device header)

USARTx
Peripheral
USART_NoOfStopBits
USART_WordLength
USART_HWFlowControl
USART_ParityControl
USART_Baud
USART_Mode
Configurable items
For user application

USART Driver
API
s
USART Initialization / peripheral clock
control
USART TX
USART RX
USART Interrupt config. &
handling
Other USART management APIs

USART handle structure and
configuration structure

USART Configuration Structure
USART Handle Structure

Exercise :
1. Create USART driver header file and source file
2. Complete USART register definition structure and other
macros ( peripheral base addresses, Device definition ,
clock en , clock di , etc) in MCU specific header file
3. Also add USART register bit definition macros in MCU
specific header file
4. Add USART Configuration structure and USART handle
structure in USART header file

USART: Oversampling
 The receiver implements different user-configurable oversampling techniques
(except in synchronous mode) for data recovery by discriminating between valid
incoming data and noise.
 The oversampling method can be selected by programming the OVER8 bit in
the USART_CR1 register and can be either 16 or 8 times the baud rate clock
 Configurable oversampling method by 16 or by 8 to give flexibility between
speed and clock tolerance

Receiver block sampling the Rx
line during reception when
oversampling by 16 is used
Receiver block sampling the Rx
line during reception when
oversampling by 8 is used

Noise Error
When noise is detected in a frame:
The NF flag bit is set by hardware when noise is detected
on a received frame
The invalid data is transferred from the Shift register to
the USART_DR register
The application may consider or discard the frame based
on application logic

Selecting the proper oversampling method
The receiver implements different user-configurable oversampling techniques (except in
synchronous mode) for data recovery by discriminating between valid incoming data and
noise.
If you select oversampling by 8 (OVER8=1) then you can achieve max baudrate up to
FPCLK/8, but In this case the maximum receiver tolerance to clock deviation is reduced
If you select oversampling by 16 (OVER8=0) then you can achieve max baudrate up
to FPCLK/16, In this case the maximum receiver tolerance to clock deviation is
increased.

Peripheral Clock
Divide factor to generate different baud rates
The baud rate for the receiver and transmitter (Rx and Tx) are both set to the same
value as programmed in the Mantissa and Fraction values of USARTDIV.

OVER8 =1 , if Oversampling by 8 is used
OVER8=0, if Oversampling by 16 is used

Fck= 16MHz Tx/Rx baud = 9600 bps OVER8=0
USARTDIV = 16M /(8 * 2 * 9600)
=104.17
(USART Peripheral Clock) (Desired Baudrate) (Oversampling by 16)

Programming USART Baudrate register
(USART_BRR)

USARTDIV = 104.1875
(For baudrate 9600bps with Fck = 16MHz and OVER8=0)
Now this value we have to convert in to hex and then program the
USART_BRR register to achieve desired baud rate.
Fraction part of 4 bits Mantissa part of 12 bits
USART_BRR
USART uses a fractional baud rate generator - with a 12-bit mantissa and 4-bit fraction

USARTDIV = 104.1875
DIV_Fraction = 0.1875 X 16 = 3
Div_Mantissa = 104 = 0x68
USARTDIV = 0x683
(Program this value into USART_BRR register to generate baudrate of 9600bps)

Now lets take another example of generating baud rate of
115200 bps.
For , FCK = 16MHz and OVER8=1

USARTDIV = 17.361
DIV_Fraction = 0.361 X 8 = 2.88 = 3
Div_Mantissa = 17
USARTDIV = 0x113
(Program this value into USART_BRR register to generate baudrate of 115200bps)

Overrun Error
 An overrun error occurs when a character is received when RXNE has not
been reset. Data can not be transferred from the shift register to the RDR
register until the RXNE bit is cleared.
 When an overrun error occurs:
 The ORE bit is set.
 The RDR content will not be lost. The previous data is available
when a read to USART_DR is performed
 The shift register will be overwritten. After that point, any data
received during overrun is lost.
 An interrupt will be generated if enabled.

APB1/APB2
RX shift register
RDR
TDR
Firmware Read Data Register
TX shift register
Read
USART_DR

Exercise
Write a program to send some message over UART from STM32 board to
Arduino board. The Arduino board will display the message (on Arduino
serial monitor) sent from the ST board.
Baudrate : 115200 bps
Frame format : 1 stop bits, 8 bits , no parity

Exercise
Write a program for stm32 board which transmits different messages
to the Arduino board over UART communication.
For every message STM32 board sends , arduino code will change the
case of alphabets(lower case to upper case and vice versa) and sends
message back to the stm32 board .
The stm32 board should capture the reply from the arduino
board and display using semi hosting.

Arduino Sketch
001UARTRxString.ino
Download the Arduino sketch into Arduino board

Part-2: Mastering microcontroller with embedded driver development

More Related Content

What's hot (20)

Similar to Part-2: Mastering microcontroller with embedded driver development (20)

Recently uploaded (20)

Part-2: Mastering microcontroller with embedded driver development