PID-based Practical Digital Control With Raspberry Pi and Arduino Uno

books books
PID-based Practical
PID-based Practical
PID-based Practical Digital Control • Dogan Ibrahim

Digital Control
With Raspberry Pi and Arduino Uno
The Arduino Uno is an open-source microcontroller development system
encompassing hardware, an Integrated Development Environment (IDE),
and a vast number of libraries. It is supported by an enormous community
Digital Control
of programmers, electronic engineers, enthusiasts, and academics. The
libraries in particular really smooth Arduino programming and reduce
programming time. What’s more, the libraries greatly facilitate testing
your programs since most come fully tested and working. Prof Dogan Ibrahim has a BSc,
Hons. degree in Electronic
Engineering, an MSc degree in
The Raspberry Pi 4 can be used in many applications such as audio and Automatic Control Engineering,
video media devices. It also works in industrial controllers, robotics, games,
# d e f in e P h a s e A 2 / / Phase A
and a PhD degree in Digital Signal
and in many domestic and commercial applications. The Raspberry Pi 4 Processing. # d e f in e P h a s e B 3 / / Phase B
also offers Wi-Fi and Bluetooth capability which makes it great for remote
and Internet-based control and monitoring applications. Dogan has worked in many industrial # d e f i n e P WM 5 / / P WM p i n
organizations before he returned
to academic life. He is the author # d e f i n e DIR 4 / / DIR p i n
This book is about using both the Raspberry Pi 4 and the Arduino Uno of over 70 technical books and has
in PID-based automatic control applications. The book starts with basic published over 200 technical articles f l o a t s k , K p , T i, T d , p k , T , p k _ 1, e k , e k _ 1, a , b , y k , q k , w k , u k ;
theory of the control systems and feedback control. Working and tested on electronics, microprocessors,
v o l a t i l e u n sig n e d l o n g C o u n t = 0; / / Encode r coun t
projects are given for controlling real-life systems using PID controllers. The microcontrollers, and related fields.
open-loop step time response, tuning the PID parameters, and the closed- f l o a t c o n v = 15 0.0 / 9 0.0;
The full program listings of all the
loop time response of the developed systems are discussed together with projects discussed in the book / /
the block diagrams, circuit diagrams, PID controller algorithms, and the may be downloaded free of charge
full program listings for both the Raspberry Pi and the Arduino Uno. The from the Elektor Store website, / / C o n f i g u r e P WM p i n a n d I n i t i a l i z e v a r i a b l e s
projects given in the book aim to teach the theory and applications of PID www.elektor.com (search for:
controllers and can be modified easily as desired for other applications. book title). / /
The projects given for the Raspberry Pi 4 should work with all other v o i d s e t u p ()
models of Raspberry Pi family.
{
The book covers the following topics: T C C R 2 B = T C C R 2 B & B 11111 0 0 0 | B 0 0 0 0 0 0 11;
> Open-loop and closed-loop > ON-OFF temperature control with
control systems Raspberry Pi and Arduino Uno p i n M o d e ( D I R , O U T P U T ); / / Di r e c t i o n i s o u t p u
> Analog and digital sensors > PID-based temperature d i g i t a l W r i t e ( D I R , L O W);
> Transfer functions and control with Raspberry Pi and
continuous-time systems Arduino Uno p i n M o d e ( P WM, O U T P U T ); / / P WM i s o u t p u t
> First-order and second-order > PID-based DC motor control with Elektor International Media BV
p i n M o d e ( P h a s e B , I N P U T ); / / P h a s e B is in p u t
system time responses Raspberry Pi and Arduino Uno www.elektor.com
> Discrete-time digital systems > PID-based water level control p i n M o d e ( P h a s e A , I N P U T ); / / P h a s e A is in p u t
> Continuous-time PID controllers with Raspberry Pi and Arduino
> Discrete-time PID controllers > PID-based LED-LDR brightness
a t t a c h I n t e r r u p t ( d i g i t a l P i n T o I n t e r r u p t ( P h a s e B ), E n c o d e r I S R , R I S
control with Raspberry Pi and a t t a c h I n t e r r u p t ( d i g i t a l P i n T o I n t e r r u p t ( P h a s e A ), E n c o d e r I S R 2 , R
Arduino Uno
S e r i a l . b e g i n (1 9 2 0 0 ); Dogan Ibrahim
● This is an Elektor Publication. Elektor is the media brand of
Elektor International Media B.V.
PO Box 11, NL-6114-ZG Susteren, The Netherlands
Phone: +31 46 4389444
● All rights reserved. No part of this book may be reproduced in any material form, including photocopying, or
storing in any medium by electronic means and whether or not transiently or incidentally to some other use of this
publication, without the written permission of the copyright holder except in accordance with the provisions of the
Copyright Designs and Patents Act 1988 or under the terms of a licence issued by the Copyright Licencing Agency
Ltd., 90 Tottenham Court Road, London, England W1P 9HE. Applications for the copyright holder's permission to
reproduce any part of the publication should be addressed to the publishers.
● Declaration
The Author and Publisher have used their best efforts in ensuring the correctness of the information contained in
this book. They do not assume, and hereby disclaim, any liability to any party for any loss or damage caused by
errors or omissions in this book, whether such errors or omissions result from negligence, accident, or any other
cause.
All the programs given in the book are Copyright of the Author and Elektor International Media. These programs
may only be used for educational purposes. Written permission from the Author or Elektor must be obtained before
any of these programs can be used for commercial purposes.
● British Library Cataloguing in Publication Data

A catalogue record for this book is available from the British Library
● ISBN 978-3-89576-519-3 Print

ISBN 978-3-89576-520-9 eBook
● Second, revised edition

© Copyright 2022: Elektor International Media B.V.
Editor: Jan Buiting
Prepress Production: D-Vision, Julian van den Berg
Elektor is part of EIM, the world's leading source of essential technical information and electronics products for pro
engineers, electronics designers, and the companies seeking to engage them. Each day, our international team develops
and delivers high-quality content - via a variety of media channels (including magazines, video, digital media, and social
media) in several languages - relating to electronics design and DIY electronics. www.elektormagazine.com
●4
PID-based Practical Digital Control With Raspberry Pi and Arduino Uno 220802 v3 UK.indd 4 11/10/2022 13:54
Contents
Contents
Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Chapter 1 • Control Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1 Open-loop and closed-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Microcontroller in the loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Control system design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Chapter 2 • Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1 Sensors in Computer Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 Analog Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2 Digital Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3 Position Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4 Velocity and Acceleration Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5 Force Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.6 Pressure sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.7 Liquid Sensors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.8 Flow Sensors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Chapter 3 • Transfer Functions and Time Response . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2 First-order Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2.1 Time Response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3 Second-order Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3.1 Time Response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4 Time Delay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.5 Transfer Function of a Closed-loop System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Chapter 4 • Discrete Time (Digital) Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2 The Sampling Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3 The Z-Transform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.1 Unit step function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.2 Unit ramp function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
●5
PID-based Practical Digital Control
4.3.3 Tables of z-Transforms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.4 The z-Transform of a function expressed as a Laplace Transform. . . . . . . . . . . . . . 58
4.5 Inverse z-Transforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.6 Pulse transfer function and manipulation of block diagrams . . . . . . . . . . . . . . . . . 61
4.6.1 Open-loop systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7 Open-loop time response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.8 Closed-loop system time response. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Chapter 5 • The PID Controller in Continuous-Time Systems . . . . . . . . . . . . . . . . . 69
5.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.2 Proportional-only Controller with a First-Order System. . . . . . . . . . . . . . . . . . . . . 70
5.3 Integral-Only Controller with a First-order System. . . . . . . . . . . . . . . . . . . . . . . . 71
5.4 Derivative-only Controller with a First-order System . . . . . . . . . . . . . . . . . . . . . . 72
5.5 Proportional + Integral Controller with a First-order System . . . . . . . . . . . . . . . . . 73
5.6 Proportional + Integral + Derivative controller with a First-order System . . . . . . . . 74
5.7 Effects of Changing the PID Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.8 Tuning a PID Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.8.1 Open-loop Ziegler and Nichols Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.8.2 Open-loop Cohen-Coon PID Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.8.3 Closed-loop Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.8.4 Practical PID Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.9 The Auto-tuning PID Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.10 Increasing and Decreasing PID Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.11 Saturation and Integral Wind-up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.12 Derivative Kick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.13 Using the PID Loop Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Chapter 6 • The Digital PID Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.2 Digital PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.3 Choosing a Sampling Time, T . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
6.4 Microcontroller Implementation of the PID Algorithm . . . . . . . . . . . . . . . . . . . . . . 91
Chapter 7 • On-Off Temperature Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
●6
Contents
7.2 Temperature Controllers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.3 Project 1: ON-OFF Temperature Control with Arduino Uno . . . . . . . . . . . . . . . . . . 94
7.4 Project 2: ON-OFF Temperature Control with Hysteresis and Arduino Uno . . . . . . . 99
7.5 Project 3: ON-OFF Temperature Control with Button Control – Arduino Uno . . . . . 101
7.6 Project 4: ON-OFF Temperature Control with Rotary Encoder and Arduino Uno . . . 104
7.7 Project 5: ON-OFF Temperature Control with Raspberry Pi 4 . . . . . . . . . . . . . . . . 109
Chapter 8 • PID Temperature Control with the Raspberry Pi . . . . . . . . . . . . . . . . 119
8.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.2 Project 1 - Reading the temperature of a thermistor . . . . . . . . . . . . . . . . . . . . . 119
8.3 Project 2: Open-loop Step-input Time Response . . . . . . . . . . . . . . . . . . . . . . . . 123
8.4 Project 3: PI Temperature Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.5 Project 4: PID Temperature Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
8.6 Using the PID Loop Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Chapter 9 • PID Temperature Control with the Arduino Uno. . . . . . . . . . . . . . . . . 144
9.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
9.2 Project 1: Reading the Temperature of a Thermistor . . . . . . . . . . . . . . . . . . . . . 144
9.3 Project 2: PID Temperature Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
9.4 Project 3: PID Temperature Control with Arduino Uno and Timer Interrupts . . . . . 152
9.5 Project 4: PID Temperature Control using the Arduino Uno PID Library . . . . . . . . 155
Chapter 10 • DC Motor Control with Arduino and Raspberry Pi. . . . . . . . . . . . . . . 160
10.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
10.2 Types of Electric Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
10.3 Brushed DC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
10.3.1 Permanent-magnet BDC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
10.3.2 Series-wound BDC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
10.3.3 Shunt-wound BDC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
10.3.4 Compound-wound BDC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
10.3.5 Separately-excited BDC Motors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
10.3.6 Servo Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
10.3.7 Stepper Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
10.4 Brushless DC Motors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
10.5 Motor Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
●7
10.6 Transfer Function of a Brushed DC Motor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
10.7 The DC Motor Used in the Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
10.8 Project 1: Motor Speed and Direction Control Using an H-Bridge Integrated Circuit 170
10.9 Project 2: Displaying the Motor Speed with Arduino Uno. . . . . . . . . . . . . . . . . . 177
10.10 Project 3: Displaying Motor Speed on LCD with Arduino Uno . . . . . . . . . . . . . . 181
10.11 Project 4: Displaying Motor Speed with Raspberry Pi . . . . . . . . . . . . . . . . . . . 184
10.12 Project 5: Displaying Motor Speed on LCD with Raspberry Pi . . . . . . . . . . . . . . 186
10.13 Project 6: Identification of the DC Motor with Raspberry Pi . . . . . . . . . . . . . . . 188
10.14 Project 7: PID Motor Speed control with Raspberry Pi. . . . . . . . . . . . . . . . . . . 191
10.15 Project 8: PID Motor Speed Control with Arduino Uno . . . . . . . . . . . . . . . . . . 195
Chapter 11 • Water Level Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.2 Ultrasonic Transmitter-Receiver Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.3 Project 1: Measuring Distance using the HC-SR04 Ultrasonic Module with
Arduino Uno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.4 Project 2: Measuring Distance using the HC-SR04 Ultrasonic Module with
Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
11.5 Project 3: Step Input Response of the System with Raspberry Pi . . . . . . . . . . . . 206
11.6 Project 4: PID-based Water Level Control with Raspberry Pi . . . . . . . . . . . . . . . 210
11.7 Project 5: PID-based Water Level Control with Arduino Uno . . . . . . . . . . . . . . . 215
Chapter 12 • PID-based LED Brightness Control . . . . . . . . . . . . . . . . . . . . . . . . . . 220
12.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
12.2 Project 1: Step Time Response of LED Brightness Control using the Raspberry Pi 220
12.3 Project 2: PID-Based LED Brightness Control using the Raspberry Pi . . . . . . . . . 224
12.4 Project 3: PID-based LED Brightness Control using the Arduino Uno . . . . . . . . . 229
12.5 Project 4: PID-based LED Brightness Control using the Arduino Uno Library . . . . 232
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
●8
Preface
Microcontrollers are highly popular integrated circuits commonly used in many domestic,
commercial, and industrial electronic monitoring and control applications. It is estimated
that there are more than 50 microcontrollers in every home in developed countries. Do-
mestic equipment having embedded microcontrollers include microwave ovens, printers,
keyboards, computers, tablets, washing machines, dishwashers, smart televisions, smart-
phones, and many more.
Arduino Uno is an open-source microcontroller development system incorporating hard-

ware, an Integrated Development Environment (IDE), and a large number of libraries. The
Arduino Uno is supported by a large community of programmers, electronic engineers,
enthusiasts, and academics. There are many different designs of the basic Arduino Uno
board. Although they are intended for different types of applications, they can all be pro-
grammed using the same IDE and in general, programs can be transported between differ-
ent boards. This may be one of the reasons for the popularity of the Arduino family, which
is also supported by countless software libraries for many peripherals that can easily be
included in your programs. These libraries make programming a doddle and speed up the
programming time. Using libraries also make it easier to test your programs since most of
them come as fully tested and working.
The Raspberry Pi 4 is one of the latest credit-card sized popular computers that can be used
in many applications such as in audio and video media centers, as a desktop computer, in
industrial controllers, robotics, games, and many domestic and commercial applications. In
addition to rich set of features found in other Raspberry Pi computers, the Raspberry Pi 4
also offers Wi-Fi and Bluetooth capability which makes it highly desirable for incorporation
in remote and Internet-based control and monitoring applications.
This book is about using both the Raspberry Pi 4 and the Arduino Uno in PID-based auto-
matic control applications. The book starts with basic theory of the control systems and
feedback control. Working and tested projects are given for controlling real systems using
PID controllers. The open-loop step time response, tuning the PID parameters, and the
closed-loop time response of the developed systems are discussed in depth together with
the block diagrams, circuit diagrams, PID controller algorithms, and the full program list-
ings for the Raspberry Pi as well as the Arduino Uno. The projects given in the book should
teach the theory and applications of PID controllers. They can be modified easily as desired
for other applications. The projects given for Raspberry Pi 4 should work with all other
It is expected that the readers have some programming experience with the Arduino Uno
using the Arduino IDE. The same for the Raspberry Pi with the Python 3 programming lan-
guage. Some basic electronic hardware experience and knowledge of basic mathematics
will also be useful.
●9
All programs discussed in the book are contained in an archive file you can download free
of charge from the Elektor website. Head to: www.elektor.com/books and enter the book
title in the Search box.
I hope that you enjoy reading the book and at the same time learn the theory and practical
applications of the PID controllers.
Dogan Ibrahim
London, 2022
● 10
Chapter 1 • Control Systems
1.1 Open-loop and closed-loop

Control engineering covers all aspects of governing a dynamic system, also called a plant
or a process. A plant can be a mechanical system, an electrical system, a thermal system,
a fluid system, or a combination of such systems.
A plant can have one or more inputs and one or more outputs. The dynamic behavior of a
plant is described by differential equations. Given the model (or the differential equations),
inputs, and initial conditions of a plant we can easily calculate its outputs. Generally, a
plant is a continuous-time system with its inputs and outputs also continuous in time. For
example, an electromagnetic motor is a continuous-time plant whose input (e.g., voltage
or current) and its output (e.g., speed or position) are also continuous in time.
Control engineering is based on the theories of system modelling, feedback, system re-
sponse, and stability. As a result, control engineering is not limited to only one engineering
discipline, but is equally applicable to mechanical, chemical, aeronautical, civil, and electri-
cal engineering disciplines.
A plant is normally an open-loop system (Figure 1.1) where an actuating device is used
to control the plant directly without using feedback. For example, a motor is expected to
rotate when a voltage is applied across its input terminals, but we do not know by how
much the motor rotates since there is no knowledge about its output. If the motor shaft is
loaded and the motor slows down, there is no knowledge about this. As shown in Figure
1.1, a plant may also have external disturbances affecting its behavior, and in an open-loop
system there is no way of knowing or minimizing such disturbances.
Figure 1.1: Open-loop system
In contrast to open-loop control system, in a closed-loop control system (Figure 1.2) the
actual plant output is measured and compared with what we would like to see at the plant
output. The measure of the output is called feedback signal. The difference between
the desired output value and the actual output value is called the error signal. The error
signal is used to force the system output to a point such that the desired output value and
the actual output value are equal, i.e., the error signal is zero. One of the advantages of
closed-loop control, or feedback control is the ability to compensate for disturbances and
yield the correct output even in the presence of disturbances. Also, the plant output settles
● 11
and remains at the desired value. For example, in a motor speed control system the speed
of the motor remains the same when load is applied to the motor shaft. A controller (or
compensator) is usually used to read the error signal and drive the plant in such a way
that the error tends to zero.
Sensors are devices which measure the plant output. For example, a thermistor is a sensor
used to measure the temperature and it can be used in a closed-loop thermal plant control.
Similarly, a tachometer or an encoder can be used to measure the rotational speed of a
motor and they can be used in closed-loop motor speed control applications. Notice that
in electrical systems a power amplifier may be required after the DAC to drive the plant.
Figure 1.2: Closed-loop system
As you'll discover in a later Chapter, most sensors are analog devices giving analog voltage
or current outputs. These sensors can be used directly in analog systems where the inputs,
controller, plant, and the outputs are all analog variables.
1.2 Microcontroller in the loop

Nowadays, practically all control systems are microcontroller based, where a microcon-
troller is used as the central control device. Some sensors (e.g., temperature, pressure,
humidity etc.) provide digital outputs and can be connected directly to a microcontroller.
Analog sensors cannot be connected directly to a microcontroller. An analog-to-digital con-
verter (ADC) is needed to convert the analog signal into digital form so that it can be fed
to a microcontroller.
Figure 1.3 shows a digital control system where the input and the output of the sensor are
assumed to be analog. An ADC is used to periodically convert the error signal into digital
form and this is fed to a digital controller which is usually a microcontroller. The microcon-
troller implements a control algorithm (e.g., PID algorithm) and its output is converted into
analog form using a digital-to-analog converter (DAC) so that it can drive the plant to set
the plant output to the desired value.
Figure 1.3: Digital control system.
● 12
Figure 1.4 shows the block diagram of a digital control system where the ADC is shown as
a sampler. Most microcontrollers incorporate ADC and DAC modules and these are shown
as part of the microcontroller in Figure 1.4.
Figure 1.4: Block diagram of a digital control system.
In Figure 1.4 the input and the sensor output are analog signals. A variation of this system
is shown in Figure 1.5 where the input is digital and is either hardcoded to the microcon-
troller software or is input using a suitable input device such as a keypad. Here, a sensor
with digital output is used and is connected directly to the microcontroller.
Figure 1.5: Another variation of digital control.
Figure 1.6 shows a typical analog speed control system. Here, the desired speed is set
using a potentiometer. The speed of the motor is measured using a tachometer and is fed
back to a difference amplifier. The output of this amplifier is the error signal which is input
to an analog controller consisting of operational amplifiers. The output of the controller
drives the motor through a power amplifier to achieve the desired speed.
Figure 1.6: Analog speed control system.
● 13
Figure 1.7 shows the digital equivalent of Figure 1.6. Here, a digital encoder is used to
measure the motor speed and this is fed to the microcontroller together with the desired
speed where the speed is set using a keypad. The microcontroller implements the control
algorithm and sends its output to the power amplifier in the form of a Pulse Width-Modulat-
ed (PWM) signal which in turn provides power to the motor to set the speed at the desired
value.
Figure 1.7: Digital speed control system.
Since a plant can be controlled using an analog approach, you might be tempted to ask
why use digital control? In the 1960s, computers and microcontrollers were bulky and very
expensive devices and their use as digital controllers was not justified. They were only used
in large and expensive plants, such as large chemical processing sites or oil refineries. Since
the introduction of microcontrollers in 1970s, the cost and size of digital controllers have
dropped dramatically. As a result of this, also from the drop in the price of other digital
components such as memories, interest in using digital control has soared in the past few
decades.
Digital controllers have several advantages compared to analog controllers:
• Improved user interface. Digital controllers can display the system parameters
and response graphically on a monitor.
• Digital controllers can be configured to be adaptive. Complex controller
algorithms can easily be implemented using digital controllers.
• The cost of digital controllers are lower than the analog ones, especially if
additional control loops have to be added to the system.
• It is easy to tune digital controllers. All that is required is to change pertinent
parameters in software.
• Digital controllers are more dependable than the analog ones and they are
not affected by environmental factors such as component aging, component
tolerances, etc.
• Digital controllers can be modified easily through software. Modification of
an analog controller on the other hand usually require re-wiring or the use of
different or additional components.
• Almost all analog controllers have been replaced over time by digital ones.
● 14
1.3 Control system design

Control system design is an engineering process and it must be carried out systematically.
The major steps to design a physical control system can be summarized by the following
steps:
• Define the system input and output

• Define the variable to be controlled
• Derive a mathematical model (differential equations) of the system
• Decide whether analog or digital control is to be used
• Choose a suitable sensor
• Choose a microcontroller (if digital control is to be used)
• Choose other components such as power supply, op-amp, power amplifier etc.
• Draw a block diagram of the system
• Describe the controller to be used and develop the control algorithm
• Adjust the parameters of the chosen controller
• Simulate the overall system (if simulation tools such as MATLAB are available)
• Assemble the system and observe its behavior. If the system response is as
desired, that concludes the project. If on the other hand the system does not
behave as required, go back to choose a different controller or to re-adjust the
controller parameters, re-simulate and re-test.
● 15
PID-based Practical Digital Control Chapter 2 • Sensors
Chapter 2 • Sensors
2.1 Sensors in Computer Control

Sensors are important parts of all closed-loop systems. A sensor is a device that outputs a
signal which is related to the measurement (i.e., is a function of) a physical quantity, such
as temperature, humidity, speed, force, vibration, pressure, displacement, acceleration,
torque, flow, light or sound. Sensors are used in closed-loop systems in the feedback loops,
and they provide information about the actual output of the plant they are attached to. For
example, a speed sensor gives a signal proportional to the speed of a motor and this signal
is subtracted from the desired speed reference input in order to obtain the error signal.
Similarly, a liquid level sensor gives a signal proportional to the level of liquid in a container.
Such a sensor is used in controlling the level of a liquid in a container.
Sensors can be divided into two groups: analog or digital. Analog sensors are widely used
and their outputs are analog signals (e.g., voltage or current) proportional to the physical
quantity to be measured. Most environmental variables in the world are analog by nature,
for example the temperature, humidity, pressure etc. An analog temperature sensor gives
an analog voltage directly proportional to the measured temperature. Analog sensors can
only be connected to microcontrollers using ADC converter modules.
Digital sensors are not very common and they give digital logic level outputs which can be
directly connected to a computer. The advantage of using digital sensors is that they are
more accurate and stable than the analog ones and they can directly be connected to a
computer. Digital sensors also tend to me more expensive than their analog equivalents.
The choice of a sensor for a particular application depends on several factors such as the
availability, cost, accuracy, precision, resolution, range, and linearity of the sensor. Some
important sensor related parameters are described below.
Range: The range of a sensor specifies the upper and lower limits that can be measured
by the sensor. For example, if the range of a temperature sensor is specified as 10 – 60 ºC
then the sensor should only be used to measure temperatures within this range.
Resolution: The resolution of a sensor is specified as the largest change in measured value
that will not result in a change in sensor's output. i.e., the measured value can change by
the amount quoted by the resolution before this change can be detected by the sensor. In
general, the smaller this amount the better the sensor is, and sensors with a wide range
have less resolution. For example, a temperature sensor with a resolution of 0.01 ºC is
better than a sensor with a resolution of 0.1 ºC.
Sensitivity: The sensitivity of a sensor is defined as the slope of the output characteris-
tic curve. More generally, it is the minimum input of physical parameter that will create a
detectable output change. For example, a typical temperature sensor may have a sensi-
tivity rating of 1 ºC. This means that the output voltage will not change if the temperature
change is less than 1 ºC .
● 16
Accuracy: The accuracy of a sensor is the maximum difference that will exist between
the actual value and the indicated value at the output of the sensor. The accuracy can be
expressed either as a percentage of full scale or in absolute terms.
Repeatability: The repeatability of a sensor is the variation of output values that can be
expected when the sensor measures the same physical quantity with the same conditions.
For example, if the voltage across a resistor is measured at the same time several times
you may get slightly different results.
Linearity: An ideal sensor is expected to have a linear transfer function. i.e., the sensor
output is expected to be exactly proportional to the measured value. For example, the
LM35 temperature sensor chip output is linear and is specified as 10mV/ºC. At 10 ºC the
output voltage is 100 mV, at 20 ºC it is 200 mV and so on. In practice all sensors exhibit
some amount of nonlinearity depending upon the manufacturing tolerances and the meas-
urement conditions.
Offset error: The offset error of a sensor is defined as the output that will exist when it
should be zero. For example, the output of a force sensor should be zero if there is no force
applied to the sensor.
Dynamic response: The dynamic response of a sensor specifies the limits of the sensor
characteristics when the sensor is subject to a sinusoidal frequency change. For example,
the dynamic response of a microphone may be expressed in terms of the 3-dB bandwidth
of its frequency response.
Response time: Sensors do not change their output states immediately when an input
parameter change occurs. For example, a temperature sensor does not give new reading
as soon as the temperature changes, but rather, it will take some time before the output
changes. The response time can be in microseconds, milliseconds, or seconds depending
upon the sensor used. Sensors with short response times, although more expensive, are
preferred in most applications.
Self-heating: The internal temperatures of some sensors may increase when used con-
tinuously for long times and this is called self-heating. Self-heating is not desirable as it
may cause the output of the sensor to change. For example, a temperature sensor with
self-heating feature may give wrong and fluctuating outputs as the sensor is used over
time.
Physical size: The physical size of a sensor can be important in some applications. Users
should check the dimensions of a sensor before it is considered for use.
Operating voltage: This is also an important factor to consider before a sensor is used.
The operating voltage, as well as the minimum and maximum voltages that can be applied
to the sensor should be known before a sensor is used. For example, if the operating volt-
age is specified as +3.3 V then this value must not be exceeded.
● 17
In the remainder of this Chapter, the operation and characteristics of some popular sensors
are discussed.
2.2 Temperature Sensors

Temperature is one of the fundamental physical variables in most chemical and process
control applications. Accurate and reliable measurement of the temperature is important
in all process control applications. The choice of a temperature sensor depends on the
required accuracy, temperature range, response time, cost, and the environment where
it will be used (e.g., chemical, electrical, mechanical, environmental etc.). Temperature
sensors are available as either analog or digital. Both sensor types are described briefly in
the following sections.
2.2.1 Analog Temperature Sensors

Some of the most commonly used analog temperature sensors are: thermocouples, re-
sistance temperature detectors (RTDs), thermistors, and sensors in te form of chips (in-
tegrated circuits). Table 2.1 shows the basic characteristics of different types of analog
temperature sensors.
Sensor Temperature range ( ºC ) Accuracy (± ºC ) Cost Robustness
Thermocouple –270 to +2600 1 Low Very high
RTD –200 to +600 0.2 Medium High
Thermistor –50 to +200 0.2 Low Medium
Integrated circuit –40 to +125 1 Low Low
Table 2.1: Analog temperature sensors.
Thermocouples
Thermocouples (Figure 2.1) are best suited to very low and very high temperature meas-
urements. They have the advantages that they are low-cost, very robust, and they can be
used in chemical environments. The typical accuracy of a thermocouple is ±1 ºC. Thermo-
couple temperature sensors can be made with various conductor materials for different
temperature ranges and output characteristics. Thermocouple types are identified with sin-
gle letters of the alphabet. Figure 2.1 shows the temperature ranges of various thermocou-
ples. Notice that lead color codes are used to identify thermocouples. The materials used
to form thermocouples is shown in Figure 2.2. For example, one of the commonly used
low-cost thermocouples is Type K which is made from chromel/alumel junction, identified
with green lead color, and has temperature range of –180 ºC to +1300 ºC .
● 18
Figure 2.1: Thermocouple types.
Figure 2.2: Materials used in different thermocouples.
To get the temperature from a thermocouple a thermocouple amplifier is generally used.

The temperature output from the thermocouple amplifier depends on the voltage of the
reference junction. The voltage at the reference junction depends on the temperature dif-
ference between the reference junction and the thermal junction. Therefore, you need to
know the temperature at the reference junction. The MAX6675 thermocouple amplifier
module (Figure 2.3) comes with an on-board temperature sensor to measure temperature
at the reference junction and also amplifies the small thermocouple voltage at the reference
junction so that you can read it using a microcontroller.
● 19
Figure 2.3: MAX6675 thermocouple amplifier module.
Thermocouples are available in various shapes and forms. Some sensors are equipped with
2-way plugs for ease of connecting to a measuring device. Figure 2.4 shows some of the
commonly available thermocouples.
Figure 2.4: Some thermocouples.
RTDs
RTDs (Resistance Temperature Detector) are sensors whose resistance changes with tem-
perature. The resistance increases as the temperature of the sensor increases. The resist-
ance vs temperature relationship is well known and repeatable over time. RTDs are passive
devices and they do not produce any output. Usually, the resistance of an RTD is measured
by passing a small electrical current through it and then measuring the voltage across the
sensor. Care should be taken not to pass large currents as self-heating of the sensor may
occur. Typically, 1 mA or less current is passed through the sensor. Figure 2.5 shows some
RTD sensors. RTDs have excellent accuracies over a wide temperature range and some
RTDs have accuracies better than 0.001 ºC . another advantage of the RTDs is that they
drift less than 0.1 ºC /year.
Figure 2.5: Some RTDs.
● 20
In order to achieve high stability and accuracy, RTD sensors must be contamination free.
Below about 250 ºC the contamination is not much of a problem, but above this tem-
perature, special manufacturing techniques are used to minimize the contamination. RTD
sensors are usually manufactured in two forms: wire wound, or thin film. Wire-wound
RTDs are made by winding a very fine strand of platinum wire into a coil shape around a
non-conducting material until the required resistance is obtained. Thin-film RTDs are made
by depositing a layer of platinum in a resistance pattern on a ceramic substrate. The most
commonly used RTD standard is the IEC 751 which is based on platinum with a resistance
of 100 Ω at 0 ºC.
For high accuracy it is recommended to use an RTD-to-digital converter module like the
MAX31865 module (Figure 2.6). This chip is optimized for platinum RTDs. An accurate ref-
erence resistor is used to set the sensitivity for the RTD. An on-chip ADC returns the ratio
of the RTD resistance to the reference resistance in digital form. Knowing the reference re-
sistance, you can easily calculate the RTD resistance and hence the measured temperature
either from temperature-resistance tables or using a library function.
Figure 2.6: MAX31865 RTD converter module.
Thermistors
The name thermistor derives from the words thermal and resistor. Thermistors are
temperature sensitive passive semiconductors which exhibit a large change in electrical
resistance when subjected to a small change in body temperature. Thermistors are man-
ufactured in a variety of sizes and shapes (Figure 2.7). beads, discs, washers, wafers, and
chips are the most widely used thermistor sensor types.
● 21
Figure 2.7: Different shapes of thermistors.
Thermistors are generally available in two types: Negative Temperature Coefficient (NTC)
and Positive Temperature Coefficient (PTC). PTC thermistors are generally used in power
circuits for inrush current protection. NTC thermistors exhibit many desirable features for
temperature measurement. Their electrical resistance decreases with increasing tempera-
ture (Figure 2.8) and the resistance-temperature relationship is very nonlinear. The resist-
ance of a thermistor is referenced to 25 ºC and for most applications the resistance at this
temperature is between 100 Ω and 100 kΩ.
Figure 2.8: Typical thermistor R/T characteristic.
The advantages of NTC thermistors are:
Sensitivity: One of the advantages of thermistors compared to thermocouples and RTDs

is their large change in resistance with temperature, typically –5% per ºC.
Small size: Thermistors have very small sizes and this makes for a very rapid response
to temperature changes. This feature is very important in temperature feedback control
systems where a fast response may be required.
Ruggedness: Most thermistors are rugged and can handle mechanical and thermal shock
and vibration better than other types of temperature sensors.
● 22
Remote measurement: Thermistors can be used to sense the temperature of remote

locations via long cables because the resistance of a long cable is insignificant compared to
the relatively high resistance of a thermistor.
Low-cost: Thermistors cost less than most other types of temperature sensors.
Interchangeability: Thermistors can be manufactured with very close tolerances. As a

result, it is possible to swap thermistors without having to recalibrate the measurement
system.
Thermistors can suffer from self-heating problems as a result of current passing through
them. When a thermistor self-heats, the resistance reading drops relative to its true value
and this causes errors in the measured temperature. It is therefore important to minimize
the electrical current through a thermistor.
Thermistors can be used in circuits in series with a known accurate fixed resistor. By meas-
uring the voltage across the thermistor, you can calculate its resistance. Alternatively,
constant current, bridge, or operational amplifier circuits can be designed to measure the
resistance of a thermistor. After finding the resistance of a thermistor, you can calculate
the temperature using tables (if available), or a library function (if available), or use the
standard Steinhart-Hart equation given below:
or
Where T0 is the room temperature in K (298.15), B is the thermistor temperature constant,

R0 is the thermistor resistance at room temperature, and R is the measured resistance of
the thermistor. An example is given below.
Example
The temperature constant of a thermistor is B = 2910. Also, its resistance at room tem-
perature (25 ºC ) is 1 kΩ. This thermistor is used in an electrical circuit to measure the
temperature and it is found that the resistance of the thermistor is 800 Ω. Calculate the
measured temperature.
Solution
Here, you know that B = 2910, T0 = 298.15, R = 800 Ω, and R0 = 1000 Ω
● 23
Kelvin
or T = 310.24 – 273.15 = 37.09 ºC
Integrated circuits
Integrated circuit analog sensors are semiconductor devices. they differ from other sensors
in some fundamental ways:
• They have relatively small physical sizes.

• Their outputs are linear.
• The temperature range is relatively limited.
• The cost is relatively low.
• They often lack good thermal contacts with the outside world and as a result it
is usually more difficult to use them other than measuring the air temperature.
• A power supply is required to operate these sensors.
Analog integrated circuit temperature sensor can be voltage output or current output. In
this section you will look at the characteristics of some commonly used sensors.
LM35DZ
This is a popular 3-pin temperature sensor (Figure 2.9) chip whose output voltage is linear,
given by 10 mV/ ºC . For example, at 10 ºC the output voltage is 100 mV, at 20 ºC it is
200 mV and so on. this sensor has the range 0 ºC to +100 ºC (the CZ version of this sen-
sor has a wider temperature range like –20 ºC to +120 ºC ). The accuracy of this sensor
is ±1.5 ºC and the operating voltage is 4 to 30 V.
Figure 2.9: The LM35DZ temperature sensor.
The LM34 is similar to the LM35DZ but it measures in degrees Fahrenheit. The LM134,
AD590, and AD592 are current-output temperature sensors where the output current is di-
rectly proportional to the measured temperature. For example, the output of AD590 (Figure
2.10) is given as 1 µA/K.
● 24
Figure 2.10: AD590 temperature sensor.
TMP36
This is another popular analog integrated circuit temperature sensor chip. The size and
configuration of the sensor is same as in Figure 2.9. The output of TMP36 is linear with the
measured temperature given by: Vo – 500 /10, where Vo is the sensor output voltage in
millivolts.
2.2 Digital Temperature Sensors

These sensors produce digital outputs and therefore they can be directly connected to
microcontrollers. The outputs are non-standard and the measured temperature can be
extracted in software by using a suitable algorithm. Table 2.2 gives a list of some popular
digital output temperature sensors.
Sensor Output Maximum error Temperature range
LM75 I2C ±3 ºC –55 ºC to +125 ºC
TMP03 PWM ±4 ºC –25 ºC to +100 ºC
DS18B20 1-Wire ±0.5 ºC –55 ºC to +125 ºC
AD7814 SPI ±2 ºC –55 ºC to +125 ºC
MAX6575 1-Wire ±0.8 ºC –40 ºC to +125 ºC
DHT11 Serial 1 wire ±2 ºC 0 ºC to +50 ºC
DHT22 Serial 1 Wire ±0.5 ºC –40 ºC to +80 ºC
Table 2.2: Some digital-output temperature sensors.
DHT11 and DHT22 (Figure 2.11) are highly popular 3-terminal digital output sensors. Both
devices can measure temperature as well as relative humidity. Arduino and Raspberry Pi li-
braries are available for both sensors for reading the temperature and humidity data easily.
● 25
Figure 2.11: The DHT11 and DHT22 sensors.
2.3 Position Sensors

Position sensors are used to measure the position of moving objects. These sensors are
basically of two types: sensors to measure linear movement, and sensors to measure an-
gular movement.
The simplest position sensor is a potentiometer. Potentiometers are available in linear and
rotary forms. In a typical application, a fixed voltage is applied across the potentiometer
and the voltage across the potentiometer arm is measured. This voltage is proportional to
the position of the arm, and hence by measuring the voltage you know the position of the
arm. Figure 2.12 shows a linear potentiometer. If the applied voltage is Vi , the voltage
across the arm is given by:
Va = k Vi y
where y is the position of the arm from the beginning of the potentiometer, and k is a
constant.
Figure 2.12: Linear potentiometer.
● 26
Figure 2.13 shows a rotary potentiometer which can be used to measure angular position.
If Vi is again the applied voltage, the voltage across the arm is given by:
Va = k Vi θ
where θ is the arm angle and k is a constant.
Figure 2.13: Rotary potentiometer.
Other types of position sensors are capacitive sensors, inductive sensors, linear variable
differential transformers (LVDTs), magnetic linear encoders, optical encoders, ultrasonic
sensors etc. Capacitive position sensors rely on the fact that the capacitance of a paral-
lel-plate capacitor changes as the distance between the plates is changed. These sensors
are used in micrometer and millimeter applications where their resolution can be in nano-
meters (e.g., the MicroSense Model 4810).
LVDT sensors (Figure 2.14) consist of one primary and two secondary windings on a hollow
cylinder. A magnetic core which measures the position moves inside the cylinder, and the
movement of this core varies the magnetic field linking the primary winding to the second-
ary windings. The movement of the core to one position increases the induced voltage in
one secondary coil and decreases the induced voltage in the other secondary coil. The net
voltage difference is proportional to the position of the core inside the cylinder. Thus, by
measuring the induced voltage you know the position of the core.
The advantages of LVDT are:
• low cost
• robust design
• no hysteresis effect
• fast response time;
• no friction resistance
• long life
● 27
To be fair, the main disadvantage of the LVDT is that the core must have direct contact with
the measured surface, which may not always be possible.
Figure 2.14: LVDT position sensor.
A magnetic linear encoder system uses a magnetic sensor head and a magnetic scale to
produce analog or digital output. As the magnetic sensor head passes along the magnetic
scale, the sensor detects the change in magnetic field and outputs a signal to indicate the
position of the head.
Optical encoders are sensors commonly used for measuring the position or speed of a
rotating body. There are several different types of optical encoders. In its simplest applica-
tion, the device consists of a shaft connected to a circular disc with holes on it (Figure 2.15).
A light beam shines from one side and a light detector is used at the other side. By counting
the holes passing in-front of the sensor you can tell the position or the speed of the rotating
shaft. Other types of optical encoders use the Hall-effect principle where one or more small
magnets are attached to the rotor and the magnetic field is detected as the rotor rotates.
Using two such magnets you can determine the direction of rotation of the rotor.
Figure 2.15: Optical encoder.
2.4 Velocity and Acceleration Sensors

One of the widest used rotary velocity sensors is the tach generator. A tachometer (Figure
2.16) is connected to the shaft of a rotating device (e.g., a motor) and produces an analog
DC voltage which is proportional to the speed of the shaft. If ω is the angular velocity of the
shaft, the output voltage of the tachometer is given by:
● 28
Vo = k ω
where k is the gain constant of the tachometer. Another popular velocity sensor is the op-
tical encoder as shown in Figure 2.15 and described earlier.
Figure 2.16: Commercially available tachogenerator.
Acceleration is the differentiation of velocity, or the double differentiation of position. Thus,

in general, position or velocity sensors can be used to measure acceleration. The differen-
tiation can be done either by using operational amplifiers or by a computer program. For
accurate measurement of the acceleration, semiconductor accelerometers can be used.
For example, the ADXL203 is an accelerometer chip manufactured by Analog Devices Inc.
The chip is tiny (5 × 5 × 2 mm) and it is available as a module on a small board (see Fig-
ure 2.17). This is a low-cost 8-pin chip with two outputs to measure the acceleration in
two dimensions. The outputs are digital signals whose duty cycles are proportional to the
acceleration in each of the two axes. These outputs can be connected directly to a micro-
controller and the acceleration can be measured very easily, requiring no A/D converter.
The measurement range of the ADXL203 is ±1.7 g to ±18 g, where g is acceleration due to
gravity, and the device can measure both dynamic acceleration (e.g., vibration), and static
acceleration (e.g., gravity).
Figure 2.17: ADXL203 accelerometer module.
● 29
2.5 Force Sensors

Load cells are commonly used in force sensor applications. Load cells can use different
technologies to produce an output. Some load cell types are: hydraulic, pneumatic, induc-
tive, capacitive, piezoelectric, strain gauge et.
Strain gauges can be used to measure force accurately. There are many different types of
strain gauges. A strain gauge can be made from capacitors and inductors, but the most
widely used types are made from resistors. A wire strain gauge is made from a resistor, in
the form of a metal foil. The principle of operation is that the resistance of a wire increases
with increasing strain and decreases with decreasing strain. In order to measure strain
with a strain gauge, it must be connected to an electrical circuit, and a Wheatstone bridge
is commonly used to detect the small changes in the resistance of the strain gauge. Strain
gauges can be used to measure force, load, weight pressure, torque or displacement.
Force can also be measured using the principle of piezoelectricity. A piezoelectric sensor
produces voltage when a force is applied to its surface. The disadvantage of this method is
that the voltage decays after the application of the force and thus piezoelectric sensors are
only useful for measuring dynamic force.
Some of the popular force sensors used in microcontroller applications are the FlexiForce
sensors. For example, the A201 is a variable resistance flexible force sensor (Figure 2.18)
that can be used to measure force from 4.4N to up to 440N. This is a 191mm long, 14mm
wide flexible sensor. The sensor is usually used with an operational amplifier where the
output voltage is proportional to the measured force.
Figure 2.18: A201 force sensor.
2.6 Pressure sensors

Pressure sensors are used to measure the pressure in air, liquid or gas. There are basically
three types of pressure sensors: relative (or gauge) pressure sensors, absolute pressure
sensors, differential pressure sensors.
● 30
Relative pressure sensors measure the pressure relative to the ambient atmospheric pres-
sure. It is positive for pressures higher than atmospheric, or negative for lower pressures.
These sensors have two ports to allow the reference pressure and the pressure to be meas-
ured.
Absolute pressure sensors give the result relative to perfect vacuum (i.e., zero pressure).
These sensors have one port for the pressure to be measured. These sensors can be used
to measure the atmospheric pressure (e.g., for determining the altitude).
Differential pressure sensors measure the difference in pressure between two points, simi-
lar to relative sensors, but here the reference pressure may not have to be the atmospheric
pressure.
There are many pressure sensors available that can be used with microcontrollers. For
example, the Adafruit MPRLS 3965 module (Figure 2.19) uses the I2C bus and includes a
24-bit ADC, operating at 3-5V. This sensor can measure the absolute pressure from 0 to
25 PSI. this is a small module measuring only 3.7 mm long and 2.5 mm diameter. Arduino
and Raspberry Pi libraries are available for this module.
Figure 2.19: MPRLS 3965 pressure sensor.
SparkFun MPL3115A2 is another popular pressure sensor module (Figure 2.20) for micro-
controllers. This sensor module also provides altitude data to within 30 cm. Interface to
the module is through the I2C bus. The device also contains a 12-bit temperature sensor.
Operating with 1.95 to +3.6 V, pressure output is in Pascals and altitude in meters. The
sensor can measure pressures from 20 to 110 kPa. The temperature sensor range is –40 ºC
to +85 ºC with an accuracy of ±3 ºC across the whole temperature range.
● 31
Figure 2.20: MPL3115A2 pressure sensor.
The BMP280 is another popular pressure sensor frequently used in microcontroller applica-
tions. This is an absolute barometric pressure sensor. This sensor, based on piezo-resistive
technology has been developed by Bosch and features high accuracy and linearity as well
as long term stability. The sensor is available as a module as shown in Figure 2.21. pressure
range of this sensor is 300 to 1100 hPa with an accuracy of ±1 hPa. The module operates
with the I2C interface and provides temperature measurement as well in the range –40 ºC
to +85 ºC with an accuracy of ±1 ºC .
Figure 2.21: BMP280 pressure sensor module.
2.7 Liquid Sensors

There are many different types of liquid sensors. These sensors are used to:
• detect the presence of liquid;

• measure the level of liquid;
• measure the flow rate of liquid, for example through a pipe.
The presence of a liquid can be detected by using optical, ultrasonic, change of resistance,
change of capacitance or similar techniques. For example, optical technique is based on us-
ing an LED and a photo-transistor, both housed within a plastic dome and at the head of the
● 32
device. When no liquid is present, light from the LED is internally reflected from the dome to
the photo-transistor and the output is designed to be off. When liquid is present the dome is
covered with liquid and the refractive index at the dome–liquid boundary changes, allowing
some light to escape from the LED. As a result of this, the amount of light received by the
photo-transistor is reduced and the output is designed to switch on, indicating the presence
of liquid.
The level of liquid in a tank can be measured using immersed sensor techniques, or
non-touching ultrasonic techniques. The simplest technique is to immerse a rod in the liquid
with a potentiometer placed inside the rod. The potentiometer arm is designed to move as
the level of the liquid is changed. The change in the resistance can be measured and hence
the level of the liquid is obtained.
Ultrasonic transmitter-receiver pair modules are often used to measure the level of liquid
in a container. An ultrasonic signal is transmitter by the transmitter module. This signal
reflects back from the surface of the liquid and is detected by the receiver module. The time
difference between sending and receiving the signal is used to determine the distance to
the surface of the liquid. Knowing the height of the container you can easily calculate the
height of the liquid in the container.
Pressure sensors are also used to measure the level of liquid in a tank. Typically, the pres-
sure sensor is mounted at the bottom of the tank where change of pressure is proportional
to the height of the liquid. These sensors usually give an analog output voltage proportional
to the height of the liquid inside the tank.
Non-touching ultrasonic level measurement is very accurate, but more expensive than the
other techniques. Basically, an ultrasonic beam is sent to the surface of the water and the
echo of the beam is detected. The time difference between sending the beam and the echo
is proportional to the level of the liquid in the tank.
The liquid flow rate can be measured by several techniques:
• paddlewheel sensors;
• displacement flow meters;
• magnetic flow meters.
Paddlewheel sensors are cost-effective and very popular for the measurement of liquid flow
rate. A wheel is mounted inside the sensor whose speed of rotation is proportional to the
flow rate. As the wheel rotates a voltage is produced which indicates the flow rate.
Displacement flow meters measure the flow rate of a liquid by separating the flow into
known volumes and counting them over time. These meters provide good accuracy. Dis-
placement flow meters have several types such as sliding vane meters, rotary piston me-
ters, helix flow meters and so on.
● 33
Magnetic flow meters are based on Faraday's law of magnetic induction. Here, the liquid
acts as a conductor as it flows through a pipe. This induces a voltage which is proportional
to the flow rate. The faster the flow rate, the higher is the voltage. This voltage is picked
up by the sensors mounted in the meter tube and electronic means are used to calculate
the flow rate based on the cross-sectional area of the tube. The advantages of magnetic
flow rates are as follows:
• Corrosive liquids can be used.

• The measurement does not change the flow stream.
• Corrosive liquids can be used.
The e-Tape Liquid Level Sensor (Figure2.22) is a low-cost solid-state sensor with a resistive
output that varies with the level of the fluid and it is used in liquid level control applications
as liquid level sensor. The sensor's resistive output is inversely proportional to the height of
the liquid: the lower the liquid level, the higher the output resistance; the higher the liquid
level, the lower the output resistance. The length and width of the sensor are 257 mm and
25.4 mm respectively. Sensor output is 1500 Ω when empty, and 300 Ω when full. The
resolution of the sensor is 0.25 mm.
Figure 2.22: e-Tape liquid level sensor.
The LV170 device from Omega is a liquid sensor switch (Figure 2.23) based on optical
technology. This electro-optical sensor contains an infrared LED and a light receiver. Con-
tinuous light from the LED is directed into a prism which forms the tip of the sensor. With
no liquid present, light from the LED is reflected within the prism to the receiver. When a
rising liquid immerses the prism, the light is refracted out into the liquid, leaving little or no
light to reach the receiver. Sensing this change, the receiver actuates electronic switching
within the unit to operate an external alarm or control circuit.
Figure 2.23: The LV170 liquid sensor switch.
The low-cost float switch (Figure 2.24) can be mounted at the edge of a tank and used
to detect the level of liquid in a tank. The switch provides normally-open/normally-closed
● 34
contacts so that external equipment can be switched on or off depending on the level of
the liquid.
Figure 2.24: Liquid float switch.
The mini liquid level sensor (Figure 2.25) from Parallax can be used to detect water level
in a small tank by inserting it vertically into the tank. Liquid levels from 0 to 48mm can be
detected by the sensor. The sensor has 2 to 5 V analog output and therefore ADC is needed
to connect it to a microcontroller. With an operating voltage of 2 to 5 V, the sensor can be
used in non-toxic, non-corrosive liquids such as water.
Figure 2.25: Mini liquid level sensor.
2.8 Flow Sensors

Flow sensors are used to measure the flow rate of liquid, gas, or air. For example, a liquid
or gas flow rate sensor measures the rate of liquid or gas passing through a pipe.
The low-cost YF-S201 can be used to measure the liquid flow rate (Figure 2.26). This sen-
sor operates with 5 to 18 V and provides TTL output with 450 pulses per liter. The range
of the sensor is 1 to 30 liters/minute, with an accuracy of ±10%. This sensor can directly
be connected to the Arduino. Connection to Raspberry Pi required the output voltage to be
dropped to 3.3 V, e.g., using a resistive potential divider circuit.
● 35
Figure 2.26: YF-S201 liquid flow rate sensor.
The FT-210 series is also a popular liquid flow rate sensor, although more expensive than
the YF-S201. This sensor operates with 5 to 24V and provides open-collector output with
22,000 pulses/liter, at an accuracy of ±3% of reading.
Figure 2.27: The FT-210 liquid flow rate sensor.
The Renesas type FS2012 sensor can be used to measure the flow rate of both liquid and
gas (Figure 2.28). Operating at 5 V, the sensor output is 0 to 5 V analog or I2C digital. It is
resistant to vibration and pressure shock. Gas flow range of the sensor is 0.015 to 2 SLPM
(Standard Liters Per Minute), with a flow accuracy of ±2% of the reading. Liquid flow range
is 0.025 to 0.5 SLPM, with an accuracy of ±2% of the reading.
Figure 2.28: The FS2012 gas/liquid flow rate sensor.
● 36
Chapter 3 • Transfer Functions and Time Response
3.1 Overview
In the previous Chapter, you had a look at some of the sensors that can be used in micro-
controller based digital control applications. In this Chapter, you will learn the theory and
time response of the first-order and second-order systems. They are important as most
control structures can be reduced to simple first or second-order systems. The aim of this
book is to minimize the theory and mathematical derivation as much as possible,
and yet learn the fundamental properties and the design of microcontroller based control.
In this Chapter, only continuous-time systems are considered since it is necessary to learn
the fundamental aspects of continuous-time systems before moving to digital systems.
Digital systems will be covered in a later Chapter.
3.2 First-order Systems

Example 1
Let's consider a simple electrical system consisting of a resistor (R) and an inductor (L) as
shown in Figure 3.1, where v(t) is the applied voltage and i(t) is the current in the circuit.
Figure 3.1: Electrical system with R and L.
You can write the loop equation as a differential equation:
(3.1)
Taking the Laplace transform with the initial conditions, you have
(3.2)
With zero initial conditions, the transfer function relating the current to the applied voltage
is given by:
(3.3)
● 37
or
(3.4)
Figure 3.2 shows the open-loop block diagram of the system with V(s) as input and I(s) as
output.
Figure 3.2: Open-loop block diagram.
Example 2
Let's now consider a liquid level system (Figure 3.3) where liquid enters a tank at the rate
of qi and leaves at the rate of qo through an orifice. Derive the mathematical model for the
system, showing the relationship between the height h of the liquid and the input flow rate
qi.
Figure 3.3: Liquid level control.
Assuming V is the volume and A is the area of the liquid tank,
(3.5)
or
(3.6)
● 38
But the pressure in a tank is given by:
(3.7)
Hence, (3.6) becomes:
(3.8)
If R is the hydraulic resistance.
(3.9)
So that
(3.10)
Substituting in (3.8) gives
(3.11)
Taking the Laplace transform gives:
(3.12)
And the transfer function can be written as:
(3.13)
or conclusively:
(3.14)
3.2.1 Time Response

Notice that equation (3.4) and (3.14) are very similar since they are both first-order sys-
tems. In general, you can write the transfer function of a first-order open-loop system as
follows:
● 39
(3.15)
If you now apply a unit step input R(t) to the system, where R(s) = 1/s, the Laplace trans-
form of the overall open-loop system C(s) becomes:
(3.16)
The time response of the open-loop system is given by taking the inverse Laplace transform
of (3.16), which gives:
(3.17)
The response is clearly an exponential rise. Initially at t = 0, system output c(t) = 0. The
output then rises to 1 in an exponential manner.
Parameter 1/a is known as the time constant of the system. At t = 1/a, the response
becomes:
(3.18)
You can therefore say that when a step input is applied to a first-order system, the system
output rises to 63% of its final value at the time equal to the time constant of the system.
Notice that the time constant 1/a has the unit of time.
Figure 3.4 shows the output response of the system graphically.
Figure 3.4: Output response of a first-order system.
● 40
In reference to Figure 3.4, you can write the following:
• The response rises exponentially from 0 to 1.

• The initial slope can be used to find the time constant 1/a. find the point of
intersection of the initial slop and final value and then read the time constant
from the horizontal axis.
• The rise time Tr is the point where the response rises to 90% of its final value,
and is given by: Tr = 2.2/a.
• The settling time Ts is defined the time where the final response settles within
2% of its final value, and is given by: Ts = 4/a.
Question
The transfer function of a first-order system is given by:
Calculate the time response if a unit step input is applied to the system.
Solution
With a unit step input the open-loop transfer function is:
or
From inverse Laplace transform tables, you find that the time response is given by:
At t = 0 the output is 0, and the final value of the output is (for very large t) equal to K/a.
Question
The unit step time response of a first-order system is found to be as shown in Figure 3.5.
Calculate the transfer function of this system.
● 41
Figure 3.5: First-order system response.
Solution
The final value of the system is clearly 2.5. Time constant is when the curve reaches 63% of
its final value. Therefore, the time constant occurs at the y axis point 2.5 × 0.63 = 1.575.
Drawing a horizontal line from this point, you find on the horizontal axis that the time
constant is 1/a = 0.25. Therefore, a = 1/0.25 = 4. You now have to find K. The final value
is K/a = 2.5, therefore K = 4 × 2.5 = 10. The required transfer function of the system is:
Question
The unit step time response of a first-order system is found to be as shown in Figure 3.6,
where the initial value of the output is 4. Calculate the transfer function of this system.
Figure 3.6: First-order system response.
● 42
Solution
The final value of the system is 9, where its initial value is 4. The time constant occurs when
the curve reaches 63% of its final value, i.e., at the y axis point 4 + (9 – 4) × 0.63 = 7.15.
Drawing a horizontal line from this point, you find that the time constant on the horizontal
axis is 1/a = 0.5. Therefore, a = 1/0.5 = 2. You now have to find K. The final value is K/a =
(9 – 4), therefore K = 5 × 2 = 10. The required transfer function of the system is:
3.3 Second-order Systems

Example 1
Consider the mechanical system shown in Figure 3.7, consisting of a mass, spring, and
dashpot, where force F is applied to the system.
Figure 3.7: Mechanical system with mass, spring, and dashpot.
The net force on the mass is the applied force minus the forces exerted by the spring and
the dashpot. Applying Newton's second law, you can write:
(3.19)
or,
(3.20)
Taking the Laplace transform gives:
The transfer function is then given by:
(3.21)
● 43
Which is usually written in the standard form as a second-order open-loop system transfer
function:
(3.22)
Example 2
Consider the electrical system given in Figure 3.8, consisting of a resistor (R), inductor (L),
and a capacitor (C). Let's derive the model of this system.
Figure 3.8: Electrical circuit.
Applying Kirchhoff's voltage law, you can write:
(3.23)
or,
(3.24)
For the capacitor, you can write
(3.25)
Substituting into (3.24), you obtain
(3.26)
Taking the Laplace transform gives
● 44
The transfer function is therefore given by:
Which can be written in the form:
(3.27)
Equation (3.27) is similar to (3.22) as both systems are second-order. In fact, the general
form of a second-order open-loop transfer function is of the following format:
(3.28)
Where, is the natural frequency and is the damping ratio.
3.3.1 Time Response

You will now investigate the output response of a second-order system when a unit step
input is applied. There four solutions to equation (3.28) depending on the value of the
damping ratio.
Case 1: Undamped
This is an oscillatory response.
Case 2: Critically damped
This is an exponentially rising response.
Case 3: Overdamped
Case 4: Underdamped
● 45
Where, is the damped natural frequency
and
Figure 3.9 shows the time response for all four cases.
Figure 3.9: Time response of a second-order system.
In controlling a plant, you are mainly interested in the underdamped case where the damp-
ing ratio is less than one. As shown in Figure 3.10, as the damping ratio gets smaller you
get higher overshoots in the response. You should aim for a damping ratio of about 0.7
whish gives a very slight overshoot and a fast rise time.
Figure 3.10: Second-order system response as damping ratio changes.
Some important parameters that define a second-order underdamped response are given
below (see Figure 3.11)
● 46
Figure 3.11: Second-order system parameters.
Peak time (Tp) : This is the time required for the system response to reach its first over-
shoot and is given by:
Rise time (Tr): This is the time required for the system to reach the final value first time.
It is given by:
where
Maximum overshoot (Mp): This is the difference between the maximum overshoot and
the final value, given by:
Settling time (ts): This is the time required for a response to become steady. It is usually
defined as the time required by the response to reach within specified range of 2% to 5%
of its final value, given by:
to 2%
to 5%
● 47
Example
Given the following open-loop transfer function of a system with unit step input applied,
calculate the Tp, Tr, Mp, and ts to 2%.
Solution
is 10, is 10, or is 0.5
Therefore:
or
seconds
or B = 59.9 degrees or 1.045 radians
seconds
or 16.3%
seconds
Hence, seconds, seconds, , seconds.
Example
Sometimes you have a DC gain and the transfer function (3.28) becomes:
● 48
An example is given below. Draw the unit step time response for the following two transfer
functions:
and
Solution
Figure 3.12 shows the two step functions next to each other. Notice that in the second re-
sponse the gain is 4 and therefore the final state of the time response settled at 4.
Figure 3.12: Step responses.
Example
The unit step time response of a second-order system is shown in Figure 3.13. Derive the
transfer function of this system.
Figure 3.13: Unit step time response.
Solution
In reference to Figure 3.14, you can read the following:
● 49
Figure 3.14: Finding the parameters.
seconds
Therefore, , which gives
Also,
, which gives , hence
And , or
The required transfer function is:
or
3.4 Time Delay

In some systems, especially in thermal systems the response of the system is slow when an
input is applied and it takes some time for the output to change. This is called time delay
and is represented with the following transfer function:
● 50
Where T is the delay in seconds. As an example, the transfer function of a first-order sys-
tem with time delay is given below.
Figure 3.15 shows the unit step response of this system.
Figure 3.15: Step response with time delay.
3.5 Transfer Function of a Closed-loop System

A control system may include a number of blocks interconnected together. In this section
you will derive the transfer function of a basic feedback control system.
Figure 3.16 shows the block diagram of a feedback control system with the forward trans-
fer function G(s) and the feedback transfer function H(s), and input and outputs I(s) and
O(s), respectively. It can be shows that the transfer function of this closed-loop system is
given by:
Figure 3.16: Feedback control system.
● 51
When the blocks are in series to each other you can multiply them to find the overall
transfer function (interested readers can find lots of information on the Internet on block
diagram manipulation).
Example
Find the overall transfer function of the system shown in Figure 3.17.
Figure 3.17: Block diagram of the example system.
Solution
The overall transfer function is given by:
● 52
Chapter 4 • Discrete Time (Digital) Systems
4.1 Overview
A digital system operates on discrete-time rather than continuous-time signals. A digital
computer (e.g. a microcontroller) is used as the controller in such a system. A DAC con-
verter is usually connected to the output of the computer to drive the plant. Let's assume
that all the signals enter and leave the computer at the same fixed times, known as the
sampling times.
A typical sampled data control system is shown in Figure 4.1. The digital computer per-
forms the controller or the compensation function within the system. The ADC converts the
error signal, which is a continuous signal, into digital form so that it can be processed by the
computer. At the computer output the DAC converts the digital output of the computer into
a form which can be used to drive the plant. It is also common to use some form of power
amplifier circuit before the plant in electrical systems such as electromechanical motors.
Figure 4.1: A digital control system.
4.2 The Sampling Process

An ADC is used as a sampler which is basically like a switch that closes every T seconds, as
shown in Figure 4.2. When a continuous signal r(t) is sampled at regular intervals T, the re-
sulting discrete-time signal is shown in Figure 4.3, where q represents the amount of time
the switch is closed. Notice that signal r(t) is shown as r*(t) after it is sampled.
In practice the closure time q is much smaller than the sampling time T, and the pulses can
be approximated by flat-topped rectangles as shown in Figure 4.4.
In control applications the switch closure time q is much smaller than the sampling time T
and can be neglected. This leads to the ideal sampler with output as shown in Figure 4.5.
Figure 4.2: A sampler.
● 53
Figure 4.3: Signal r(t) after the sampling operation.
Figure 4.4: Sampled signal with flat-topped pulses.
● 54
Figure 4.5: Signal r(t) after ideal sampling.
A DAC converts the sampled signal r ∗(t) into a continuous signal y(t). The DAC can be ap-
proximated by a zero-order hold (ZOH) circuit as shown in Figure 4.6. This circuit remem-
bers the last information until a new sample is obtained, i.e. the zero-order hold takes the
value r(nT) and holds it constant for nT ≤ t < (n + 1)T, and the value r(nT) is used during
the sampling period.
Figure 4.6: A sampler and zero-order hold.
A sampler and zero-order hold can accurately follow the input signal if the sampling time T
is small compared to the transient changes in the signal. The response of a sampler and a
zero-order hold to a ramp input is shown in Figure 4.7 for two different values of sampling
period.
● 55
Figure 4.7: Response of a sampler and a zero-order hold for a ramp input.
Example
Figure 4.8 shows an ideal sampler followed by a zero-order hold. Assuming the input signal
r(t) is as shown in the figure, show the waveforms after the sampler and also after the
zero-order hold.
Figure 4.8: Ideal sampler and zero-order hold.
Solution
The signals after the ideal sampler and the zero-order hold are shown in Figure 4.9.
Figure 4.9: Solution of the example.
● 56
4.3 The Z-Transform

The z-transform is used in manipulating, designing and testing digital systems just like the
Laplace transform is used in continuous-time systems.
The z-transform of the function r (t) is Z [r (t)] = R(z) and is given by:
(4.1)
Notice that the z-transform consists of an infinite series in the complex variable z, and
(4.2)
i.e. are the coefficients of this power series at different sampling instants. The re-
sponse of a sampled data system can be determined easily by finding the z-transform of
the output and then calculating the inverse z-transform.
4.3.1 Unit step function

Consider a unit step function as shown in Figure 4.10, defined as:
From (4.1),
or, for
Figure 4.10: Unit step function.
● 57
4.3.2 Unit ramp function

Consider a unit ramp function as shown in Figure 4.11, defined as:
From (4.1),
Or, for
Figure 4.11: Unit ramp function.
4.3.3 Tables of z-Transforms

A table of z-transforms for the commonly used functions is freely available on the Internet.
As with the Laplace transforms, you are interested in the output response y(t) of a digital
system and you must find the inverse z-transform to obtain y(t) from Y(z).
4.4 The z-Transform of a function expressed as a Laplace Transform

It is important to realize that although you denote the z-transform equivalent of G (s) by
G (z), G (z) is not obtained by simply substituting z for s in G (s). You can use one of the
following methods to find the z-transform of a function expressed in Laplace transform
format:
Given G (s), calculate the time response g(t) by finding the inverse Laplace transform of
G(s). Then find the z-transform either from the first principles, or by looking at the z-trans-
form tables.
Given G(s), find the z-transform (z) by looking at the tables which give the Laplace trans-
forms and their equivalent z-transforms.
● 58
Example
Let
Determine by the methods described above.
Solution 1 - By finding the inverse Laplace transform

You can express G(s) as a sum of its partial fractions:
The inverse Laplace transform of this transfer function is given by:
From the z-transform tables you obtain:
or,
Solution 2 - By using the z-transform transform tables for the partial product
From the z-transform tables, the z-transform of is . Therefore,
or,
● 59
4.5 Inverse z-Transforms

The inverse z-transform is obtained in a similar way to the inverse Laplace transforms.
Generally, the z-transforms are the ratios of polynomials in the complex variable z, with
the numerator polynomial being of order no higher than the denominator. By finding the
inverse z-transform you find the sequence associated with the given z-transform polyno-
mial. As in the case of inverse Laplace transforms, you are interested in the output time
response of a system. Therefore, you use an inverse transform to obtain y(t ) from Y (z).
There are several methods to find the inverse z-transform of a given function as described
below:
• Power series (long division);

• Expanding Y (z) into partial fractions and using z-transform tables to find the
inverse transforms;
• Obtaining the inverse z-transform using an inversion integral.
In this section you will look at an example using the power series method. This method
involves dividing the denominator of Y (z) into the numerator.
Example
Find the inverse z-transform (time function) for the following transfer function:
Solution
Dividing the denominator into the numerator is shown in Figure 4.12.
Figure 4.12: Dividing the denominator into numerator.
● 60
The coefficients of the power series are:
The required output time sequence is:
Where represent delay by T samples.
Figure 4.13 shows the first few samples of the time sequence y(t).
Figure 4.13: First few samples of y(t).
4.6 Pulse transfer function and manipulation of block diagrams

The pulse transfer function is the ratio of the z-transform of the sampled output and the
input at the sampling instants.
Suppose you wish to sample a system with output response given by:
As illustrated in Figure 4.14. You sample the output signal to obtain:
or,
● 61
Figure 4.14: Sampling a system.
4.6.1 Open-loop systems

An example of manipulating the open-loop block diagram is given in this section.
Example
Figure 4.15 shows an open-loop digital system. Derive an expression for the z-transform of
the output of the system, where
and
Figure 4.15: Open-loop system.
Solution
The following expressions can be written for the system:
or,
and,
where,
substituting the values gives:
from z-transform tables you obtain:
● 62
and the z-transform of the output is given by:
4.7 Open-loop time response

The open-loop time response of a digital system can be obtained by finding the inverse
z-transform of the output function. Two examples are given below.
Example
A unit step signal is applied to the electrical RC system shown in Figure 4.16. Calculate and
draw the output response of the system, assuming a sampling period of T = 1 s.
Figure 4.16: RC system with unit step input.
Assume that the transfer function of the RC system is:
Solution
For this system you can write:
and
giving
the z-transform of a unit step function is
and the z-transform of G(s) is
● 63
thus, the output z-transform is given by:
T = 1 s and e-1 = 0.368, you get
The output time response is obtained by finding the inverse z-transform of y(z). You can
either use an inverse z-transform table, divide the numerator by the denominator, or find
the partial fractions as follows:
Calculating A and B you find:
And finally,
From the inverse z-transform tables you find the time function as:
The first few output samples are:
And the output time response is (see Figure 4.17) given by:
● 64
It is important to notice that the response is only known at the sampling instants. For
example, in Figure 4.17 the capacitor discharges through the resistor between the sam-
pling instants, and this causes an exponential decay in the response between the sampling
intervals. But this behaviour between the sampling instants cannot be determined by the
z-transform method of analysis.
Figure 4.17: RC system output response.
Example
Assume that the system in Example 4.16 is used with a zero-order hold (see Figure 4.18).
What will the system output response be if a unit step input is applied.
Figure 4.18: RC system with zero-order hold.
Solution
The transfer function of the zero-order hold is
And that of the RC system is
For this system you can write
And
or, taking the z-transforms.
● 65
Now, T = 1 s and
Which can be written as:
From the z-transform tables you find that
For a unit step input,
And the system output response becomes
From inverse z-transform tables you find that
Where a is the unit step function. Thus
The time response is shown in Figure 4.19
● 66
Figure 4.19: Step input response of the system.
4.8 Closed-loop system time response

An example of manipulating the closed-loop system block diagram is given in this section.
Example
A unit step signal is applied to the sampled data digital system shown in Figure 4.20. Cal-
culate and plot the output response of the system. Assume that T = 1 s.
Figure 4.20: Closed-loop system.
Solution
The transfer function of the system is found as
Or e*(s)=r*(s)-G*(s)e*(s)
Solving for e*(s) , you obtain
● 67
And therefore
The z-transform of the output is given by
In our example, and
Therefore, the output z-transform is
Simplifying and setting T = 1 gives:
After long division of the numerator to the denominator gives
The first 10 samples of the output response are shown in Figure 4.21
Figure 4.21: First 10 output samples.
● 68
Chapter 5 • The PID Controller in Continuous-Time Systems
Chapter 5 • The PID Controller in Continuous-Time

Systems
5.1 Overview
A PID controller (sometimes called three-term controller) is an algorithm that is widely
used in industrial process control systems, and in many other control systems where zero
error is required in the final system output. It is important to realize that PID is not the
only controller type used in control systems. There are many other types such as lead, lag,
lead-lag, pole assignment, dead-beat, Dahlin, etc.
In a PID control algorithm, the controller receives the error value which is the difference be-
tween the desired and the actual measured value, and then applies correction to the plant
in order to force the error value to zero and obtain a successful, stable response.
In PID control, P is the proportional control action, I is the integral control action, and D is
the derivative control action. As you will learn in this Chapter, P is proportional to the error
and if the error is large then the value applied to the plant will also be large. Using pro-
portional control on its own results in error between the desired and the actual measured
values.
Integral action provides an integral of the error value over time to the plant. As a result,
any error value will be eliminated and the integral term will cease to grow. The objective of
using the integral control action is to force the error value to zero.
Derivative action provides the derivative of the error value to the plant. This action tends
to reduce the error value as well as the inevitable overshoot. The derivative action is not
used in all systems.
The continuous-time PID controller is expressed mathematically as follows:
Where, u(t) is the controller output, and e(t) is the error value which is input to the control-
ler. Also, Kp, Ki, and Kd are known as the proportional, integral, and derivative constants of
the PID controller. The Laplace transform of the PID controller is:
(5.1)
or (5.2)
● 69
Sometimes the PID controller is expressed in an alternative way:
(5.3)
One of the problems in PID controller design is tuning the values of the P, I, and D coeffi-
cients or parameters (Kp, Ki, and Kd) so that the required output response is obtained from
the system. There are many methods for doing this and you will explore some popular ones
in this Chapter.
In the remaining sections of this Chapter, you will discover details of the PID controller by
using it with a first-order continuous-time system.
5.2 Proportional-only Controller with a First-Order System

Consider the first order closed-loop system shown in Figure 5.1 with this proportional-only
controller transfer function:
and the plant transfer function:
Figure 5.1: First-order closed-loop system with proportional only controller.
The closed-loop transfer function is given by:
giving
Which has the time constant 1/11 = 0.09. The closed-loop system without the proportional
only controller had the time constant 1/2 = 0.5. You can see that with the proportional
only controller the time constant has decreased. i.e., the system response became faster.
Figure 5.2 shows the unit time response of the closed-loop system with and without the
proportional only controller. It is also interesting to notice that there is steady state error
in system response with proportional only controller. i.e., the final state of the system is at
● 70
0.9 and not 1.0. You can reduce the error with larger proportional constant Kp but this will
require very large value (theoretically infinite value).
Figure 5.2: Unit step response with and without controller.
5.3 Integral-Only Controller with a First-order System

Let's look at the first-order closed-loop system shown in Figure 5.3 with this integral-only
controller transfer function:
and the plant transfer function .
Figure 5.3: First-order closed-loop system with integral only controller.
The closed-loop transfer function:
giving
Figure 5.4 shows the unit step, closed-loop system response with and without the inte-
gral-only controller. It is interesting to note that the closed-loop system response with the
integral-only controller is fast but exhibits overshoots. Also, there is no steady state error,
i.e., the final state of the system is at 1.0. The overshoot can be reduced by reducing the
integral amount. Figure 5.5 shows the response when the integral controller is 0.5/s. Notice
that the overshoot is reduced considerably and also the steady state error is zero. You can
● 71
conclude here that integral action is very important in systems where you want the steady
state error to be zero.
Figure 5.4: Unit step response with and without controller.
Figure 5.5 System response with the integral-only controller set to 0.5/s.
5.4 Derivative-only Controller with a First-order System

Consider the first-order closed-loop system shown in Figure 5.6 with the integral-only con-
troller transfer function:
● 72
Figure 5.6: First-order closed-loop system with derivative-only controller.
giving
Figure 5.7 shows the closed-loop system response. Notice that the derivative action does
not track the error. Instead, it tracks the rate of change of the error and is not useful on
its own.
Figure 5.7: Unit step response with derivative-only.
5.5 Proportional + Integral Controller with a First-order System

View the first-order closed-loop system shown in Figure 5.8 with the proportional and inte-
gral controller transfer function:
● 73
Figure 5.8: First-order, closed-loop system with proportional+integral controller.
giving
Figure 5.9 shows the closed-loop unit step response with and without the controller. Notice
that this is an acceptable response since there is little overshoot and the steady state error
is zero.
Figure 5.9: First-order, closed-loop system response with and without P+I controller.
5.6 Proportional + Integral + Derivative controller with a First-order

System
You will now add derivative action to our controller. Consider the first-order closed-loop
system shown in Figure 5.10 with the PID controller transfer function:
● 74
Figure 5.10: First-order, closed-loop system with

proportional+integral+derivative controller.
giving
Figure 5.11 shows the system response with the PID in action. Compare this response with
Figure 5.9. Notice that by adding a derivative action, the system now has slightly higher
overshoot and higher rise time meaning you have not gained a better response. The impor-
tance of setting the PID parameters is very important as you have seen in these example
plots. This is called tuning the controller and you will look at different methods of tuning a
system.
Figure 5.11: First-order closed-loop unit step response with PID controller.
5.7 Effects of Changing the PID Parameters

You will now use the system with transfer functions as given in the previous section and
examine the effects of changing the PID parameters.
The system's closed-loop transfer function is:
● 75
and with the PID transfer function:
The closed-loop unit step time response with the above parameters is pictured in Figure
5.12a. It shows the response after doubling Kp. PID parameters were put back to what they
were and Figure 5.12c shows the response after Ki is doubled. Finally, the parameters were
put back to what they were again and Figure 5.12d is the response after Kd is doubled. No-
tice that the steady state error is zero in all cases. Increasing the integral parameter makes
the system faster but at the same time oscillatory before it settles down.
Figure 5.12: Effects of changing the PID parameters.
5.8 Tuning a PID Controller

One of the commonly used methods for tuning the PID parameters is known as the Ziegler
and Nichols tuning method. This method can be applied to both open-loop and closed-loop
systems. The method involves observing the unit time response of a system and then esti-
mating the PID parameters based on the time response.
● 76
You will use the following form of the PID controller in tuning the controller:
which has the transfer function:
5.8.1 Open-loop Ziegler and Nichols Tuning

For open-loop tuning, you first find the plant parameters by applying a step input to the
open-loop system. The plant parameters Kp , Td and Ti are then found from the result of
the step test as shown in Figure 5.13. Notice that TD is the time delay of the system (see
section 3.4). You can also use the method described in Chapter 3 to find the open-loop
transfer function of a system from its unit step time response. The transfer function of the
system is then found to be:
Ziegler and Nichols then suggest using the PID controller settings given in Table 5.1 when
the loop is closed. These parameters are based on the concept of minimizing the integral of
the absolute error after applying a step change to the set-point. An example is given here
to illustrate the method used.
Figure 5.13: Finding the plant parameters.
The Ziegler and Nichols method has these advantages:
• simple to implement
• very little knowledge required about the system dynamics
● 77
On the down side:
• response results in large (25%) overshoot

• tuning is sensitive to system dynamics, especially to the delay time
• tuning is sensitive to non-linearities
5.8.2 Open-loop Cohen-Coon PID Tuning

This method is based on the Ziegler and Nichols method but provides significantly better
control performance especially for systems with large delay times.
The settings of the Cohen-Coon tuning are as shown in Table 5.1.
Table 5.2: Cohen-Coon PID tuning settings.
Where L is the delay time, T is the system time constant, and Kprocess is the gain of the
process. This method can only be used offline.
Cohen-Coon tuning has these advantages:
• works well with systems with large delay time

• gives quicker response than the Ziegler and Nichols method
Example
Figure 5.14 shows the open-loop unit step time response of a system with time delay. Your
task is to derive the Ziegler and Nichols tuning parameters for this system and draw the
time response of the closed system with the PI controller.
Soluti on
With reference to Figure 5.14, the open-loop system parameters are given as follows:
K = 10, TD = 2, T1 = 4
● 78
Therefore, the open-loop system transfer function is:
With reference to Table 5.1, the PI parameters are:
Figure 5.14: Open-loop time response.
The required PI transfer function is:
The block diagram of the system is shown in Figure 5.15.
Figure 5.15: Block diagram of the system.
● 79
The unit step time response of the closed-loop system is shown in Figure 5.16. Notice that
the system has high overshoot which is the characteristic of the design using Ziegler &
Nichol method. If you reduce Kp to 0.15 the transfer function of the controller becomes:
And the closed-loop system response becomes as shown in Figure 5.17.
Figure 5.16: Unit step time response of the closed system.
Figure 5.17: System response with reduced Kp.
There are several other PID tuning algorithms used in practice, such as modified Ziegler
and Nichols, Lambda, Chien-Hrones-Reswick, the Tyreus-Luyben method, Ciancone-Mar-
line method, Internal Model Control (IMC), and others. You will now proceed to designing a
Lambda type controller for your example system.
● 80
Example
Let's design a Lambda PI controller for the plant whose transfer function is found to be:
Solution
Like the Ziegler and Nichols tuning, lambda tuning involves a set of formulas or tuning
rules that dictate the values of the PI parameters required to achieve the desired controller
performance. The tuning rules for the Lambda PI controller are as follows:
Where is the process time constant. In order to obtain a closed-loop system with a
non-oscillatory setpoint response that will settle out in approximately 4λ seconds. These
tuning rules require the user to specify only one performance parameter: λ. This simplifies
the calculations considerably.
In or example, K=10 and
Setting (i.e., ) you find:
which gives and
The transfer function of the PI controller then becomes:
The closed-loop system response with this controller is shown in Figure 5.18.
● 81
Figure 5.18: Closed-loop time response.
Lambda tuning has the following advantages:
• works well for systems with large delay time

• largely insensitive to system non-linearities
• response has no overshoot
• the closed-loop time constant can be chosen
The disadvantages of the Lambda tuning are:
• only available for PI type controllers

• slow rejection of disturbances
5.8.3 Closed-loop Tuning

The Ziegler & Nichols closed-loop tuning algorithm is based on plant closed-loop tests. The
procedure is as follows:
• Disable any derivative and integral action in the controller and leave only the
proportional action.
• Carry out a set-point step test and observe the system response.
• Repeat the set-point test with increased (or decreased) controller gain until a
stable oscillation is achieved (see Figure 5.19). This gain is called the ultimate
gain, Ku.
• Read the period of the steady oscillation and define it as Pu.
• Calculate the controller parameters according to the following formulae: Kp =
0.45Ku, Ti = Pu/1.2 in the case of the PI controller; and Kp = 0.6Ku, Ti = Pu/2, Td
= Tu/8 in the case of the PID controller.
● 82
Figure 5.19: Ziegler and Nichols closed-loop test.
Example
Let's go ahead and design a PI controller for a system whose open-loop transfer function
is given by:
Solution
Increasing the gain of the system, you find that the system output starts to oscillate when
the gain is 3.803. The period of the oscillations was found to be 7.5 seconds (Figure 5.20).
Figure 5.20: System oscillating with increased gain.
Therefore, , and
Therefore, from the Ziegler and Nichol settings,
and
● 83
The transfer function of the PI controller is:
Figure 5.21 shows the closed-loop time response of the system. There is about 18% over-
shoot in the response which is expected from the Ziegler and Nichol type tuning.
Figure 5.21: Closed-loop time response of the system.
Note that most systems can easily be controlled using just the PI controller without the
derivative action. The derivative action is exceedingly sensitive to noise and it must not
be used unless the system time constant is very slow. Filters are commonly used with the
derivative action to cancel out the noise.
5.8.4 Practical PID Tuning

In most cases, you can tune a PID system by performing some practical observations. The
steps are:
• Use only Proportional Control (set the integral and derivative to zero) and
apply step input to the system. Vary the proportional parameter until a good
response is obtained. Then decrease the proportional parameter slightly.
• Keep the proportional parameter found and now vary the integral parameter
until a good response is obtained and the steady state error is zero.
• Keep the proportional and integral parameters found and vary the derivative
parameter until a good response is obtained. It is interesting to note that most
systems do not require the derivative action.
Figure 5.22 shows how a system can be tuned practically.
● 84
Figure 5.22: Effect of PID parameter changes.
5.9 The Auto-tuning PID Controller

Many controller manufacturers nowadays offer intelligent PID controllers which can au-
tomatically tune themselves depending on the plant characteristics to find the optimum
controller parameters.
5.10 Increasing and Decreasing PID Parameters

The effects of increasing the PID parameters are summarized in Table 5.3.
Response Rise Time Overshoot Settling Time SS Error
Kp Decrease Increase No change Decrease
Ti Increase Decrease Decrease Eliminate
Td No change Decrease Decrease No change
Table 5.3: Effect of increasing the PID parameters.
5.11 Saturation and Integral Wind-up

In practical applications, the output value of a control action is limited by physical con-
straints. For example, the maximum voltage output from a device is limited. Similarly, the
maximum flow rate that a pump can supply is limited by the physical capacity of the pump.
● 85
As a result of this physical limitation, the error signal does not return to zero and the inte-
gral term keeps adding up continuously. This effect is called integral wind-up (or integral
saturation). As a result of it, long periods of overshoot can occur in the plant response.
A simple example of what happens is the following. Suppose you wish to control the po-
sition of a motor and a large setpoint change occurs, resulting in a large error signal. The
controller will then try to reduce the error between the set-point and the output. The inte-
gral term will grow by summing the error signals at each sample and a large control action
will be applied to the motor. But because of the physical limitation of the motor electronics,
the motor will not be able to respond linearly to the applied control signal. If the set-point
now changes in the other direction, then the integral term is still large and will not respond
immediately to the set-point request. Consequently, the system will have a poor response
when it comes out of this condition.
The integral wind-up problem affects positional PID controllers. With velocity PID control-
lers, the error signals are not summed up and as a result integral wind-up will not occur,
even though the control signal is physically constrained.
Many techniques have been developed to eliminate integral wind-up from the PID control-
lers, and some of the popular ones are as follows:
• Stop the integral summation when saturation occurs. This is also called
conditional integration. The idea is to set the integrator input to zero if the
controller output is saturated and the input and output are of the same sign.
• Fix the limits of the integral term between a minimum and a maximum.
• Reduce the integrator input by some constant if the controller output is

saturated. Usually, the integral value is decreased by an amount proportional
to the difference between the unsaturated and saturated (i.e., maximum)
controller output.
• Use the velocity form of the PID controller.
5.12 Derivative Kick

Another possible problem when using PID controllers is caused by the derivative action
of the controller. This may happen when the set-point changes sharply, causing the error
signal to change suddenly. Under such a condition, the derivative term can give the output
a kick, known as a derivative kick. This is usually avoided in practice by moving the deriva-
tive term to the feedback loop. The proportional term may also cause a sudden kick in the
output and it is common to move the proportional term to the feedback loop.
5.13 Using the PID Loop Simulator

The PID Loop Simulator from the website Engineers-Excel.com is a very useful comput-
er-aided to properly simulate processes with PID controllers. It is invaluable for tuning the
PID parameters of a given system. The simulator can be used after you obtain the open-
loop transfer function of our system from a step-input time response.
● 86
The PID Loop Simulator software application for PC is available free of charge from the
following website:
https://view.officeapps.live.com/op/view.aspx?src=http%3A%2F%2Fwww.engineers-
excel.com%2FApps%2FPID_Simulator%2FPID_scrollbar.xls&wdOrigin=BROWSELINK
Figure 5.23 shows the PID Loop Simulator software application. In the middle part of
the screen, the general simulation block diagram is shown with the PID controller and a
first-order plant with time delay. The transfer function of the plant (gain, time constant, and
delay time) are entered at the top left under heading Process. The controller parameters
(proportional, integral and derivative) are entered under the heading Controller. The unit
step output time response of the plant as well as the output time response of the controller
are shown at the bottom of the screen. System output is shown in blue while the controller
output is shown in green.
Figure 5.23: The PID Loop Simulator.
As an example, let's consider the following plant transfer function:
and the PID controller's transfer function:
● 87
The controller transfer function in "PID Loop Simulator" is specified as:
Therefore, C = 2, I = 10, and D = 1.2
Entering the plant and controller values into the simulator produces the theoretical system
time response shown in Figure 5.23. The system has a small overshoot and the steady
state error is zero for all practical purposes. You can easily change the controller parame-
ters and view the output time response immediately.
● 88
Chapter 6 • The Digital PID Controller
6.1 Overview
This Chapter discusses the digital form of the continuous-time PID controller as well as
ways of using it in a computer system like a microcontroller.
6.2 Digital PID

The continuous-time transfer function of the PID controller was found to be:
(6.1)
The digital form of the PID controller can be found by taking the z-transform of the above
transfer function:
(6.2)
This transfer function can be implemented as a parallel structure by summing the pro-
portional, integral, and derivative terms.
Let and (6.3)
Then, equation (6.2) can be written as:
(6.4)
It can be shown that equation (6.4) can be implemented as shown in Figure 6.1 with the
following sets of equations.
PID:
For the proportional section:
For the integral section:
For the derivative section:
The output is given by:
● 89
Figure 6.1: PID controller implementation as a parallel structure.
Variables and are the memory variables of the controller.
PI:
For the case of PI-only controller, you have the following equations:
For the proportional section:
For the integral section:
The output is given by:
The PI implementation is pictured in Figure 6.2 as a parallel structure.
Figure 6.2: PI-only controller implementation as a parallel structure.
6.3 Choosing a Sampling Time, T

Before implementing a digital PID algorithm, you have to choose a sampling time T (or
sampling interval). Choosing a large sampling time has destabilizing effects on the system.
In addition, information loss occurs when large sampling times are selected. Also, the er-
rors that occur when a continuous system is discretized increase as the sampling interval
increases.
● 90
You may think that decreasing the sampling interval towards zero will make a discrete sys-
tem converge towards an equivalent continuous system. However, in practice this is not the
case. As the sampling interval is reduced, the change between the successive data values
becomes less than the resolution of the system, leading to loss of information. In general,
if a shorter sampling interval is to be used then the word length of the system should be
increased so that the difference between adjacent samples can be resolved.
It has been found from practical applications in the process industry that a sampling inter-
val of 1 second is generally short enough for most applications such as pressure control,
temperature control and flow control. Systems with fast responses such as electromechan-
ical systems (e.g., motors) require much shorter sampling intervals, usually of the order
of milliseconds.
Various empirical rules have been suggested by many researchers for the selection of the
sampling interval. These rules are based on practical experience and simulation results.
Among them are the following:
If the plant has the dominant time constant Tp, then the sampling interval T for the closed-
loop system should be selected such that T < Tp/10.
Assuming that the process has a Ziegler–Nichols open-loop model:
then the sampling interval should be selected such that T < T1/4.
If the closed-loop system is required to have a settling time Tss or a natural frequency of ωn
then choose the sampling interval T such that T < Tss/10 and ωs > 10ωn, where ωs is the
sampling frequency, i.e., ωs = 2π/T.
6.4 Microcontroller Implementation of the PID Algorithm

The final stage of a digital control system design is the implementation of the controller
algorithm (set of difference equations) on a digital computer — nowadays, usually a micro-
controller. In this section, you learn about the implementation of the PID digital controller
algorithm on microcontrollers.
Microcontrollers have traditionally been programmed using the assembly language of the
target hardware. Assembly language has several important disadvantages and is currently
less popular than it used to be. One important disadvantage is that the code generated
using the assembly language can only run on the specific target hardware. For example,
the assembly program developed for a PIC microcontroller cannot be used, say, on an Intel
8051 microcontroller. Assembly language programs also tend to be more difficult to devel-
op, test and maintain. In the projects in this book, you will be using C programs for the
Arduino, and Python programs for the Raspberry Pi.
● 91
There are several methods that can be used to implement the controller algorithm on a
microcontroller. One of the most common methods with the advantage of accurate imple-
mentation involves a timer interrupt to generate the required loop delay (or the sampling
interval). In this method, the software consists of two parts: the main program and the
timer interrupt service routine (ISR).
As shown in Figure 6.3 in the form of a Program Description Language (PDL), in the main
program various variables such as the setpoint value, PID controller parameters, as well
as the A/D converter and the timer interrupt mechanism are initialized. The setpoint value
can either be hardcoded into the software or a keypad & pushbutton combination can be
used to set it. The timer is set to interrupt at an interval equivalent to the chosen sampling
interval of the system.
The main program then enters a loop waiting for the timer interrupts to occur. Whenever a
timer interrupt occurs, the program jumps the interrupt service routine where the PID con-
troller algorithm is implemented in software. The error signal is obtained by calculating the
difference between the setpoint value and measured output value. The algorithm is then
implemented and the output sample for the current sampling time is obtained.
A pre-processing step is then performed by updating the variables for the next sample. On
return from the ISR, the program waits in the main program until the next sampling inter-
val, while the above process repeats forever.
MAIN:BEGIN
Initialize PID parameters
Initialize other variables used
Set/Read setpoint value, sk
Initialize ADC
Initialize Timer interrupts, interrupt at T intervals
DO FOREVER
Wait for timer interrupts
ENDDO
MAIN:END
ISR:BEGIN
Get setpoint, sk
Read output, yk
Calculate error, ek
Calculate controller output, uk (section 6.2)
Limit uk to avoid interrupt windup
Update controller memory variables, pk-1 and ek-1
Return from interrupt
ISR:END
Figure 6.3: Controller implementation on a microcontroller.
● 92
Chapter 7 • On-Off Temperature Control
7.1 Overview
Temperature control is used to control the temperature of a gas (e.g., air) in a closed space,
or the temperature of liquid in a container, or for example to control the temperature of
an oven. Here, the aim is to design a controller which will force the measured temperature
to be the same as the desired SetTemp temperature. Thus, if for example the measured
temperature changes then the controller will take the necessary steps to force the output
temperature to be same as the SetTemp value. Also, if the SetTemp value is changed then
again the controller will make sure that the SetTemp and the measured values are the
same. The controller takes inputs from temperature sensors and provides output that is
usually connected to a heater or a fan.
7.2 Temperature Controllers

Basically, three types of temperature controllers are in common use as described below.
ON-OFF temperature control

This is perhaps the simplest form of temperature controller, where the output from the
controller is either on or off. A heater is usually connected to a relay in on-off control. If the
measured temperature is above the SetTemp value, then the relay and consequently the
heater is turned off. If on the other hand, the measured temperature is below the SetTemp
value, then the relay and hence the heat are turned on.
One disadvantage of this method is that the temperature is not controlled closely, and also
the rapid cycling of the relay can shorten its life and can cause damage to it. One technique
used in On-Off control is to add hysteresis to the controller operation. With the hysteresis,
the measured temperature is allowed to exceed the SetTemp value by some amount before
the relay is turned off. Similarly, the measured temperature is allowed to drop below the
SetTemp value by some amount before the relay is turned back on. For example, if the
SetTemp value is 20 ºC, a 2 ºC hysteresis can be used such that the relay turns off when
the temperature reaches 22 ºC, and it turns on when the temperature falls below 18 ºC.
Although this technique will eliminate the rapid cycling of the relay, it has the disadvantage
that the output temperature will fluctuate between the two limits of the hysteresis points.
The response will show overshoot and undershoot from the setpoint value.
The On-Off type control is used in applications where precise control of the temperature is
not required, or in temperature alarm systems such that an alarm is generated if the tem-
perature goes above or below pre-specified values.
Proportional temperature control

This control method is similar to On-Off but here the power supplied to the heater is de-
creased as the measured temperature approaches the SetTemp value. This way, the meas-
ured temperature will not overshoot the SetTemp value, and therefore a closely controlled
temperature output can be obtained. Way below the SetTemp value, full power is applied
to the heater as is the case with On-Off control.
● 93
PID temperature control

This is by far the best temperature controller method as enables precise control of the tem-
perature. As you have seen in previous Chapters, the PID parameters must be selected cor-
rectly for successful control of the plant. i.e., the PID must be tuned correctly. PID control
is used in temperature applications, such as in ovens, furnaces, and chemical plants, where
close control of the temperature is required with quick action to the SetTemp or measured
temperature changes.
In the remaining sections of this Chapter, you'll examine ON-OFF temperature controllers
using the Arduino Uno and the Raspberry Pi computers.
7.3 Project 1: ON-OFF Temperature Control with Arduino Uno

Description: In this project you will be implementing an ON-OFF type control algorithm to
control the temperature in a room. In this project, the desired temperature (SetTemp) is
fixed in the program for simplicity.
Block diagram: Figure 7.1 shows the block diagram of the project. A relay is controlled
from the Arduino Uno which turns the heater power on/off. A red LED indicates when the
relay (i.e., the heater) is ON. The room temperature is sensed using an analog TMP36 type
semiconductor temperature sensor chip.
Figure 7.1: Block diagram of the project.
Circuit diagram: The circuit diagram of the project is shown in Figure 7.2. An I2C type LCD
is used in this project with the on-board PCF8574T type I2C controller chip. The interface
between the Arduino Uno and the external components are as follows (Ground and power
supply pins are not shown):
External component Arduino Uno port

TMP36 A0
RELAY (Pin S) 2
LED 3
LCD SDA, SCL
● 94
Figure 7.2: Circuit diagram of the project.
I2C LCD: The Arduino Uno has one I2C bus at the following pins:
A4 SDA also marked near AREF pin
A5 SCL also marked near AREF pin
As shown in Figure 7.3, the I2C address of the PCF8574T chip is selected by 3 jumpers
labeled A0, A1, and A2 on the controller board. By default, the address is set to 0x27 (i.e.,
no jumper connections), but your LCD address may be different.
Figure 7.3: LCD I2C address selection.
Before using the I2C LCD, you have to add the I2C library to our IDE. Libraries are often
distributed as a ZIP file or folder where the name of the folder is the name of the library.
Inside the folder, there is a .cpp file, a .h file, a keywords.txt file, examples folder, and
other files that may be required by the library. You should not unzip the library.
The steps to add the I2C LCD library are as follows:
• Browse to the following website to locate the library file (the file is also
available in the support software package for the book):
https://www.arduinolibraries.info/libraries/liquid-crystal-i2-c
• Download this file: LiquidCrystal_I2C-1.1.2,zip to a folder on your PC.
● 95
• Start the IDE.
• Click Sketch  Include Library  Add .ZIP Library.
• Select the saved library file and click Open.
• Return to Sketch  Include Library menu and you should see the new library
at the bottom of the drop-down menu.
• To test that the library has been added successfully, enter the following lines in
a newly created program:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
void setup()
{
void loop()
{
}
• Compile the program. There should be no errors.
The I2C LCD library supports many functions. Some most commonly used functions are:
init(): initialize LCD (This must be the first function call)

clear(): clear the screen
home(): home the cursor
noBlink(): stop blinking cursor
blink(): enable blinking cursor
noCursor(): hide cursor
cursor(): display cursor
scrollDisplayLeft(): scroll display left
scrollDisplayRight(): scroll display right
noBacklight(): disable backlight
backlight(): enable backlight
setCursor(column, row): set cursor position (0, 0) is the top-left position
print(): print data on LCD
write(): write to LCD
The address of the I2C LCD must be defined at the beginning of the program. For example,
if the address is 0x3F and the LCD is 16 columns by 2 rows (i.e., 16×2), then:
● 96
LiquidCrystal_I2C lcd(0x3F, 16, 2);
Following the above statement, you can call the LCD functions by indexing them with the
keyword lcd. For example, to initialize the LCD:
lcd.init(); // initialize the lcd
or, for example to enable the backlight, use:
lcd.backlight(); // Enable backlight
Program listing: Figure 7.4 shows the program listing (Program: AONOFF1). At the
beginning of the program, SetTemp is set to 20.0 degrees C, and the LED and RELAY
are assigned to port numbers 3 and 2, respectively. Inside the setup() function, both the
RELAY and LED are configured as outputs and are deactivated to start with.
The output voltage of the TMP36 temperature sensor chip is proportional to the tempera-
ture and is given by:
T = (Vo – 500) / 10
Where T is the measured temperature in Degrees C, and Vo is the sensor output voltage is
millivolts.
Inside the main program loop the room temperature is read by the ADC channel A0 and
subsequently compared to the desired temperature. If the room temperature is lower than
the desired temperature then both the LED and RELAY are activated so that the heater is
turned ON, otherwise they are deactivated to turn OFF the heater. The program checks the
temperature every 10 seconds. The SetTemp and RoomTemp are displayed on the LCD
as shown in Figure 7.5.
//----------------------------------------------------------------------
// ON-OFF TEMPERATURE CONTROL
// ==========================
//
// This is an ON-OFF temperature controller project. The ambient temperature
// is read and compared to the desired set value. If it is less than the set
// value then the relay and LED are activated, otherwise they are deactivated
//
// Author: Dogan Ibrahim
// File : AONOFF1
// Date : June, 2022
//----------------------------------------------------------------------
#include <Wire.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
● 97
float SetTemp = 20.0; // Desired temperature

#define TMP36 A0 // TMP36 at port A0
int raw;
int LED = 3; // LED at port 3
int RELAY = 2; // RELAY at port 2
void setup()
{
pinMode(LED, OUTPUT); // LED is output
pinMode(RELAY, OUTPUT); // RELAY is output
digitalWrite(LED, LOW); // LED OFF at beginning
digitalWrite(RELAY, LOW); // RELAY OFF at beginning
lcd.init(); // Initialize LCD
lcd.backlight(); // Backlight ON
}
void loop()
{
raw = analogRead(TMP36); // Read temperature
float mV = 5000.0 * raw / 1023.0; // in mV
float RoomTemp = (mV-500.0) / 10.0; // Room temperature in C
lcd.clear(); // Clear LCD

lcd.setCursor(0, 0);
lcd.print(" SetTemp = "); // Display SetTemp =
lcd.print(SetTemp); // Display SetTEmp
lcd.print("RoomTemp = "); // Display RoomTemp =
lcd.print(RoomTemp); // Display RoomTemp
if(SetTemp > RoomTemp) // If cold

{
digitalWrite(LED, HIGH); // LED ON
digitalWrite(RELAY, HIGH); // RELAY ON
}
else
{
digitalWrite(LED, LOW); // LED OFF
digitalWrite(RELAY, LOW); // RELAY OFF
}
delay(10000); // Wait 10 seconds
}
Figure 7.4: Program: AONOFF1.
● 98
Figure 7.5: The LCD display.
7.4 Project 2: ON-OFF Temperature Control with Hysteresis and

Arduino Uno
Description: This project is very similar to Project 1, but here the temperature is kept
between two values TLOW and THIGH. In this project TLOW and THIGH are set to 25 ºC
and 27 ºC respectively.
The block diagram and circuit diagram of the project are as in Figure 7.1 and 7.2, respec-
tively.
Program listing: Figure 7.6 shows the program listing (Program: AONOFF2). This pro-
gram is very similar to the one given in Figure 7.4 but here the temperature is kept be-
tween TLOW and THIGH. If the room temperature is equal to or lower than TLOW then the
relay is activated. If on the other hand the room temperate higher or equal to THIGH then
the relay is deactivated. Figure 7.7 shows the LCD output.
//--------------------------------------------------------------------------
// ON-OFF TEMPERATURE CONTROL WITH HYSTERESIS
// ==========================================
//
// This is an ON-OFF temperature controller project. The ambient temperature
// is read and compared to TLOW. If it is lower than or equal to TLOW then the
// relay is activated. If on the other hand it is higher than or equal to THIGH
// then the relay is deactivated.
//
// File : AONOFF2
//---------------------------------------------------------------------------
#include <Wire.h>
float TLOW = 25.0; // Low limit

float THIGH = 27.0; // High limit
int raw;
● 99
void setup()
{
}
void loop()
{
float mV = 5000.0 * raw / 1023.0; // in mV

lcd.print("TLH="); // Display TLH=
lcd.print(TLOW); // Display TLOW
lcd.print("-"); // Display -
lcd.print(THIGH); // Display THIGH
lcd.print("RoomTemp = "); // Display RoomTemp =
if(RoomTemp <= TLOW) // If lower or equal

{
}
else
{
if(RoomTemp >= THIGH) // If greater or equal
{
}
}
}
Figure 7.6: ON-OFF control with hysteresis.
● 100
Figure 7.7: The LCD output.
7.5 Project 3: ON-OFF Temperature Control with Button Control –

Arduino Uno
Description: This project is similar to Project 1, but here the desired SetTemp is set using
buttons. Three buttons named as UP, DOWN, and START are used. SetTemp is set to
20 ºC to start with. Pressing UP increments SetTemp, while pressing DOWN decrements it.
When the user is satisfied with the desired SetTemp, the START button should be pressed
to start the temperature controller.
Block diagram: Figure 7.8 shows the block diagram of the project.
Circuit diagram: The circuit diagram of the project is shown in Figure 7.9. The control
buttons UP, DOWN, and START are connected to Arduino Uno port pins 4, 5, and 6, respec-
tively. The output state of the buttons is at logic 1 and go to logic 0 when pressed. The LCD,
relay, and the LED are connected as in Project 1.
Figure 7.9:Circuit diagram of the project.
● 101
Program listing: Figure 7.10 shows the program listing (Program: AONOFF3). Function
Desired() controls the button actions. When the program runs, the default value of the
SetTemp (20 ºC) is displayed. Pressing button UP will increment the SetTemp by one, while
pressing button DOWN will decrement it by one. Pressing the START button will launch the
controller. The control action is as in Project 1 where the SetTemp value is compared to the
measured value (RoomTemp) and the relay is turned ON or OFF to control the heater. At
this point, the program will have to be restarted in order to set another SetTemp value. The
control action is implemented at every 10 seconds.
//--------------------------------------------------------------------------
// ON-OFF TEMPERATURE CONTROL - SetTemp with buttons
// =================================================
//
// This is an ON-OFF temperature controller project. In this version of the
// project the SetTemp is set using buttons
//
// File : AONOFF3
//---------------------------------------------------------------------------
#include <Wire.h>
float SetTemp = 20.0; // Initial SetTEmp

int raw;
int UP = 4; // UP at 4
int DOWN = 5; // DOWN at 5
int START = 6; // START at 6
int ExitFlag = 0;
void setup()
{
pinMode(UP, INPUT); // Button is input
pinMode(DOWN, INPUT); // Button is input
pinMode(START, INPUT); // Button is input
Desired();
● 102
//
// This function sets the desired temperature using buttons
//
void Desired()
{
lcd.clear();
while(ExitFlag == 0)
{
lcd.print("SetTemp = ");
lcd.print(SetTemp);
while(digitalRead(UP) == 1 && digitalRead(DOWN) == 1 && digitalRead(START)==
1);
if(digitalRead(UP) == 0)
{
SetTemp++;
while(digitalRead(UP) == 0);
}
else if(digitalRead(DOWN) == 0)
{
SetTemp--;
while(digitalRead(DOWN) == 0);
}
delay(10);
if(digitalRead(START) == 0)ExitFlag = 1;
}
}
void loop()
{
float mV = 5000.0 * raw / 1023.0; // in mV

lcd.setCursor(0, 0); // Cursor at 0,0
lcd.print("SetTemp = "); // Display SetTemp
lcd.print(SetTemp);
lcd.setCursor(0, 1); // Cursor at (0,1
lcd.print("RoomTemp= "); // Display RoomTemp =
if(RoomTemp < SetTemp) // If lower
● 103
{
}
else
{
}
}
7.6 Project 4: ON-OFF Temperature Control with Rotary Encoder and

Arduino Uno
Description: This project is similar to the previous temperature control projects, but here
a rotary encoder is used to set the SetTemp. Initially SetTemp is set to 20ºC and rotating
the arm of the rotary encoder you can increase or decrease the SetTemp value.
Figure 7.11 Block diagram of the project.
A rotary encoder (Figure 7.12) is a device that looks like a potentiometer and it senses the
rotation and direction of its knob. The device has two internal contacts that make and break
a circuit as the knob is turned. As the knob is turned, a click is felt that indicates that the
know has been rotated by one position. With a simple logic you can determine the direction
of rotation.
A rotary encoder has the following pins:
GND: power supply ground
Vcc (+): power supply
● 104
CLK: This is an output pin used to determine the amount of rotation. Each time the
knob is rotated by one click in either direction, the CLK output goes to HIGH and
then LOW
DT: This is an output similar to CLK pin, but it lags the CLK by 90 degrees. This
output is used to determine the direction of rotation
SW: This is an active LOW push button. When the knob is pushed, the voltage
goes LOW
Figure 7.12: Rotary encoder.
In our project each rotation (i.e., click) of the knob will increment (or decrement) the Set-
Temp by 1ºC. Turning the knob in one direction will increment by one, while turning it in
the other direction will decrement it by one. When the required value is reached, the user
has to push the knob so that the controller action.
Circuit diagram: the connections between the Arduino Uno and the external components
are as follows (power supply and GND connections are not shown):
External component Arduino Uno port

LED 3
Relay 2
LCD SCL, SDA
TMP36 A0
Encoder CLK 4
Encoder DT 5
Encoder SW 6
The circuit diagram of the project is shown in Figure 7.13.
● 105
Program listing: Figure 7.14 shows the program listing (Program: AONOFF4). At the
beginning of the program the interface between Arduino Uno and external components are
defined and the variables used in the program are initialized.
Inside the setup() function, LED and RELAY ae configured as outputs, and the rotary en-
coder pins are configured as inputs. The LED and RELAY are turned OFF at the beginning
of the program and the LCD is initialized. The program then calls function Rotary(). This
function senses when the user turns the encoder arm and increments or decrements var-
iable SetTemp depending on which direction the arm is rotated. When the user is happy
with the SetTemp value, the rotary encoder shaft should be pushed in. After reading the
SetTemp value, the remainder of the program is same as in Project 1.
//--------------------------------------------------------------------------
// ON-OFF TEMPERATURE CONTROL - SetTemp with Rotary Encoder
// ========================================================
//
// This is an ON-OFF temperature controller project. In this version of the
// project the SetTemp is set using a rotary encoder
//
// File : AONOFF4
//---------------------------------------------------------------------------
#include <Wire.h>
float SetTemp = 20.0; // Initial SetTEmp

int raw;
● 106
int CLK = 4; // CLK pin

int DT = 5; // DT pin
int SW = 6; // SW pin
int flag = 1;
int ClkState, ClkOldState, DTState, SWState;
void setup()
{
pinMode(CLK, INPUT); // CLK is input
pinMode(DT, INPUT); // DT is input
pinMode(SW, INPUT_PULLUP); // SW is input
Rotary();
}
//
// This functon reads the rotary encoder value as the encoder arm
// is rotated. The SetTemp value in changes by 1 (incremented or
// decremented at each click of the rotary encoder).
//
void Rotary()
{
ClkOldState = digitalRead(CLK);
lcd.print("SetTemp:"); // Display SetTemp
lcd.print(SetTemp); // Display initial value
while(flag == 1)
{
ClkState = digitalRead(CLK);
DTState = digitalRead(DT);
if(ClkState != ClkOldState && ClkState == 1)
{
if(DTState != ClkState)
SetTemp++; // Increment SetTemp
else
{
SetTemp--; // Decrement SetTemp
if(SetTemp == 0)SetTemp = 20; // Back to 20 if 0
● 107
}
lcd.print(" "); // Delete
lcd.setCursor(0, 1); // Cursor back at 0,1
lcd.print(SetTemp); // Display SetTEmp
}
ClkOldState = ClkState;
SWState = digitalRead(SW); // Read stste of SW button
if(SWState == 0)flag = 0; // Exit Rotary() function
}
}
void loop()
{
float mV = 5000.0 * raw / 1023.0; // in mV

lcd.print("SetTemp = "); // Display SetTemp
lcd.print(SetTemp);
lcd.setCursor(0, 1); // Cursor at (0,1
lcd.print("RoomTemp= "); // Display RoomTemp =
if(RoomTemp < SetTemp) // If lower

{
}
else
{
}
}
Figure 7.15 shows the LCD display when the program is first run, where the default tem-
perature value 20 ºC is displayed before the rotary encoder arm is rotated.
● 108
Figure 7.15: Initial LCD display.
7.7 Project 5: ON-OFF Temperature Control with Raspberry Pi 4

Description: In this project, you will be using the Raspberry Pi 4 for ON-OFF temperature
control. As in Project 1, you will hardcode the desired SetTemp value in software.
Block diagram: Figure 7.16 shows the block diagram of the project. This figure is very
similar to Figure 7.1, but here you have used an external ADC chip to convert the analog
temperature output of the TMP36 sensor into digital form. This is because the Raspberry Pi
does not have any ADC channels and external ADC chips must be used to interface analog
devices to Raspberry Pi.
Circuit diagram: In this project, the MC3002 ADC chip is used (Figure 7.17). This chip has
the following features:
• 10-bit resolution (0 to 1023 quantization levels)

• On-chip sample and hold
• SPI bus compatible
• Wide power supply range (+2.7 to +5.5V)
• 75 ksps sampling rate
• 8-pin package
• 5 nA standby current, 50 µA active current
The MCP3002 is a successive approximation 10-bit ADC with on-board sample and hold
circuitry. The chip is programmable to operate as either a differential-input pair or as dual
single-ended inputs. The pin definitions are as follows:
● 109
Vdd/Vref: Power supply and reference voltage input

CH0: Channel 0 analog input
CH1: Channel 1 analog input
CLK: SPI clock input
DIN: SPI serial data in
DOUT: SPI serial data out
CS/SGDN: Chip select/shutdown input
In this project, the supply voltage and the reference voltage are both set to +3.3 V. Thus,
the digital output code is given by:
Digital output code = 1024 × Vin / 3.3
or
Digital output code = 310.30 × Vin
Each quantization level corresponds to 3300 mV/1024 = 3.22 mV.
Thus, for example, digital input data "00 00000001" corresponds to 3.22 mV, "00 00000010"
corresponds to 6.44 mV, and so on.
The MCP3002 has two configuration bits: SGL/DIFF and ODD/SIGN. These bits follow the
sign bit and are used to select the input channel configuration. The SGL/DIFF is used to
select single-ended or differential mode. The ODD/SIGN bit selects which channel is used
in single-ended mode and is used to determine polarity in differential mode. In this project,
you are using channel CH0 in single-ended mode. According to the MCP3002 datasheet,
SGL/DIFF and ODD/SIGN must be set to 1 and 0 respectively.
Figure 7.17: The MCP3002 ADC chip.
Notice that Raspberry Pi pins are not +5 V tolerant, but the I2C LCD operates with +5 V
where its SDA and SCL pins are pulled to +5 V. It is generally not a good idea to connect
the LCD directly to the Raspberry Pi as it can damage its I/O circuitry. There are several
solutions here. On solution is to remove the I2C pull-up resistors on the LCD module. The
other option is to use an I2C which operates with +3.3 V. The other solution is to use a bidi-
rectional +3.3 V to +5 V logic level converter chip. In this project, you will use the TXS0102
bidirectional logic level converter chip like the one shown in Figure 7.18.
● 110
Figure 7.18: Logic level converter.
The circuit diagram of the project is shown in Figure 7.19. The interface between the Rasp-
berry Pi 4 and the external devices are as follows (power and ground connections are not
shown):
External device Raspberry Pi 4 port Raspberry Pi pin no

RELAY GPIO17 11
ADC DIN GPIO10 19
ADC CLK GPIO11 23
ADC DOUT GPIO9 21
ADC CS GPIO8 24
LED GPIO27 13
LCD SCL GPIO3 5
LCD SDA GPIO2 3
Enabling the SPI and I2C buses on your Raspberry Pi

You have to enable the SPI bus since the MC3002 uses it. Also, the I2C bus must be enabled
to use the I2C LCD. The steps are:
● 111
• Start your Raspberry Pi in command mode.

• Enter sudo raspi-config.
• Scroll down to Interface Options (Figure 7.20).
Figure 7.20: Scroll down to Interface Options.
• Select SPI.
• Select <Yes> to enable the bus and select <OK>.
• Select Interface Options again.
• Select I2C.
• Select <Yes> to enable the bus and select <OK>.
• Move the cursor to <Finish> and press Enter to exit.
• Enter the following command:
sudo apt install -y i2c-tools python3-smbus
• Restart your Raspberry Pi by typing:
sudo reboot
Checking the LCD I2C address

After building the hardware, you should enter the following command to check the address
of the I2C LCD:
sudo i2cdetect –y 1
you should see display as shown in Figure 7.21. The address of the LCD author is using
was: 0x27.
● 112
Figure 7.21: Checking the I2C LCD address.
Installing the I2C library

Before you start developing our controller software, you have to install an I2C LCD library.
There are several libraries available on the Internet. The one chosen by the author is
named RPLCD and it can be installed as follows:
sudo pip3 install RPLCD
The I2C LCD library supports the following functions (see the RPLCD I2C LCD library docu-
mentation for more details):
lcd_clear() clear LCD and set to home position

cursor_pos = (row, column) position cursor
lcd.write_string(text) display text
lcd.write_string(text\r\n) display text followed by new line
lcd.home() home cursor
lcd.cr() insert carriage-return
lcd.lf() insert line-feed
lcd.crlf() insert carriage-return and line-feed
Testing the I2C bus and LCD

It is worthwhile to test the LCD display before developing our controller program. Create
the simple test program shown in Figure 7.22 (Program: lcdtest.py) which send the text
MY LCD to the LCD.
If you have used a text editor (e.g., nano) to create the program, you can run it by enter-
ing the following command:
python3 lcdtest.py
If on the other hand you have used the Thonny IDE, then just run the program.
#---------------------------------------
#
# LCD TEST PROGRAM
# ================
#
● 113
# Author: Dogan Ibrahim

# File : lcdtest.py
# Date : June, 2022
#---------------------------------------
from RPLCD.i2c import CharLCD
lcd=CharLCD('PCF8574', 0x27)
lcd.clear()
lcd.home
lcd.write_string("MY LCD")
Figure 7.22: LCDtest program.
Testing the SPI bus

To test the SPI bus, enter the command:
sudo ls –l /dev/spidev*
You should get the display shown in Figure 7.23.
Figure 7.23: Testing the SPI bus.
SPI bus functions

Python supports the following SPI bus functions:
Function Description
open (0, 0): Open SPI bus 0 using CE0

open (0, 1): Open SPI bus 0 using CE1
close(): disconnect the device from the SPI bus
writebytes([array of bytes]): Write an array of bytes to SPI bus device
readbytes(len): Read len bytes from SPI bus device
xfer2([array of bytes]): Send an array of bytes to the device with CEx
asserted at all times
xfer([array of bytes]): Send an array of bytes de-asserting and
asserting CEx with every byte transmitted
You are now ready to develop our controller program.
Program listing: Figure 7.24 shows the Raspberry Pi Python program listing (Program:
AONOFF5.py). At the beginning of the program the library modules used in the program
are imported to the program. SetTemp is set to 33 ºC and the LED and RELAY ports are
defined. The function Setup() configures LED and RELAY as outputs and deactivates them
at the beginning of the program.
● 114
The function Get_ADC_Data() is used to read the analog data from the temperature sen-
sor chip, where the channel number (channel_no) is specified in the function argument as
0 or 1. Notice that you have to send the start bit, followed by the SGL/DIFF and ODD/SIGN
bits and the MSBF bit to the MCP3002 ADC chip. It is recommended to send leading zeroes
on the input line before the start bit. This is often done when using microcontroller based
systems required to send 8 bits at a time.
The following data can be sent to the ADC (SGL/DIFF = 1 and ODD/SIGN = channel_no) as
bytes with leading zeroes for more stable clock cycle. The general data format is:
0000 000S DCM0 0000 0000 0000
Where, S = start bit, D = SGL/DIFF bit, C = ODD/SIGN bit, and M = MSBF bit.
For channel 0: 0000 0001 1000 0000 0000 0000 (0x01, 0x80, 0x00)
For channel 1: 0000 0001 1100 0000 0000 0000 (0x01, 0xC0, 0x00)
Notice that the second byte can be sent by adding 2 to the channel number (to make it 2 or
3) and then shifting 6 bits to the left as shown above to give 0x80 or 0xC0. The chip returns
24-bit data (i.e., 3 bytes) and you must extract the correct 10-bit ADC data from this 24-bit
data. The 24-bit data is in the following format ("X" is don't care bit):
XXXX DDDD DDDD DDXX
Assuming that the returned data is stored in 24 bit variable ADC, you have:
ADC[0] = "XXXX"
ADC[1] = "XXXX DDDD"
ADC[2] = "DDDD DDXX"
Thus, you can extract the 10-bit ADC data with the following operations:
(ADC[2] >> 2) so, low byte = "00DD DDDD"
and
(ADC[1] & 15) << 6) so, high byte = "DD DD00 0000"
Adding the low byte and the high byte you get the 10-bit converted ADC data as:
DD DDDD
The raw data read from the ADC is stored in variable adc, which is then converted into
physical voltage in millivolts and stored in variable mv. This value is then converted into
temperature in degrees Celsius by subtracting 500 and dividing by 10, and then stored
● 115
in variable Temperature. SetTemp is compared with the measured temperature, and if

the measured value is less than SetTemp then the RELAY is activated which turns ON the
heater to increase the temperature. At the same time the LED is turned ON to indicate that
power is applied to the heater. If the SetTemp is higher than the measured temperature,
then the opposite action is taken where the RELAY is deactivated and the LED is turned OFF.
The above process repeats forever after 5 seconds of delay.
#----------------------------------------------------------
#
# ON-OFF TEMPERATURE CONTROLLER
# =============================
#
# This is an ON-OFF temperature controller program.
# The meaured temperatrue is compared to the SetTemp
# and if it greater than SetTemp then the relay and LED
# are turned OFF, otherwise they are both turned ON
#
# File : AONOFF5.py
# Date : June, 2022
#----------------------------------------------------------
import RPi.GPIO as GPIO
import time
import spidev
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
lcd=CharLCD('PCF8574', 0x27) # Init LCD

spi = spidev.SpiDev() # Init SPI
spi.open(0, 0)
spi.max_speed_hz=4000 # SPI speed
SetTemp = 33.0 # SetTemp
LED = 27 # LED port
RELAY = 17 # RELAY port
#
# This function configures the LED and RELAY and set them
# both OFF at the beginning of the program
#
def Setup():
GPIO.setup(LED, GPIO.OUT) # LED is output
GPIO.setup(RELAY, GPIO.OUT) # RELAY is output
GPIO.output(LED, 0) # LED OFF
GPIO.output(RELAY, 0) # RELAY OFF
● 116
#
# This function returns the ADC result in variable rcv
#
def Get_ADC_Data(channel_no):
ADC = spi.xfer2([1, (2 + channel_no) << 6, 0])
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
Setup()
while True: # Do Forever
adc = Get_ADC_Data(0) # Read temperature
mv = adc * 3300.0 / 1024.0 # Convert to mV
Temperature = (mv - 500) / 10.0 # In Degrees C
lcd.clear() # Clear LCD
lcd.home() # Home LCD
head1 = "SetTemp = " + str(SetTemp) # Heading
lcd.write_string(head1) # Write top row
head2 = "Measured= " + str(Temperature)[:4] # Heading
lcd.cursor_pos = (1, 0) # Bottom row
lcd.write_string(head2) # Write bottom row
if Temperature < SetTemp: # If Temp < SetTEmp

GPIO.output(RELAY, 1) # RELAY ON
GPIO.output(LED, 1) # LED ON
else: # ELSE
GPIO.output(RELAY, 0) # RELAY OFF
GPIO.output(LED, 0) # LED OFF
time.sleep(5) # Wait 5 sec
Figure 7.24: Program: AONOFF5.py.
Figure 7.25 shows an example display of the LCD. Figure 7.26 shows the project built on
a breadboard.
Figure 7.25: Example LCD display.
● 117
Figure 7.26: Project built on a breadboard (relay and heater are not shown).
● 118
Chapter 8 • PID Temperature Control with the Raspberry Pi
Chapter 8 • PID Temperature Control with the

Raspberry Pi
8.1 Overview
In the previous Chapter you engaged in designing ON-OFF type temperature control sys-
tems using Arduino and Raspberry Pi computers. In this Chapter you will learn how to de-
sign PID based temperature control systems using the Raspberry Pi 4 computer.
8.2 Project 1 - Reading the temperature of a thermistor

In this Chapter you will be controlling the temperature of a 3D printer hotbed. Figure 8.1
shows the hotbed which is basically a 12 cm x 12 cm bed with in-built heater and thermistor
temperature sensor. The basic specifications of this hotbed are:
• Power supply:12 V, 120 W

• Built-in NTC 3950 type 100 K thermistor
• Size: 12 × 12 × 3 cm
• Weight: 80 g
• Working temperature: Up to 200 ºC
• Made of durable silicone rubber
• Adhesive back
Figure 8.1: 3D printer hotbed with built-in thermistor.
The hotbed is fixed on an aluminum plate enabling it to dissipate its heat. Before developing
the PID controller software for the hotbed, you will learn how to measure the temperature
of the hotbed via the built-in thermistor.
The NTC 3950 thermistor

Figure 8.2 shows the NTC 3950 thermistor device. The specifications of this thermistor are
as follows:
● 119
• Temperature at 25 ºC: 100 kΩ

• Thermistor B value: 3950
• Operating temperature: –55 ºC to +125 ºC
The hotbed has 4 wires: 2 for the heater and 2 for the thermistor. The thermistor wires are
identified easily because they are much thinner than the heater wires.
Figure 8.2: NTC 3950 thermistor.
Measuring the temperature

Temperature measurement using a thermistor requires to find the resistance of the ther-
mistor at the temperature to be measured and then using the Steinhart-Hart equation
(see section 2.2.1). The resistance of the thermistor is found by connecting a series resistor
to the thermistor to form a resistive potential divide circuit and then measuring the voltage
across the series resistor (or thermistor).
Figure 8.3 shows the circuit to be used to measure the thermistor resistance.
Figure 8.3: Resistive potential divider circuit.
Assuming a power supply of +3.3 V, The voltage across the series resistor is given by:
, where is the series resistance, and is the resistance of the

thermistor.
● 120
From this equation, the resistance of the thermistor is given by:
Choosing a 100 kΩ series resistor, you have:
where is in millivolts
,
You can then use the Steinhart-Hart equation to find the temperature as described in
Chapter 2:
The output voltage of the resistive potential divider circuit is connected to CH0 of the
MCP3002 ADC as shown in Figure 8.4.
Figure 8.4: Circuit diagram to measure the temperature.
Program listing: Figure 8.5 shows the program listing (Program: thermistor). At the be-
ginning of the program the libraries used are imported to the program, resistors
are initialized. Function Get_ADC_Data() returns the analogue value read from the
thermistor. Function Calc_Temperature() calculates the temperature using the Stein-
hart-Hart equation, which is displayed every 2 seconds on the screen. Figure 8.6 shows
the temperature readings displayed on te screen.
● 121
#----------------------------------------------------------
#
# THERMISTOR TEMPEARTURE SENSOR
# =============================
#
# This program measures the temperature of a thermistor
#
# File : thermistor.py
# Date : June, 2022
#----------------------------------------------------------
import time
import spidev
import math

spi.open(0, 0)
B = 3950 # Thermistor B
R0 = 100000 # Thermistor R0
Rs = 100000 # Rs
T0 = 298.15 # T0 temp
#
#
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
#
# This function calculates the temperature
#
def Calc_Temperature(Vo):
Rt = Rs * (3300 - Vo) / Vo # Find Rt
R = math.log(Rt / R0) # Find temperature
R = R / B # ...
T = R + 1 / T0 # ...
T = 1 / T # ...
T = T - 273.15 # ...
return T
● 122
while True: # Do Forever

adc = Get_ADC_Data(0) # Read temperature
Vo = adc * 3300.0 / 1024.0 # Convert to mV
T = Calc_Temperature(Vo) # Temperature
Temperature = str(T)[:6] # As a string
print(Temperature) # Display temperature
time.sleep(2) # Wait 5 sec
Figure 8.5: Program: thermistor.
Figure 8.6: Temperature readings displayed on the screen.
8.3 Project 2: Open-loop Step-input Time Response

Description: In this project, you will display the step input time response of our hotbed
and then calculate the transfer function so that you can design a suitable PID controller.
Block diagram: Figure 8.7 shows the open-loop block diagram of the project. The temper-
ature of the hotbed is measured with the built-in thermistor as described in Project 1. The
MOSFET switch is driven by the Raspberry Pi PWM (Pulse Width Modulated) output signal
and it switches an external high capacity power supply voltage to provide the required cur-
rent to the hotbed. Since the hotbed operates with 12 V 120 W, the external power supply
must be able to supply at least 10 A of current at 12 V.
Before going into more details of the design, it is worthwhile to review the basic principles
of the PWM signals and the MOSFET switch used in this project.
● 123
PWM
Pulse Width Modulation (PWM) is a commonly used technique for controlling the power
delivered to analog loads using digital waveforms. Although analog voltages (and cur-
rents) can be used to control the delivered power, they have several drawbacks. Controlling
large analog loads require large voltages and currents that cannot easily be obtained us-
ing standard analogue circuits and DACs. Large analog voltage generators can be heavy,
large, and expensive and they are also sensitive to noise. By using the PWM technique the
average value of voltage (and current) fed to a load is controlled by switching the supply
voltage ON and OFF at a fast rate. The longer the power on time, the higher is the voltage
supplied to the load.
Figure 8.8 shows a typical PWM waveform where the signal is basically a repetitive positive
pulse, having the period T, ON time TON and OFF time of T – TON seconds. The minimum and
maximum values of the voltage supplied to the load are 0 and VP respectively. The PWM
switching frequency is usually set to be very high (usually in the order of several kHz) so
that it does not affect the load that uses the power. The main advantage of PWM is that the
load is operated efficiently since the power loss in the switching device is very low. When
the switch is ON there is practically no voltage drop across the switch, and when the switch
is OFF there is no current supplied to the load.
Figure 8.8: PWM waveform.
The duty cycle (or D) of a PWM waveform is defined as the ratio of the ON time to its period.
Expressed mathematically,
Duty Cycle (D) = TON / T
The duty cycle is usually expressed as a percentage and therefore,
D = (TON / TOFF) Ω 100 %
By varying the duty cycle between 0% and 100% you can effectively control the average
voltage supplied to the load between 0 and Vp.
The average value of the voltage applied to the load can be calculated by considering a
general PWM waveform shown in Figure 8.8. The average value A of waveform f(t) with
period T and peak value ymax and minimum value ymin is calculated as:
● 124
or
In a PWM waveform, ymin = 0 and the above equation becomes
or
As evident from the above equation, the average value of the voltage supplied to the load is
directly proportional to the duty cycle of the PWM waveform, and by varying the duty cycle
you control the average load voltage. Figure 8.9 shows the average voltage for different
values of the duty cycle.
Figure 8.9: Average voltage (shown as dashed line) supplied to a load.
By varying the duty cycle you can effectively vary the average analog voltage supplied to
the load, e.g., to a heater and therefore control the heat output.
Raspberry Pi 4 has 2 PWM pins as shown in Table 8.1.
GPIO Pin PWM
GPIO12 PWM0
GPIO18 PWM0
GPIO13 PWM1
GPIO19 PWM1
Table 8.1: Raspberry Pi 4 PWM pins.
● 125
The PWM pin must be configured as an output before it can be used to generate PWM sig-
nals. The following built-in functions are available with Python to control the PWM:
pwm = GPIO.PWM(pwm_pin, freq) Create PWM instance with specified

frequency
pwm.start(0) Start PWM with 0 duty cycle
pwm.ChangeDutyCycle(duty) Set the PWM duty cycle
pwm.stop() Stop PWM
PWM duty cycle has the range 0 to 100, corresponding to 0% (no output) to 100% (full
output).
MOSFET switch
The hotbed operates with 12 V and consumes about 120 watts. This means that about 10
A current is required for its operation. In this project an external 12 V power supply is used
capable of supplying the required power. A MOSFET switch assembly with a large heatsink
is used to power the hotbed. This module is sold as a 3D printer heating controller. The
input to the switch is the PWM waveform from the Raspberry Pi, and its output drives the
hotbed. Figure 8.10 shows the MOSFET switch module used. This module has the following
features:
• Maximum current capacity 30 A

• Control signal +5 V to +24 V
• Size 66.6 × 32 mm
• Large heatsink
Figure 8.10: MOSFET switch module.
● 126
The MOSFET switch operates with +5 V to +12 V but the output voltage of the Raspberry Pi
is only +3.3 V. Therefore, a +3.3 V to +5 V logic level converter chip (Figure 8.11) is used
to provide the required +5 V for the MOSFET switch.
Figure 8.11: +3.3 V to +5 V logic level converter.
Circuit diagram: Figure 8.12 shows the circuit diagram of the project. The thermistor volt-
age is read using the MCP3002 ADC chip and the temperature is calculated as described in
the previous project. GPIO12 is used as the PWM output and is connected to the SIG input
of the MOSFET switch. An external 12 V 10 A DC power supply is connected to this switch.
The other two pins of the MOSFET switch are connected to the hotbed. You should make
sure that the external power supply polarity is correct when connected to the MOSFET
switch. The hotbed has no polarity.
Program listing: Figure 8.13 shows the program listing (Program: StepResponse.py).
In this program, you effectively display the temperature readings in real-time on a graph
using the matplotlib library of the Raspberry Pi. At the beginning of the program, the li-
braries used in the program are imported and the parameters of the thermistor and series
resistor are defined. Function Get_ADC_Data() reads the voltage at the series resistor
and then calculates the resistance of the thermistor. Then, the Steinhart-Hart equation is
used as before to calculate the temperature of the hotbed. Then, a step input is applied to
the hotbed by setting the PWM duty cycle to 25%. The temperature of the hotbed is then
plotted in real-time and is shown in Figure 8.14.
● 127
#----------------------------------------------------------
#
# PID TEMPERATURE CONTROLLER
# ==========================
#
# This is the step response program display
#
# File : StepResponse.py
# Date : June, 2022
#----------------------------------------------------------
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import numpy as np
import time
import spidev
import math

spi.open(0, 0) # USing CE0
Rs = 100000 # Rs
T0 = 298.15 # T0
MOSFET = 12 # MOSFET
GPIO.setup(MOSFET, GPIO.OUT) # PWM port
GPIO.output(MOSFET, 0)
pwm = GPIO.PWM(MOSFET, 100) # PWM at 100 Hz
#
# Setup real time plot
#
def SetupPlot():
plt.axis([0,400, 0,100]) # Axes limits
plt.title('Temperature') # Graph title
plt.xlabel('Time (seconds)') # X label
plt.ylabel('Temperature') # Y label
plt.ion()
return
● 128
#
#
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
#
# This function calculates and returns the thermistor temperature
#
def Calc_Temperature():
adc = Get_ADC_Data(0) # Read voltage
Vo = adc * 3300.0 / 1024.0 # in millivolts
Rt = Rs * (3300 - Vo) / Vo # Find Rt
R = math.log(Rt / R0)
R = R / B
T = R + 1 / T0
T = 1 / T # Temperature
T = T - 273.15 # In Centigrade
return T
SetupPlot() # Initialize plot

i = 0
#
# Send Step input to the hotbed
#
pwm.start(25) # Send 10% PWM step
while i < 450: # Do for 100 secs
T = Calc_Temperature() # Get the temperature
i = i + 1
x = i
plt.scatter(x, T,color='red')
plt.show()
plt.pause(0.0001)
time.sleep(1)
pwm.stop()
Figure 8.13: Program: StepResponse.py.
● 129
Figure 8.14: Open-loop step time response of the system.
Notice that the delay time of the system was small because the thermistor is embedded
to the hotbed and responds quickly to temperature changes. In reference to Figure 8.14,
you can calculate the open-loop system transfer function either graphically or as described
in Chapter 3. Time constant is the value when the response is 63% of the final value.
Therefore, 24 + (84 – 24) × 0.63 = 52.92. Drawing a horizontal line from this point to
the response curve you find that the system time constant is 78 seconds. This is shown in
Figure 8.15, which gives:
Figure 8.15: Calculating the open-loop system parameters.
Note: the program must be run from the Thonny IDE in Desktop mode, and not from the
command mode. This is because graphics can only be drawn in Desktop mode.
8.4 Project 3: PI Temperature Control

Description: This is the PI temperature control project governs the temperature of the 3D
printer hot bed shown in Figure 8.1.
● 130
Block diagram: Figure 8.16 shows the block diagram of the project. The hotbed temper-
ature is measured with the built-in thermistor as described in Project 1. This temperature
is then fed back to the Raspberry Pi where the PI algorithm is implemented to control the
temperature so that it is at the SetTemp. In this project SetTemp is set to 50 ºC and is
hardcoded in the program, which is shown by the LCD. The MOSFET switch is driven by the
Raspberry Pi PWM (Pulse Width Modulated) output signal and it provides the high current
required by the hotbed by switching he external power supply.
Circuit diagram: Figure 8.17 shows the circuit diagram of the project. Notice that the
MOSFET switch requires +5 V for its operation and a logic level converter is used to increase
the Raspberry Pi output voltage to +5 V.
Proportional + Integral (PI) controller parameters

In reference to Figure 8.15 and the Ziegler and Nichols PI table of settings, you find the
following P and I controller parameters:
● 131
The parallel-PI realization shown in Figure 6.1 was used in this project.
Program listing: Figure 8.18 shows the program listing (Program: PItemp.py). At the
beginning of the program the libraries used are imported to the program, I2C LCD and the
SPI bus are initialized. Then the thermistor parameters are defined and PWM output is as-
signed to GPIO12 where the MOSFET switch is connected to.
Function SetupPlot() initializes the real-time graphic drawing parameters. Function Get_
ADC_Data() reads analogue data from the thermistor. Function Calc_Temperature()
reads the thermistor data and returns the temperature in degrees Centigrade. The function
Init() is where the PI parameters are defined and the LCD is configured to display the
SetTemp which is named as sk in the program.
Function PI() implements the PI algorithm as described in Figure 6.2. The error ek is cal-
culated as ek = sk – yk where sk is the SetTemp and yk is the output (i.e., the hotbed
temperature). Then the controller output uk is calculated and sent to the PWM to activate
the MOSFET switch. Note that PWM can only take values between 0 and 100 and therefore
the uk output is bound within these values.
A 'while' loop is formed inside the main program. Inside this loop the temperature of the
hot bed is read and PI() is called to calculate and output the controller values. The time
response of the system (i.e., the change of the hotbed temperature) is plotted in real-time
by the program. It is important that the program must be run in Desktop mode and
the Thonny IDE must be used to run the program so that the system response can
be plotted in real-time. The program WILL NOT work if run from the command
mode. Also, the real-time plot may introduce additional delays to the loop time
which is also the PID sample time. If the real-time plot time is a problem, then the
response time can be stored in a list (e.g., every second) and then plotted offline
at the end of the program. Additionally, it is worth to mention that the time scale
of the graph is not very accurate.
The program is repeated after a 1-second delay. i.e., the sample time is chosen as 1 sec-
ond. To be more precise, you could have setup a 1-second timer interrupt routine and
execute the PI algorithm inside the timer interrupt service routine.
● 132
#----------------------------------------------------------
#
# PI TEMPERATURE CONTROLLER
# =========================
#
# This is the PI temperature controller program
#
# File : PItemp.py
# Date : June, 2022
#----------------------------------------------------------
import matplotlib
import numpy as np
import time
import spidev
import math

spi.open(0, 0) # Using CE0
Rs = 100000 # Rs
T0 = 298.15 # T0
GPIO.setup(MOSFET, GPIO.OUT)
pwm = GPIO.PWM(MOSFET, 100) # PWM port
global sk, Kp, T, Ti, pk, pk_1, b, yk
#
#
def SetupPlot():
plt.title('Temperature') # Title
plt.xlabel('Time (seconds') # X label
● 133
plt.ion()
return
#
#
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
#
# This function calculates and returns the temperature in C
#
adc = Get_ADC_Data(0) # Get ADC value
Rt = Rs * (3300 - Vo) / Vo # Calculate Rt
R = R / B
T = R + 1 / T0
T = 1 / T # T in Kelvin
T = T - 273.15 # In Degrees C
return T
#
# This function initializes the LCD and displays SetTemp
#
def Init():
global sk, b, Kp, T, Ti, pk, pk_1
sk = 50 # SetTemp
Kp = 2.0
T = 1.0
Ti = 50.0
b = Kp*T/Ti
pk = 0.0
pk_1 = 0.0
lcd.home() # Home cursor
lcd.cursor_pos = (0, 0) # At 0,0
lcd.write_string("SetTemp:") # Heading
lcd.write_string(str(sk)) # SetTEmp
return
● 134
# This is the Proportional+Integral algorithm function

#
def PI():
global yk, pk_1
ek = sk - yk
pk = b*ek + pk_1
wk = Kp*ek
uk = wk + pk # PI output
if uk > 100.0: # Limit uk for PWM
uk = 100.0
if uk < 0.0: # Limit uk for PWM
uk = 0.0
pwm.ChangeDutyCycle(uk) # To PWM
pk_1 = pk # Update pk_1
return
Init() # Init LCD

SetupPlot() # Setup plot
i = 0
pwm.start(0)
while i < 400: # Do Forever
yk = Calc_Temperature()
PI()
i = i + 1
plt.scatter(i, yk,color='red')
plt.pause(0.00001)
EndTime = time.time() + 1
while time.time() - EndTime < 0:
pass
pwm.stop()
Figure 8.18: Program: PItemp.py.
Figure 8.19 shows the closed-loop output time response of the system where the SetTemp
(desired temperature) was set to 50 ºC. Notice that even though the steady-state error is
zero and the response settles down at 50 ºC, the response shows a large overshoot which
is not acceptable in many process control systems. Large overshoot is one of the results of
tuning a system using the Ziegler and Nichol algorithm.
● 135
Figure 8.19: Closed-loop system time response.
The integral time Ti was increased and the proportional constant reduced in order to de-
crease the overshoot and get a more acceptable result. Figure 8.20 shows the result when
Kp = 2.0 and Ti = 35.0.
Figure 8.20: Improved response.
Finally, an acceptable and nice response was obtained by increasing Ti further. Figure 8.21
shows the response with Kp = 2.0 and Ti = 50. In this response, the overshoot is small and
the system settles down at the desired temperature quickly.
● 136
Figure 8.21: Nice response!
Notice that the acceptable PI parameters were found after a few trial and error rounds. The
Ziegler and Nichol tuning parameters gave us a starting point for tuning the system.
8.5 Project 4: PID Temperature Control

Description: This project is similar to Project 2 but here you add the derivative term to
your controller to make a PID controller. Notice that in many process control applications
only the PI algorithm is used and the benefit of adding a derivative term is very little. This
is especially true if the system has noise which can make the response unacceptable if
derivative term is used. The desired temperature is set to 50 ºC as in the previous project.
Block diagram and circuit diagram: The block diagram and circuit diagram of the pro-
ject are as shown in Figure 8.16 and Figure 8.17, respectively.
Proportional + Integral + Derivative (PID) controller parameters
In reference to Figure 8.15 and the Ziegler and Nichols PID table of settings, you find the
following P, I, and D controller parameters:
The parallel-PID realization shown in Figure 6.1 was used in this project.
Program listing: Figure 8.22 shows the program listing (Program: PIDtemp.py). As in
the previous program, at the beginning of the program the libraries used are imported
● 137
.
to the program, and the I2C LCD and the SPI bus get initialized. Then the thermistor pa-
rameters are defined and PWM output is assigned to GPIO12 where the MOSFET switch is
connected to.
The only change from Figure 8.18 is the controller algorithm. Here, function PI() is re-
placed with function PID() and the derivative term is added to the controller.
#----------------------------------------------------------
#
# PID TEMPERATURE CONTROLLER
# ==========================
#
# This is the PID temperature controller program
#
# File : PIDtemp.py
# Date : June, 2022
#----------------------------------------------------------
import matplotlib
import numpy as np
import time
import spidev
import math

Rs = 100000 # Rs
T0 = 298.15 # T0
GPIO.setup(MOSFET, GPIO.OUT)
pwm = GPIO.PWM(MOSFET, 100) # PWM port
global sk, Kp, T, Ti, pk, pk_1, ek_1, a, b, yk
● 138

#
def SetupPlot():
plt.title('Temperature') # Title
plt.xlabel('Time (seconds') # X label
plt.ion()
return
#
#
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
#
# This function calculates and returns the temperature in C
#
adc = Get_ADC_Data(0) # Get ADC value
Rt = Rs * (3300 - Vo) / Vo # Calculate Rt
R = R / B
T = R + 1 / T0
T = 1 / T # T in Kelvin
T = T - 273.15 # In Degrees C
return T
#
#
def Init():
global sk, a, b, Kp, T, Ti, pk, pk_1, ek_1
sk = 50 # SetTemp
Kp = 2.0
T = 1.0
Ti = 45.0
Td = 5.0
a = Kp*T/Ti
b = Kp*Td/T
pk = 0.0
pk_1 = 0.0
● 139
ek_1 = 0.0
lcd.home() # Home cursor
lcd.write_string("SetTemp:") # Heading
lcd.write_string(str(sk)) # SetTEmp
return
#
# This is the Proportional+Integral+Derivative algorithm function
#
def PID():
global yk, pk_1, ek_1
ek = sk - yk
pk = a*ek + pk_1
wk = Kp*ek
qk = b*(ek-ek_1)
uk = wk + pk + qk # PID output
uk = 100.0
uk = 0.0
pwm.ChangeDutyCycle(uk) # To PWM
ek_1 = ek # Update ek_1
return
Init() # Init LCD

i = 0
pwm.start(0)
yk = Calc_Temperature()
PID()
i = i + 1
x = i
plt.scatter(x, yk,color='red')
plt.show()
plt.pause(0.0001)
time.sleep(1)
pwm.stop()
Figure 8.22: Program: PIDtemp.py.
● 140
Figure 8.23 shows the closed-loop output time response of the system where the SetTemp
(desired temperature) was set to 50 ºC. Notice that even though the steady state error is
zero and the response settles down at 50 ºC, the response shows a large overshoot which
is not acceptable in many process control systems. Large overshoot is one of the results of
tuning a system using the Ziegler and Nichol algorithm.
Figure 8.23: Closed-loop system time response.
The integral time Ti was increased and the proportional constant reduced in order to de-
crease the overshoot and get a more acceptable result. At the same time, the derivative
term was increased to overcome any overshoot. Figure 8.24 shows the result when Kp =
2.0 and Ti = 45.0, Td = 3.
Figure 8.24: Improved response.
Finally, a disturbance response was plotted by removing the controller for a short while and
then reconnecting it. Figure 8.25 shows the disturbance recovery response of the system.
The steady-state response settled back at 50 ºC after the disturbance is removed.
● 141
Figure 8.25: Response to disturbance.
Notice that the acceptable PID parameters were found after a few trial and error rounds.
The Ziegler and Nichol tuning parameters gave us a starting point for tuning the system.
Figure 8.26 shows the project built on a breadboard.
Figure 8.26: Project built on a breadboard.
The sample time of the PID is based on using the Python built-in delay function time.
sleep(). The delay introduced by this function is not very accurate. As a result, the re-
al-time plots drawn in this Chapter are not very accurate. More accurate sample times and
more accurate real-time plots can be obtained if the PID algorithm is implemented inside a
timer iterrupt service routine.
8.6 Using the PID Loop Simulator

The PID Loop Simulator described in Chapter 5 can be used to verify the time response of
our closed loop system with the PID controller. The simulator can also be used to estimate
the initial values of the PID parameters. Various parameters can be tried on the simulator
● 142
until a good response is obtained. Next, these parameters can be used on the actual con-
troller.
The PID controller parameters you have chosen are:
Kp = 2.0 and Ti = 45.0, Td = 3.0
Therefore, the controller transfer function is:
Comparing with the simulator transfer function of:
you have: C = 2, I = 22.5, and D = 6. Entering the plant and the controller parameters into
the simulator gives the response as in Figure 8.27, which is very similar to the response
you obtained in Figure 8.24.
Figurse 8.27: Simulator response.
● 143
Chapter 9 • PID Temperature Control with the

Arduino Uno
9.1 Overview
In the previous Chapter you absorbed how to read the temperature of a thermistor, and
how to design a PID controller for a temperature control system using a Raspberry Pi. In
this Chapter, you will learn how to design PID based temperature control systems using an
Arduino Uno.
9.2 Project 1: Reading the Temperature of a Thermistor

Description: In this Chapter, you will be using the hotbed that you used in the previous
Chapter. This hotbed has a built-in NTC type 3950 thermistor temperature sensor. In this
section you will develop a project to read and display the temperature of this thermistor.
Circuit diagram: Although a resistive potential divider circuit is formed using the thermis-
tor as shown in Figure 8.3, a +5 V power supply is used. The circuit diagram of the project
is shown in Figure 9.1. Arduino Uno has built-in ADC meaning you do not need an external
ADC. The thermistor is connected to analogue input A0 of the Arduino Uno. As shown in the
previous Chapter, using a 100 kΩ series resistor, the resistance of the thermistor is given
by:
where is in millivolts
,
You can then use the Steinhart-Hart equation to find the temperature as described in the
previous Chapter:
Figure 9.1: Circuit diagram to measure temperature using a thermistor.
● 144
Chapter 9 • PID Temperature Control with the Arduino Uno
Program listing: Figure 9.2 shows the program listing (Program: thermistor2). At the
beginning of the program, the Thermistor is assigned to analog port A0. Next, the ther-
mistor parameters and series resistor value are defined. Inside the setup() function, the
Serial Monitor is configured at 9600 baud. The function Calc_Temperature() calculates
the thermistor temperature and returns it to the main program where the temperature is
displayed every second on the Serial Monitor, as shown in Figure 9.3.
//--------------------------------------------------------------------------
// READING THE TEMPERATURE OF A THERMISTOR
// =======================================
//
// This program reads and displays the temperature of a thermistor
//
// File : thermistor2
//---------------------------------------------------------------------------
int Thermistor = A0;
int B = 3950; // Thermistor B
float R0 = 100000.0; // Thermistor R0
float Rs = 100000.0; // Series resistor
float Vo, Rt, R, T, Temperature, T0 = 298.15;
unsigned int adc;
//
// Configure the Serial Monitor at 9600 BAud
//
void setup()
{
Serial.begin(9600);
}
//
// This function calculates and returns the temperature in C
//
float Calc_Temperature()
{
adc = analogRead(Thermistor); // Read voltage
Vo = adc * 5000.0 / 1024.0;
Rt = Rs * (5000.0 - Vo) / Vo; // Thermistor resistance
R = log(Rt / R0);
R = R / B;
T = R +1 / T0;
T = 1 / T;
T = T - 273.15; // Temperature in C
return T;
● 145
void loop()
{
Temperature = Calc_Temperature(); // Read temperature
Serial.println(T); // Display temperature
}
Figure 9.2: Program: thermistor2.
Figure 9.3: Displaying the temperature.
9.3 Project 2: PID Temperature Control

Description: This is the Arduino Uno program PID temperature controller which controls
the temperature of the 3D printer hot bed shown in Figure 8.1.
Block diagram: Figure 9.4 shows the block diagram of the project. The temperature of the
hotbed is measured with the built-in thermistor as described in Project 1. This temperature
value is fed back to the Arduino Uno where the PID algorithm is implemented to control the
temperature so that it is at the SetTemp. In this project, SetTemp is set to 50 ºC. The MOS-
FET switch is driven by the Raspberry Pi PWM (Pulse Width Modulated) output signal and
it provides the high current required by the hotbed by switching he external power supply.
● 146
Circuit diagram: Figure 9.5 shows the circuit diagram of the project. Notice that because
the output port voltages of the Arduino Uno are +5 V, there is no need to use logic level
convertor chip.
On Arduino Uno, the PWM pins are numbers 3, 5, 6, 9, 10, and 11. The frequency of the
PWM signal at pins 5 and 6 will be about 980 Hz and 490 Hz on the other pins. The PWM
pins are labeled with the tilde (~) sign.
Proportional + Integral (PI) controller parameters
A PID-type controller was designed, but initially the derivative term was set to 0 so that you
had a PI controller. The following PI controller parameters were chosen since the system is
similar to the one given in the previous Chapter, but the PWM range is different:
The parallel PI realization shown in Figure 6.1 was used in this project.
● 147
Program listing: In Arduino Uno the PWM duty cycle range is 0 to 255, where 0 corre-
sponds to 0% and 255 corresponds to 100% duty cycle. The statement analogWrite(pin,
duty cycle) sets the duty cycle on the specified pin.
Figure 9.6 shows the program listing (Program: PIDtemp2). Inside the setup() function,
the Serial Monitor was initialized to 19200 baud, the MOSFET switch is configured as an
output, and finally the PID parameters are defined. The function Calc_Temperature()
calculates and returns the thermistor temperature to the main program loop.
The function PID() is where the PID algorithm is implemented. Inside the main program
loop, the temperature is read and function PID() is called. The time response of the system
is plotted using the Tools  Serial Plotter of the Arduino IDE. It is important to make sure
that the loop time of the program does not exceed 1 second since the sample time is set to
one second. The time response is plotted in real time as it happens. If the required sample
time is very small as the plotting may affect the sample time. It is also possible to store the
response time values in an array and then plot them offline.
//--------------------------------------------------------------------------
// TEMPERATURE PID CONTROLLER
// ==========================
//
// This is teh Arduino Uno PID temperature controller. The desired temperature
// is set to 50 Degrees C
//
// File : PIDtemp2
//---------------------------------------------------------------------------
float Vo, Rt, R, T, Temperature, adcconv, T0 = 298.15;
float sk, Kp, Ti, Td, pk, pk_1, ek, ek_1, a, b, yk, qk, wk, uk;
unsigned int adc;
int MOSFET = 3;
//
// Configure PWM pin and Initialize variables
//
void setup()
{
Serial.begin(19200);
pinMode(MOSFET, OUTPUT);
sk = 50.0;
Kp = 6.5; // Proportional
● 148
T = 1.0; // Sample time

Ti = 70.0; // Integral
Td = 0.0; // Derivative
a = Kp*T/Ti;
b = Kp*Td/T;
pk = 0.0;
pk_1 = 0.0;
ek_1 = 0.0;
adcconv = 5000.0 / 1024.0;
}
//
//
{
Vo = adc * adcconv;
R = log(Rt / R0);
R = R / B;
T = R +1.0 / T0;
T = 1.0 / T;
return T;
}
//
// This is the PID function
//
void PID()
{
ek = sk - yk;
pk = a*ek + pk_1;
wk = Kp*ek;
qk = b*(ek - ek_1);
uk = wk + pk + qk;
if(uk > 255.0)
uk = 255;
if(uk < 0)
uk = 0;
analogWrite(MOSFET, uk);
pk_1 = pk;
ek_1 = ek;
}
● 149
void loop()
{
yk = Calc_Temperature();
PID();
Serial.println(yk);
}
Figure 9.6: Program: PIDtemp2.
Figure 9.7 shows the time response of the system with the PI controller, where the desired
SetTemp was set to 50 ºC. The response shows a small overshoot and settles down to
50 ºC.
Figure 9.7: Time response with PI controller in action.
Figure 9.8 shows the time response of the system with:
By adding the following derivative action, the response is shown in Figure 9.9:
● 150
Here again, you have some overshoot and the response settled at 50 ºC.
Figure 9.8: Time response with PI controller.
Figure 9.9: Time response with PID controller.
Notice that the sample time is set to 1 second, but this is not very accurate since the de-
lay() function is not accurate and the code executed before the delay() function is not
considered.
● 151
9.4 Project 3: PID Temperature Control with Arduino Uno and Timer
Interrupts
Description: The delay time of the Arduino is not very accurate and this affects the sample
time of the PID. For accurate sample timing you can use timer interrupts and execute the
PID algorithm inside the timer interrupt service routine.
In this project, you have modified the program and introduced 1 second timer interrupts
and moved the PID algorithm to within the interrupt service routine.
The block diagram and circuit diagram of the project are as before.
Program listing: Figure 9.10 shows the program listing (Program: PIDtemp3). Parts of
the program are similar to Figure 9.6, but here timer interrupts are enabled. In this pro-
ject, you want to generate timer interrupts every second. i.e., the frequency of
the interrupts is 1 Hz. Using a Prescaler value of 1024, the value of the compare
match register is calculated to be:
Compare match register = [16,000,000/ (1024 * 1)] – 1 = 15624
Timer 1 interrupts are enabled inside the setup() function with the following code:
TCCR1A = 0; // Set to 0
TCCR1B = 0; // Set to 0
TCNT1 = 0; // Set counter to 0
OCR1A = 15624; // Compare reg value
TCCR1B |= (1 << WGM12); // Turn on CTC mode
TCCR1B |= (1 << CS12) | (1 << CS10); // Set prescaler=1024
TIMSK1 |= (1 << OCIE1A); // Enable Timer compare interrupt
sei(); // Enable all interrupts
The timer interrupt service routine is identified by the name: ISR(TIMER1_COMPA_

vect). Figure 9.11 shows the time response of the system with timer interrupts used for
the PID algorithm.
//--------------------------------------------------------------------------
// TEMPERATURE PID CONTROLLER - USING TIMER INTERRUPTS
// ===================================================
//
// This is the Arduino Uno PID temperature controller. The desired temperature
// is set to 50 Degrees C. PID algorithm is implemented in timer interrupt
//
// File : PIDtemp3
//---------------------------------------------------------------------------
● 152

float sk, Kp, Ti, Td, pk, pk_1, ek, ek_1, a, b, yk, qk, wk, uk;
unsigned int adc;
int MOSFET = 3;
//
//
void setup()
{
sk = 50.0;
a = Kp*T/Ti;
b = Kp*Td/T;
pk = 0.0;
pk_1 = 0.0;
ek_1 = 0.0;
adcconv = 5000.0 / 1024.0;
//
// Timer1 configuration for 1s (1Hz) interrupts
//
TIMSK1 |= (1 << OCIE1A); // Enable Timer compare
interrupt
}
//
//
{
● 153

Vo = adc * adcconv;
R = log(Rt / R0);
R = R / B;
T = R +1.0 / T0;
T = 1.0 / T;
return T;
}
//
// This is the PID timer interrupt service routine
//
ISR(TIMER1_COMPA_vect)
{
yk = Calc_Temperature();
ek = sk - yk;
pk = a*ek + pk_1;
wk = Kp*ek;
qk = b*(ek - ek_1);
uk = wk + pk + qk;
if(uk > 255.0)
uk = 255;
if(uk < 0)
uk = 0;
pk_1 = pk;
ek_1 = ek;
Serial.println(yk);
}
void loop()
{
}
Figure 9.10: Program: PIDtemp3.
● 154
Figure 9.11: System response.
9.5 Project 4: PID Temperature Control using the Arduino Uno PID
Library
Description: There are several Arduino IDE based libraries that can be used to simplify
the design of PID controllers. In this section, you will be using the popular PID library by
Brett Beauregard ([email protected]), whose details are available at the following website:
https://playground.arduino.cc/Code/PIDLibrary/
The block diagram and the circuit diagram of the project are as in the previous project in
this Chapter.
The PID library

The PID library consists of several functions that can be called to simplify the design and
tuning of PID controllers. Some details of the available functions are given in this section.
PID(&Input, &Output, &Setpoint, Kp, Ki, Kd, Direction): This function creates a PID
controller in parallel form, linked to the specified Input, Output, and Setpoint. The param-
eters are:
Input (double): The input variable you are trying to control

Output (double): The variable that will be adjusted by the PID
Setpoint (double): The desired value
Kp, Ki, Kd (double): PID parameters
Direction: This is either DIRECT or REVERSE and it determines which direction the output
will move when faced with a given error (DIRECT is most commonly used).
● 155
Compute(): This function contains the PID algorithm. it should be called once every loop
(or sample). The function calculates a new Output. The function returns true when output
is computed, and false if a new value is not evaluated.
SetOutputLimits(min,max): This function is used to set the output limits of the PWM. By
default, in Arduino Uno, these limits are 0 to 255.
SetSampleTime(): This function sets the PID sample time in milliseconds. i.e., how often
the PID algorithm will evaluate. The default is 200 ms. The compute function returns to the
calling program if it is not time to evaluate a new output.
SetMode(): This function specifies whether the PID should be on (AUTOMATIC) or off
(MANUAL) The default is MANUAL (off) when created.
SetTunings(Kp,Ki,Kd): Initial PID parameters are usually specified when the PID is cre-
ated. This function can be called to change these parameters.
Additionally, the following display functions are provided. These functions return the PID
parameters for display purposes:
GetKp()
GetKi()
GetKd()
GetMode()
GetDirection()
Before using the PID library, you have to include the library in our IDE. The steps are as
follows:
• Download the latest version from the following website:

https://www.arduino.cc/reference/en/libraries/pid/
• At the time of authoring this book, the latest version was named as:
PID-1.2.0.zip.
• Start your IDE.
• Click Sketch  Include Library  Add .zip Library and browse to the
downloaded library and click Open.
• The library should now be available to use. The library .zip file contains example
files that can be useful during PID controller design.
You are now ready to develop a PID controller for our hotbed. The program details are given
below.
Program listing: Figure 9.12 shows the program listing (Program: PIDlibtemp). At the
beginning of the program, the header file PID_v1.h is included in the program, the ther-
mistor parameters and series resistance are defined, and the MOSFET is assigned to port
3. Then the PID parameters are defined as double variables. Inside the setup() function,
● 156
the desired temperature is set to 50 ºC, the sample time is set to 1000 ms (1 second), and
the Serial Monitor is set to 19200 Baud. The program loop calls function Calc_Tempera-
ture() to calculate the temperature, then the function Compute of the PID library is called
to evaluate the PID. The output is sent to the MOSFET switch as a PWM waveform.
It is important to notice that the PID equation used in the library is of the following format:
But you have been using the PID equation in the following form:
Therefore,
and
Using the previously proven successful PID parameters: , ,
You can use the following parameters for the library version of the PID:
and
//--------------------------------------------------------------------------
// TEMPERATURE PID CONTROLLER - USING PID LIBRARY
// ==============================================
//
// This is the Arduino Uno PID temperature controller. The desired temperature
// is set to 50 Degrees C. PID library is used in this program
//
// File : PIDlibtemp
//---------------------------------------------------------------------------
#include <PID_v1.h>
unsigned int adc;
int MOSFET = 3;
● 157
//
//Define Variables we will be connecting to
//
double Setpoint, Input, Output;
//
//Specify the PID tuning parameters
//
double Kp=2.0, Ki=0.022, Kd=0;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
//
//
void setup()
{
Setpoint = 50.0;
myPID.SetSampleTime(1000);
myPID.SetMode(AUTOMATIC);
adcconv = 5000.0 / 1024.0;
}
//
//
{
Vo = adc * adcconv;
R = log(Rt / R0);
R = R / B;
T = R +1.0 / T0;
T = 1.0 / T;
return T;
}
void loop()
{
Input = Calc_Temperature(); // Calculate temperature
boolean flag = myPID.Compute(); // Compute PID
● 158
analogWrite(MOSFET, Output); // Send to MOSFET switch

if(flag)Serial.println(Input); // Plot (Serial Plotter)
}
Figure 9.12: Program: PIDlibtemp.
Figure 9.13 shows the closed-loop time response of the system. The temperature settles
down to 50 ºC after a small overshoot. This plot can be obtained by selecting the Serial
Plotter from the Tools menu. In Figure 9.14, the term was reduced to 0.028 to reduce
the overshoot.
Figure 9.13: System response with little overshoot.
Figure 9.14: System response with reduced overshoot.
● 159
Chapter 10 • DC Motor Control with Arduino and

Raspberry Pi
10.1 Overview
In the previous Chapter you learned about controlling temperature using a PID controller
implemented on the Arduino Uno. This Chapter discusses the basic principles of DC motors
in relation to PID and worked out for both the Arduino and Raspberry Pi microcomputing
platforms.
10.2 Types of Electric Motors

An electric motor is an electrical machine that converts electrical energy into mechanical
energy in the form of linear or rotational movement (or torque). Electric motors operate
with the principles of magnetic fields where a force is generated between the motor's mag-
netic field and the current through its windings and this force causes linear or rotational
movement.
Electric motors are classified into two categories, as follows:
• AC motors
• DC motors
Within these categories, there are major subdivisions as illustrated by Figure10.1.
Figure 10.1: Electric motor types.
Alternating Current (AC) motors are not commonly used in robotics because most robots
are powered with batteries which are DC voltage. AC motors are generally used in industrial
automation applications where very large torques may be required, such as in conveyor
belts, cranes and so on.
This book only covers brushed DC motors. Their advantages include:
• Low-cost
• Can operate with low DC voltages
● 160
Chapter 10 • DC Motor Control with Arduino and Raspberry Pi
• Small size
• Easy to control their speeds
• Widely available in all sizes
• Good torque-speed characteristics
The disadvantages of the brushed DC motors are:
• The brushes wear out in and may need replacement

• Brushes generate electrical sparks which could fire or explosions in certain
environments
• Brushes generate RF noise that may interfere with nearby electronic equipment
such as TVs, radios, etc.
• Professional quality DC motors are expensive
10.3 Brushed DC Motors

Brushed DC motors normally have two terminals and when voltage is applied across these
terminals the motor rotates proportionally. Brushed DC motors (BDC) are widely used in
most electronic toys and in other low-cost motor applications. They are very low-cost, easy
to drive, and available in many sizes and shapes with and without gear mechanisms. Un-
like other motor types (e.g., brushless DC, and AC), brushed DC motors do not require a
controller to switch to switch the current in the motor windings. All BDC motors are made
up of:
• a stator;
• a rotor;
• brushes and a commutator.
The stator generates a stationary magnetic field that surrounds the rotor. This field is
generated by either permanent magnets placed around the rotor, or by electromagnetic
windings surrounding the rotor.
The rotor is also called the armature and it is made up of windings which produce magnetic
field when energized by applying a DC voltage. The magnetic poles of the rotor are attract-
ed to opposite magnetic poles of the stator, thus causing the rotor to turn.
The commutator is placed on the axle of a BDC motor and as the motor turns, carbon
brushes provide a supply voltage to the rotor windings through the commutator. The brush-
es come in contact with different segments of the commutator, thus providing the required
supply voltage to different windings of the rotor. Notice that commutator is part of the rotor
and as the rotor turns, so does the commutator.
10.3.1 Permanent-magnet BDC Motors

In a permanent-magnet BDC motor, the stator field is generated by permanent magnets
(see Figure 10.2). i.e., the stator is a pair of permanent magnets. These motors have the
advantages that they can be very small and there are no field circuit copper losses. On
the down side, the torque produced is low since the permanent magnets produce weak
● 161
flux densities compared to externally supported magnetic fields. There is also a risk of
demagnetization which can stop the motor from functioning. Figure 10.3 shows the circuit
diagram of a permanent-magnet BDC motor.
Figure 10.2: Permanent magnet BDC motor.
Figure 10.3: Circuit diagram of a permanent magnet BDC motor.
10.3.2 Series-wound BDC Motors

In a series-wound BDC motor, the field coil is in series with the armature, making the field
current equal to the armature current. The advantage of these motors is that they produce
high torque. These motors have the disadvantage that it is difficult to control their speed.
Also, the maximum speed is limited to around 5000 rpm. Figure 10.4 shows the circuit
diagram of a series-wound BDC motor.
Figure 10.4: Circuit diagram of series-wound BDC motor.
● 162
10.3.3 Shunt-wound BDC Motors

Shunt-wound BC motors have the field coil in parallel with the armature, causing the cur-
rent in the field coil and the armature to be independent of each other. The advantage of
these motors is that they have excellent speed control properties. The speed can easily be
changed by inserting a resistor in series with the armature or with the field coil. Figure 10.5
shows the circuit diagram of a shunt-wound BDC motor.
Figure 10.5: Circuit diagram of a shunt-wound BDC motor.
10.3.4 Compound-wound BDC Motors

These motors are a combination of shunt-wound and series-wound motors. Their advan-
tages are mainly higher torque than series wound motors and stable speed control. Figure
10.6 shows the circuit diagram of a compound-wound BDC motor.
Figure 10.6: Circuit diagram of a compound-wound BDC motor.
10.3.5 Separately-excited BDC Motors

In a separately-excited BDC motor, the field coils are supplied from an independent source,
making the field current independent of any changes in the armature current. These motors
produce high torque and have stable speed control properties. Figure 10.7 shows the circuit
diagram of a separately-excited BDC motor.
● 163
Figure 10.7: Circuit diagram of a separately-excited BDC motor.
10.3.6 Servo Motors

A servo motor allows for precise control of angular position of its rotor. It usually consists
of a DC motor coupled with a sensor for feedback so that the rotary position of the motor
can be controlled accurately. Servo motors run in closed-loop mode to warrant high per-
formance and accuracy. These motors are commonly used in radio controlled cars, boats,
helicopters, airplanes, etc.
Servo motors are normally operated with PWM type pulses (positive-going squarewave
shaped pulses) with a period of 50 Hz (20 ms period). In most types, a 1.5-ms pulse puts
the motor in a stationary position, a 1-ms pulse turns the motor 90 degrees to one direc-
tion, and a 2-ms pulse turns the motor 90 degrees in the opposite direction. Some types
of servo motors are modified such that they rotate continuously. Figure 10.8 shows a small
servo motor.
Figure 10.8: Small servo motor.
10.3.7 Stepper Motors

Stepper motors (Figure 10.9) rotate in discrete steps when electrical pulses are applied
across its terminals in the correct sequence. The sequence of the applied pulses determine
the direction of rotation, while the speed of the motor shaft rotation is directly related to
the frequency of the input pulses, while the length of rotation is related to the number of
applied pulses. Stepper motors are ideal for open-loop position control applications such
● 164
as in printers, plotters, PCB drilling machines, and any other applications requiring precise
control of the rotor position. Stepper motors suffer from relatively low torque.
Figure 10.9: A small stepper motor.
Basically, there are two types of stepper motors: unipolar and bipolar. The main difference
between these two types is the applied voltage levels. Unipolar stepper motors operate
with positive voltages only (e.g., 0 and +12 V). Bipolar motors, on the other hand, operate
with positive and negative voltages (e.g. –5 V and +5 V). As shown in the images, unipo-
lar motors require an additional wire in the middle of each coil. Bipolar motors have the
advantages that they produce larger torques (since the current flows in the entire coil and
generates stronger electromagnetic field) and require one less wire for operation.
10.4 Brushless DC Motors

In a brushless DC motor (BLDC), the rotor is a permanent magnet and the stator has wind-
ings. This is basically like a brushed DC motor turned inside-out. In a brushless DC motor,
you will not find brushes or a commutator and consequently these motors last longer and
require little or no maintenance. In addition, brushless motors do not generate electrical
sparks and are therefore cleaner, less noisy, and more dependable. On the downside,
these motors are more expensive. The sequence of voltages applied to the stator windings
replaces the function of the commutator and effectively turn the motor. The control of a
brushless DC motor is much different from the normal brushed-DC motor as it requires
sensors to detect the rotor's angular position before applying the voltage pulses. Speed
control of brushless DC motors is achieved using electronic Speed Control (ESC) modules.
10.5 Motor Selection

Choosing an electric motor for an application is an important task when designing a mo-
bile robot or any other electric car. Some of the important motor specifications to consider
during a choice are:
• Torque
• Speed
• Accuracy
• Operating voltage
• Cost
• Physical size and weight
● 165
10.6 Transfer Function of a Brushed DC Motor

The transfer function of a system is the ratio of its output to its input, represented using
the Laplace transform. It is important to know the transfer function of a system before any
form of feedback can be applied to it to achieve closed-loop control. In this section you are
introduced to deriving the transfer function of a permanent-magnet brushed DC motor (or
a separately-excited DC motor) which is one of the most commonly used motors in robotic
applications.
Figure 10.10 shows the circuit diagram of the motor where R (in ohms) and L (in henries)
are the resistance and inductance of the motor windings, V (in volts) is the applied DC volt-
age, J (in kg.m2/s2) is the inertial of the load attached to the motor, and Ve (in volts) is the
back emf generated by the motor.
Figure 10.10: Permanent-magnet DC motor.
The torque generated by the motor is proportional to the current through the motor wind-
ings and it can be written as:
T = KT I (10.1)
Where KT is the motor torque constant and i (in ampères) is the current
The back emf is proportional to the motor angular speed W (in rad/s) and is given by:
Ve = KE W (10.2)
Notice that W = dΘ/dt where Θ is the angle rotated by the motor (in radians). KE is the
motor back emf constant.
Using Kirchoff's law, you can write the following equation about the motor circuit:
V – Ve = Ri + L di/dt (10.3)
or,
V = Ri + Ldi / dt + KEW (10.4)
also,
T = J dW / dt (10.5)
● 166
From (10.1) and (10.2) you can write:
i = J / KT dW / dt (10.6)
using equations (10.6) and (10.4):
(10.7)
In small motors the inductance L is very small and can be neglected. Equation (10.7) then
becomes:
(10.8)
Equation (10.8) is a first order equation. Using the Laplace transforms where s is the Lap-
lace operator, you can rewrite it as:
(10.9)
or
(10.10)
When a step voltage VO is applied across the motor terminals the motor speed increases
exponentially until it settles down at a final value. The step response of the motor (i.e.,
the motor speed when a sudden step voltage is applied) can be derived by multiplying the
transfer function by 1/s and then taking the inverse Laplace transform. The result is given
below:
(10.11)
Initially the speed is 0, and it increases exponentially, having a final value of W(t) = VO /
KE. Figure 10.11 shows the typical step response of a brushed DC motor.
● 167
Figure 10.11: Step response of a DC motor.
Notice that the term T = R J / KT KE is the motor time constant of the motor and this is the
time it takes for the motor to reach 63% of its final value.
10.7 The DC Motor Used in the Projects

In the projects in this book, the type EMG30 brushed DC motor is used (Figure 10.12). This
is a geared DC motor with a built-in Hall sensor encoder having the following specifications:
• Operating voltage: 12 V
• Gearbox ratio: 30:1
• Rated torque: 1.5 kg/cm
• Rated speed 170 rpm
• Rated current: 530 mA
• No load speed: 216 rpm
• No load current: 150 mA
• Stall current: 2.5 A
• Encoder counts: 360 per revolution of the motor shaft
Figure 10.12: The type EMG30 DC motor.
A small mounting bracket is available from the manufacturers. For the purpose of the
projects in this book, the motor is mounted on a small wooden plate using the mounting
bracket. A plastic wheel is connected to its shaft so that the motor shaft can be observed
as is rotates (see Figure 10.13).
● 168
Figure 10.13: The motor mounted using the bracket.
The motor comes with a small 6-way JST connector having six colored wires with the fol-
lowing functions:
Wire color Connection

Purple (1) Hall sensor B Vout
Blue (2) Hall sensor A Vout
Green (3) Hall sensor ground
Brown (4) Hall sensor Vcc
Red (5) Motor supply (+)
Black (6) Motor supply (–)
The Hall Sensor Encoder

An encoder is an electromechanical device that provides an electrical signal for use in speed
and/or position control. Encoders turn the mechanical motion of a motor shaft into an elec-
trical signal for use by the control system to monitor specific parameters such as the speed
or position of the motor it is attached to.
The Hall sensor encoder used in this project operates between +3.5 V to +20 V, with its
outputs being open-collector hence requiring pull-ups to whatever signal level is required.
Encoder works by observing changes to the magnetic field created by a magnet attached
the motor shaft. As the motor rotates, the encoder outputs will trigger periodically.
An incremental encoder provides a specified amount of pulses in one rotation of the encod-
er. In a two-phase encoder, like the one used here, the output consists of two lines of puls-
es (an "A" and "B" channel) that are offset in order to determine rotation (Figure 10.14).
This phasing between the two signals is called quadrature. The speed of a motor can be
determined by counting the number of pulses generated by one phase of an encoder. The
direction of the motor is determined from the phase difference of the two encoder outputs
(Figure 10.15).
● 169
Figure 10.14: Operation of an encoder.
Figure 10.15: Two phases of an encoder.
10.8 Project 1: Motor Speed and Direction Control Using an H-Bridge

Integrated Circuit
This project shows how the speed and direction of a DC motor can be changed easily by
using an H bridge motor controller integrated circuit in conjunction with the Arduino Uno.
In this project, the motor is controlled as follows:
• Turn clockwise for 5 seconds at half full speed.

• Turn clockwise for 5 second at quarter full speed.
• Turn anticlockwise for 5 seconds at half full speed.
• Turn anticlockwise for 5 seconds at quarter full speed.
The above process is repeated indefinitely until stopped manually.
Block Diagram: The block diagram of the project is shown in Figure 10.16. In this project,
the type LMD18200 H bridge motor controller module is used. The module (Figure 10.17)
is a H bridge where the speed and the direction of rotation of a motor can be controlled.
The speed is controlled by sending PWM waves to the chip, and the direction of rotation is
controlled by setting or clearing a direction control bit.
The LMD18200 module has the following specifications:
● 170
• Up to 3 A continuous current
• Supply voltage up to 55 V
• TTL- and CMOS-compatible inputs
• Motor speed and direction control
• Thermal shutdown
• Motor stop (break) input
Figure 10.17: LMD18200 motor controller module.
The LMD18200 controller module has the following screw terminal configuration:
Left Screw Terminal (J2)

GND: Microcontroller power supply Ground
PWM: Speed control input (at logic levels)
DIR: Direction control input
BRAKE: Brake control input (logic 1 to brake)
Right Screw Terminal (J3)

V+: External motor power supply
GND: Power supply ground
OUT1: Motor connection
OUT2: Motor connection
● 171
Table 10.1 shows the operational logic table of the LMD18200 controller.
PWM DIR BRAKE Active output drivers
1 1 0 Rotate in one direction
1 0 0 Rotate in reverse direction
1 1 1 Break
1 0 1 Break
0 X 1 Break
Table 10.1: LMD18200 operational logic table.
Circuit Diagram for Arduino Uno

Figure 10.18 shows the circuit diagram of the project. The motor is connected to screw
terminals OUT1 and OUT2 and an external +12 V power supply is connected to the V+ in-
put. Port pins 0 and 3 are connected to the DIR and PWM inputs of the LMD18200 module.
Figure 10.19 shows the circuit built using jumpers to connect the Arduino Uno to the screw
terminals on the LMD18200 module.
Figure 10.18: Arduino Uno circuit diagram.
Figure 10.19: Arduino Uno connection to the LMD18200 module.
● 172
Circuit Diagram for Raspberry Pi

Figure 10.20 shows the circuit diagram for the Raspberry Pi version of the project. The
LMD18200 module is used here as well. Port pins GPIO2 and GPIO3 are connected to the
DIR and PWM inputs of the LMD18200 module. The motor is powered from an external
+12 V power supply. Figure 10.21 shows the circuit built using jumpers to connect the
Raspberry Pi to the screw terminals on the LMD18200 module.
Figure 10.20: Raspberry Pi circuit diagram.
Figure 10.21: Raspberry Pi connection to the LMD18200 module.
Program Listing for Arduino Uno

The Arduino Uno offers six PWM outputs which are connected to three timers on the pro-
cessor. These are:
Pin 5 and 6 - connected to Timer0

The frequency of the PWM depends upon the speed of the Timer/Counter which in turn
depends upon counter's clock divided by a pre-scaler value. The pre-scaler is 3 bits wide
and is stored in the three least significant bits (LSb) of the Timer/Counter registers CS02,
CS01, and CS00. The Timer/Counter registers are TCCR0B, TCCR1B, and TCCR2B. Notice
that the pairs of PWM pins have the same frequency. For example, PWM on pins 11 and 3
are controlled by Timer/Counter TCCR2B, pins 9 and 10 are controlled by TCCR1B, and pins
5 and 6 are controlled by TCCR0B.
● 173
The default values of the PWM frequencies at boot time are as follows:
Pins 5 and 6: 976.56 Hz

Pins 9 and 10: 490.20 Hz
Pins 11 and 3: 490.20 Hz
In order to change the PWM frequency, you must re-load the three least significant bits of
the required Timer/Counter registers. The values and corresponding PWM frequencies for
PWM pins 11 and 3 are given below (these statements must be included in the setup()
function of the program):
TCCR2B = TCCR2B & B11111000 | B00000001 frequency = 31372.55 Hz

TCCR2B = TCCR2B & B11111000 | B00000100 frequency = 490.20 Hz (DEFAULT)
For example, to set the PWM frequency to 980.39 Hz use the following statement inside
the setup() function:
TCCR2B = TCCR2B & B11111000 | B00000011
The program listing is shown in Figure 10.22 (program: Motor1). At the beginning of the
program, DIR and PWM are assigned to port pins 2 and 3 respectively. Inside the setup()
function the ports are configured as output. Function Rotate has two character arguments:
direction and speed. If the direction is c (clockwise) then the DIR pin of the LMD18200
module is set to LOW. If on the other hand the direction is a (anticlockwise) then the DIR
pin of the LMD18200 module is set HIGH. If the speed is f (fast) then PWM voltage with
50% (i.e., a value of 128) duty cycle is sent to the PWM pin. If on the other hand the speed
is s (slow) then the PWM duty cycle is set to 25% (i.e., a value of 64).
/*****************************************************************
* MOTOR SPEED AND DIRECTION CONTROL USING AN IC
* =============================================
*
* This is a simple motor speed and direction control project
* using the LMD18200 motor control module. Pins 3 and 2 of the
* Arduino Uno are connected to pins PWM and DIR of the LMD18200
* respectively. A +12V external power supply is used to power the
* motor.
*
* File : Motor1
* Date : July 2022
* Author: Dogan Ibrahim
● 174
*****************************************************************/
#define PWM 3 // PWM pin
#define DIR 2 // DIR pin
//
// Configure DIR as output
//
void setup()
{
pinMode(DIR, OUTPUT); // Direction is output
pinMode(PWM, OUTPUT); // PWM is output
}
//
// This function rotates the motor. Argument direction can be 'c'
// for clockwise or 'a' for anticlockwise. Argument speed can be
// 'f' for fast or 's' for slow
//
void Rotate(char direction, char speed)
{
if(direction == 'c')
digitalWrite(DIR, LOW); // Direction control
else
if(direction == 'a')digitalWrite(DIR, HIGH);
if(speed == 'f') // Speed control

analogWrite(PWM, 128); // HALF FULL speed
else
if(speed == 's')analogWrite(PWM, 64); // QUARTER FULL speed
}
//
// The motor is rotated as follows:
// 5 seconds clockwise and fast
// 5 seconds clockwise and slow
// 5 seconds anticlockwise and fast
// 5 seconds anticlockwise and slow
//
void loop()
{
Rotate('c', 'f'); // clockwise, fast
delay(5000);
Rotate('c', 's'); // clockwise, slow
delay(5000);
Rotate('a', 'f'); // anticlockwise, fast
delay(5000);
● 175
Rotate('a', 's'); // anticlockwise, slow

delay(5000);
}
Figure 10.22: Arduino Uno program listing.
Program Listing for Raspberry Pi

The program listing is shown in Figure 10.23 (program: Pimotor1.py). At the beginning of
the program, RPi.GPIO and time modules are imported to the program. DIR and PWM are
assigned to port pins 2 and 3, respectively and these pins are configured as outputs. The
function Rotate has two character arguments: direction and speed. If the direction is c
(clockwise) then the DIR pin of the LMD18200 module is set LOW. If on the other hand the
direction is a (anticlockwise) then the DIR pin of the LMD18200 module is set HIGH. If the
speed is f (fast) then a PWM voltage with 50% duty cycle (i.e., a value of 128) is sent to the
PWM pin. If on the other hand the speed is s (slow) then the PWM duty cycle is set to 25%
(i.e., a value of 64). Five seconds of delay are inserted between each output.
#-------------------------------------------------------------------
# MOTOR SPEED AND DIRECTION CONTROL
# =================================
#
# This is a simple motor speed and direction control project
# using the LMD18200 motor control module. Pins 2 and 3 of the
# Raspberry Pi are connected to pins DIR and PWM of the
# LMD18200 respectively. A +12V external power supply is used
# to power the motor.
#
# File : Pimotor1.py
# Date : July 2022
#----------------------------------------------------------------------
import time
DIR = 2 # DIR port
PWM = 3 # PWM port
GPIO.setup(DIR, GPIO.OUT) # DIR is output

GPIO.setup(PWM, GPIO.OUT) # PWM is output
#
# Generate PWM waveform at PWM pin with frequency of 1000 Hz
#
p = GPIO.PWM(PWM, 1000)
● 176
p.start(0) # Start PWM
#
# This function rotates the motor with the given direction and speed
#
def Rotate(direction, speed):
if direction == 'c':
GPIO.output(DIR, 0)
else:
if direction == 'a':
GPIO.output(DIR, 1)
if speed == 'f':
p.ChangeDutyCycle(50) # HALF FULL speed
else:
if speed == 's':
p.ChangeDutyCycle(25) # QUARTER FULL SPEED
return
while True:
Rotate('c', 'f')
time.sleep(5)
Rotate('c', 's')
time.sleep(5)
Rotate('a', 'f')
time.sleep(5)
Rotate('a', 's')
time.sleep(5)
Figure 10.23: Raspberry Pi program listing.
10.9 Project 2: Displaying the Motor Speed with Arduino Uno

Description: This project shows how the built-in encoder can be used to sense the speed of
the EMG30 DC motor. The speed is then displayed on the Serial Monitor of the Arduino IDE.
Block Diagram: The block diagram of the project is same as in Figure 10.16. The speed
of the motor is easily found by counting the number of pulses either from one or from both
encoders within a given time. For example, if only the rising edges of phase A are counted
every second, then the speed of the motor shaft after the gears can be calculated and ex-
pressed in RPM.
Circuit Diagram: Figure 10.24 shows the circuit diagram of the project. In this project, the
Hall sensor output B (purple wire) is connected to the MCU with a pull-up resistor enabling
the sensor pulses to be counted and the motor speed to be calculated. Additionally, the
LMD18200 module is connected to the MCU with the PWM and DIR pins connected to port
pins 3 and 4, respectively.
● 177
Encoder pulses are received using one of the external interrupt inputs of the Arduino Uno.
Program Listing: The Arduino Uno has two external interrupt pins at GPIO ports: 2 and
3. Pin 2 corresponds to interrupt number 0 and pin 3 corresponds to interrupt number
1. When the attachInterrupt(interrupt number,….,….) function is used to 'connect'
an interrupt to a function you have to specify the interrupt number as the first argument
of the function. Alternatively, you can use function attachInterrupt(digitalPinToInter-
rupt(pin number),……,…) and specify the GPIO pin number as the external interrupt pin.
Figure 10.25 shows the program listing of the project (program: Motor2). Phase B is as-
signed to pin number 2 and this pin is attached to interrupt service routine called Encod-
erISR. Variable interval is set to 1 second. Inside the EncoderISR the value of variable
Count is incremented by one.
Function millis() returns the number of milliseconds that elapsed since the program start-
ed running on the Arduino Uno. Inside the program loop, the elapsed milliseconds since the
last time is calculated and if this value is greater than or equal to the interval (1 second)
then it is assumed that a second has elapsed. At the end of one second, the speed of the
motor shaft after the gears is determined in RPM and then displayed on the Serial Monitor
of the Arduino IDE. Notice that the Arduino delay function is not used here to create one
second timing interval for the Count since it gives inaccurate results when this function
is interrupted by an external or a timer interrupt. Instead, the mills() function is used to
create a one second timing interval. Figure 10.26 shows the speed displayed in RPM on the
Serial Monitor.
/*****************************************************************
* MOTOR SPEED SENSE USING ENCODER
* ===============================
*
* In this project the speed of the motor is measured using the Hall
* Effect sensor with a magnetic disc attached to the shaft of the
* motor.
*
* The speed (RPM) of the motor is found by counting the number
● 178
* of encoder pulses in a given time period (e.g. in a second).

*
* The encoder ouput is connected to pin 2 of the Arduino
* Uno and the pulses generate external interrupts which are
* counted inside the interrupt service routine EncoderISR.
*
* File : Motor2
* Date : July 2022
*****************************************************************/
#define PhaseB 2 // Phase A
volatile unsigned long Count = 0; // Encoder count

unsigned long Pulses; // Encoder pulses
float RPM; // Motor speed
unsigned long previousMillis = 0;
const long interval = 1000; // milliseconds
//
// This is the interrupt service routine which is called everytime
// a pulse is generated from the encoder output rising (going from
// LOW to HIGH)
//
void EncoderISR()
{
Count++;
}
//
// Configure Encoder Phase A as input. Also, attach the Encoder A
// output to external interrupt 0 (GPIO pin 2). The interrupt
// service routine is named EncoderISR and is when an interrupt
// occurs (an encoder pulse is generated). External interrupts
// are generated on the rising edge (LOW to HIGH) of the encoder
//
void setup()
{
Serial.begin(9600);
pinMode(PhaseB, INPUT); // Phase A is input
attachInterrupt(digitalPinToInterrupt(2), EncoderISR, RISING);
Rotate();
}
● 179
//
// Wait until a second has elapsed and then calculate the speed
// of the motor in RPM and display the speed on the Serial Monitor.
// The interval is set to 1000ms (1 second). When
// CurrentMillis-previousMillis = interval
// then it is assumed that a second has elapsed
//
//
// This function rotates the motor so that we can measure its speed
//
void Rotate()
{
digitalWrite(DIR, LOW);
analogWrite(PWM, 20); // Roate the motor
}
void loop()
{
unsigned long CurrentMillis = millis();
if(CurrentMillis - previousMillis >= interval)
{
Pulses = Count; // Copy of Count
previousMillis = CurrentMillis;
Count = 0; // Clear Count
RPM = Pulses * 60.0 / 90.0; // Calculate RPM
Serial.println(RPM); // Display motor speed
}
}
Figure 10.25: Program listing of the project.
● 180
Figure 10.26: Motor speed displayed on the Serial Monitor.
10.10 Project 3: Displaying Motor Speed on LCD with Arduino Uno

This project is similar to the previous project, but here the motor speed is displayed on an
LCD in RPM. An I2C type LCD is used in this project.
Block Diagram: Figure 10.27 shows the block diagram of the project.
Circuit diagram: The circuit diagram is shown in Figure 10.28. The I2C LCD is connected
to pins SDA (A4) and SCL (A5) of the Arduino Uno.
● 181
Program listing: Figure 10.29 shows the program listing (Program: Motor3). The pro-
gram is very similar to Figure 10.25 but here the motor speed is displayed on LCD every
second.
/*****************************************************************
* DISPLAY MOTOR SPEED ON LCD
* ==========================
*
* In this project the speed of the motor EMG30 is measured using
* the built-in encoder attached to the shaft of the motor and the
* speed is displayed on LCD in RPM
*
* File : Motor3
* Date : July 2022
*****************************************************************/
#include <Wire.h>
#define PhaseB 2 // Phase A


unsigned long Pulses; // Encoder pulses
float RPM; // Motor speed
unsigned long previousMillis = 0;
const long interval = 1000; // milliseconds
//
// a pulse is generated from the encoder output rising (going from
// LOW to HIGH)
//
void EncoderISR()
{
Count++;
}
//
// Configure Encoder Phase A as input. Also, attach the Encoder A
// output to external interrupt 0 (GPIO pin 2). The interrupt
// service routine is named EncoderISR and is when an interrupt
// occurs (an encoder pulse is generated). External interrupts
// are generated on the rising edge (LOW to HIGH) of the encoder
//
● 182
void setup()
{
pinMode(PhaseB, INPUT); // Phase A is input
attachInterrupt(digitalPinToInterrupt(2), EncoderISR, RISING);
Rotate();
}
//
// Wait until a second has elapsed and then calculate the speed
// of the motor in RPM and display the speed on the Serial Monitor.
// The interval is set to 1000ms (1 second). When
// CurrentMillis-previousMillis = interval
// then it is assumed that a second has elapsed
//
//
// This function rotates the motor so that we can measure its speed
//
void Rotate()
{
analogWrite(PWM, 20); // Rotate the motor
}
void loop()
{
unsigned long CurrentMillis = millis();
if(CurrentMillis - previousMillis >= interval)
{
Pulses = Count; // Copy of Count
previousMillis = CurrentMillis;
Count = 0; // Clear Count
RPM = Pulses * 60.0 / 90.0; // Calculate RPM
lcd.setCursor(0,0); // Cursor at 0,0
lcd.print(RPM); // Display RPM
}
}
Figure 10.29: Program: Motor3.
● 183
10.11 Project 4: Displaying Motor Speed with Raspberry Pi

Description: This project shows how the built-in encoder can be used to sense the speed
of the EMG30 DC motor. The speed is then displayed by Raspberry Pi on the screen.
Block Diagram: The block diagram of the project is same as in Figure 10.16. The speed
of the motor is easily found by counting the number of pulses either from one or from both
encoders in a given time. For example, if only the rising edges of phase A are counted every
second, then the speed of the motor shaft after the gears can be calculated and expressed
in RPM.
Circuit Diagram: Figure 10.30 shows the circuit diagram of the project. In this project, the
Hall sensor output B (purple wire) is connected to the MCU with a pull-up resistor, enabling
the sensor pulses can be counted and the motor speed to be calculated. Additionally, the
LMD18200 module is connected to the MCU with the PWM and DIR pins connected to port
pins 3 and 2, respectively. The encoder output is connected to GPIO21 (pin 40) through a
pull-up resistor.
Encoder pulses are received using external interrupts on the Raspberry Pi.
Program Listing: Figure 10.31 shows the program listing (Program: Pimotor2). The
function Rotate() rotates the motor at fixed speed. External interrupts are enabled on pin
GPIO21 on the rising edge of PhaseB. When an interrupt is detected, the program jumps
to the interrupt service routine (ISR) named EncoderISR. Variable Count is incremented
by 1 inside the ISR. The value of Count is then converted into RPM and stored in variable
RPM, which is then displayed on the screen every second.
#-------------------------------------------------------------------
# DISPLAY MOTOR SPEED
# ===================
#
# This program displays the motor speed on the screen
#
● 184
# Date : July 2022

#----------------------------------------------------------------------
import time
DIR = 2 # DIR at port 2
PWM = 3 # PWM at port 3
PhaseB = 21 # Phase B at port 40
global Count
Count = 0

GPIO.setup(PhaseB, GPIO.IN) # Phase B is input
#
#
#
# This function rotates the motor
#
def Rotate():
GPIO.output(DIR, 0)
return
def EncoderISR(PhaeB):
global Count
Count = Count + 1
return
Rotate()
GPIO.add_event_detect(PhaseB, GPIO.RISING, callback = EncoderISR)
try:
while True:
pass
● 185
RPM = Count * 60.0 / 90.0

print(str(RPM)[:5])
Count = 0
except KeyboardInterrupt:
p.ChangeDutyCycle(0)
p.stop()
Figure 10.31: Program: Pimotor2.
10.12 Project 5: Displaying Motor Speed on LCD with Raspberry Pi

Description: This project is similar to project 4, but here the motor speed is displayed on
LCD.
Block Diagram: The block diagram of the project is shown in Figure 10.32.
Circuit Diagram: Figure 10.33 shows the circuit diagram of the project. Notice that the
TXS0102 logic level converter chip is used to convert the +3.3 V output of the Raspberry
Pi to +5 V to drive the LCD.
● 186
Program listing: Figure 10.34 shows the program listing (Program: Pimotor3). This pro-
gram is similar to Figure 10.31 but here the motor speed is displayed on the LCD.
#-------------------------------------------------------------------
# DISPLAY MOTOR SPEED ON LCD
# ==========================
#
# This program displays the EMG30 motor speed on I2C LCD
#
# Date : July 2022
#----------------------------------------------------------------------
import time
lcd = CharLCD('PCF8574', 0x27)
global Count
Count = 0

#
#
#
# This function rotates the motor
#
def Rotate():
GPIO.output(DIR, 0)
return
● 187
# Interrupt service routine

#
global Count
Count = Count + 1
return
Rotate()
try:
while True:
pass
RPM = Count * 60.0 / 90.0

lcd.clear()
lcd.write_string(str(RPM)[:5])
Count = 0
p.stop()
Figure 10.34: Program: Pimotor3.
10.13 Project 6: Identification of the DC Motor with Raspberry Pi

Description: In this project you plot the step time response of our DC motor with the en-
coder and then find its transfer function.
The block diagram and circuit diagram of the project are as in Figures 10.16 and 10.30,
respectively.
A PWM waveform with a duty cycle of 50% is applied to the motor through the LMD18200
module and the open-loop time response gets plotted by your Raspberry Pi.
Program listing: Figure 10.35 shows the program listing (Program: PiStep.py). Because
the motor time response is fast, the time axis was set to be in units of 100 ms. The motor
response is plotted in real-time by the program.
● 188
#-------------------------------------------------------------------
# MOTOR OPEN-LOOP STEP RESPONSE
# =============================
#
# This program applies a step of 50% PWM waveform to the motor.
# the open-loop time response is plotted by the program
#
# File : PiStep.py
# Date : July 2022
#----------------------------------------------------------------------
import matplotlib
import numpy as np

import time
global Count
Count = 0

GPIO.output(DIR, 0)
#
#
def SetupPlot():
plt.axis([0, 20, 0, 150])
plt.title('Speed')
plt.xlabel('Time')
plt.ylabel('Speed')
plt.ion()
return
● 189
global Count
Count = Count + 1
return
SetupPlot()
conv = 600.0 / 90.0

i=0
#
# Send step input to the motor with 50% PWM
#
try:
while True:
EndTime = time.time() + 0.1
pass
RPM = Count * conv

plt.scatter(i, RPM, color='Red')
i=i+1
plt.pause(0.00001)
Count=0
p.stop()
Figure 10.35 Program: PiStep.py.
The open-loop time response of the motor is shown in Figure 10.36. The motor speed
settles at 100 rpm at a 50% PWM input. The time constant of the motor can be calculated
when the output reaches 63% of its final value, and this is found to be 30 ms (0.03 s). The
transfer function can be derived to be:
or
● 190
Figure 10.36: Open-loop system response.
10.14 Project 7: PID Motor Speed control with Raspberry Pi

Description: In this project you will use a PID algorithm to control the motor speed. The
circuit diagram of the project is as in Figure 10.30.
Program listing: Figure 10.37 shows the motor PID control system (Program: PIDmotor.
py). At the beginning of the program the modules used are imported to the program, DIR,
PWM, and PhaseB pins are configured and variable Count is declared as a global variable.
Function SetupPlot() defines the axes and their titles. Function Init() initializes the PID
algorithm. The algorithm is implemented in the function PID(). The step response of the
closed-loop system with the PID is implemented in the main program loop. The sample
time is set to 0.2 seconds.
#----------------------------------------------------------
#
# PID MOTOR CONTROLLER
# ====================
#
# This is the PID motor controller program
#
# File : PIDmotor.py
# Date : June, 2022
#----------------------------------------------------------
import matplotlib
import numpy as np
import time
import spidev
import math
● 191
DIR = 2
PWM = 3
PhaseB = 21
GPIO.setup(PWM, GPIO.OUT)
GPIO.setup(DIR, GPIO.OUT)
GPIO.setup(PhaseB, GPIO.IN)
GPIO.output(DIR, 0)
p.start(0)
global Count
Count = 0
global sk, Kp, T, Ti, pk, pk_1, ek_1, a, b, yk
#
#
def SetupPlot():
plt.title('Speed Response') # Title
plt.xlabel('Time (x 0.2s)') # X label
plt.ylabel('Speed') # Y label
plt.ion()
return
def EncoderISR(PhaseB):
global Count
Count = Count + 1
return
#
#
def Init():
global sk, a, b, Kp, Ti, pk, pk_1, ek_1
sk = 100 # SetTemp
Kp = 0.03
T = 0.2
Ti = 0.05
Td = 0
a = Kp*T/Ti
b = Kp*Td/T
pk = 0.0
pk_1 = 0.0
● 192
ek_1 = 0.0
return
#
#
def PID():
ek = sk - yk
pk = a*ek + pk_1
wk = Kp*ek
qk = b*(ek-ek_1)
uk = 100.0
uk = 0.0
p.ChangeDutyCycle(uk) # To PWM
return
Init() # Init LCD

conv = 300.0 / 90.0
i = 0
try:
yk = Count * conv
PID()
i = i + 1
plt.pause(0.00001)
Count = 0
pass
p.stop()
Figure 10.37: Program: PIDmotor.py.
● 193
Tuning the PID parameters

The simulation program (Section 5.12) was used to tune the PID parameters. The system
transfer function was entered and optimum parameters were found by trial and error. Fig-
ure 10.38 shows the simulation results.
Figure 10.38: Simulation results.
The following PID parameters were found to be successful:
C = 0.03, I = 3, D = 0
From these values, you calculate that, Kp = 0.03, Ti = 0.09. It was found that Kp = 0.03
and Ti = 0.05 gave good results in practice. Including derivative term did not improve the
response. Figure 10.39 shows the system response plotted in real-time with the program.
in this program the desired speed was set to 100 rpm. It is clear that the response settles
down to the desired value with no steady-state errors.
Figure 10.39: Closed-loop system response.
● 194
Notice that the encoder has two outputs, PhaseA and PhaseB. In this program, you have
used only one output. It is possible to use both outputs to improve the accuracy of the
speed of the motor. With both outputs the pulses received from the encoder will double
(see next project).
10.15 Project 8: PID Motor Speed Control with Arduino Uno

Description: In this project, you will use a PID algorithm to control the motor speed.
Circuit diagram: The circuit diagram of the project is shown in Figure 10.40. Notice that
both outputs of the encoder are used in this project.
Program listing: Figure 10.41 shows the motor PID controller program (Program: PID-
motor3). A timer interrupt scheme is used to set the PID sample time to 0.2 seconds. The
compare-register value for 0.2 seconds (i.e., 5 Hz) is given by:
OCR1A = 16,000,000 / (prescaler*f) – 1 = 16,000 000 / (1024 × 5) – 1
which gives OCR1A = 3124. The PID algorithm is implemented by timer interrupts (func-
tion: ISR(TIMER1_COMPA_vect)), which equals every 0.2 seconds.
The motor speed is found by counting the encoder pulses. When using only one phase of
the encoder and counting pulses for one second, the speed in RPM is given by: Count ×
60.0 / 90.0. In this project you are counting the pulses for 0.2 seconds and therefore the
motor speed when only one phase is used is given by: Count × 300.0 / 90.0. When both
phases are used, you get double the count and therefore the motor speed is given by:
Count × 150.0 / 90.0.
Encoder outputs PhaseA and PhaseB are connected to pins 2 and 3 of Arduino Uno through
pull-up resistors. External interrupts are configured for both pins using the attachInter-
rupt() function, and the encoder pulses are counted (pins 2 and 3 are external interrupt
pins of the Arduino Uno) and stored in variable Count every sample time.
● 195
//--------------------------------------------------------------------------
// MOTOR PID CONTROLLER - USING TIMER INTERRUPTS
// =============================================
//
// This is the Arduino Uno PID motor controller. The desired motor speed
// is set to 100 RPM. PID algorithm is implemented in timer interrupt
//
// File : PIDmotor3
// Date : July, 2022
//---------------------------------------------------------------------------
#define PhaseA 2 // Phase A
#define PhaseB 3 // Phase B
float sk, Kp, Ti, Td, pk, T, pk_1, ek, ek_1, a, b, yk, qk, wk, uk;
float conv = 150.0 / 90.0;
//
//
void setup()
{
TCCR2B = TCCR2B & B11111000 | B00000011;
pinMode(PhaseB, INPUT); // Phase B is input
pinMode(PhaseA, INPUT); // Phase A is input
attachInterrupt(digitalPinToInterrupt(PhaseB), EncoderISR, RISING);
attachInterrupt(digitalPinToInterrupt(PhaseA), EncoderISR2, RISING);
sk = 100.0; // Desired speed
a = Kp*T/Ti;
b = Kp*Td/T;
pk = 0.0;
pk_1 = 0.0;
ek_1 = 0.0;
//
// Timer1 configuration for 0.2s (5Hz) interrupts
● 196
//
TIMSK1 |= (1 << OCIE1A); // Enable Timer compare interrupt
}
//
// a pulse is generated from the encoder PhaseB output rising (going from
// LOW to HIGH)
//
void EncoderISR()
{
Count++;
}
//
// a pulse is generated from the encoder PhaseA output rising (going from
// LOW to HIGH)
//
void EncoderISR2()
{
Count++;
}
//
// This is the PID timer interrupt service routine
//
ISR(TIMER1_COMPA_vect)
{
yk = Count * conv;
Count = 0;
ek = sk - yk;
pk = a*ek + pk_1;
wk = Kp*ek;
qk = b*(ek - ek_1);
uk = wk + pk + qk;
if(uk > 255.0)
uk = 255;
if(uk < 0)
● 197
uk = 0;
analogWrite(PWM, uk);
pk_1 = pk;
ek_1 = ek;
Serial.println(yk);
}
void loop()
{
}
Figure 10.41: Program: PIDmotor3.
The following PID parameters were found by trial and error to be satisfactory:
Kp = 0.5, Ti = 3.5, Td = 0.02
The time response shown in Figure 10.42 was plotted using the Serial Plotter of Arduino
IDE. The desired speed was set to 100 RPM. The system settles to the desired speed with
no errors.
Figure 10.42: Time response of the system.
● 198
Chapter 11 • Water Level Control
11.1 Overview
In Chapter 2 you saw various types of liquid level sensors. In this Chapter you will be using
an ultrasonic ((U/S) transmitter-receiver pair to control the level of water in a vessel or
another type of liquid container.
11.2 Ultrasonic Transmitter-Receiver Module

Ultrasonic transmitter-receiver modules are often used to measure distance from the mod-
ule to an object (or obstacle) in front of the module. These modules are used in mobile
robot and vehicle movement control applications to avoid hitting an obstacle around the
vehicle or the robot.
Figure 11.1 shows the commonly used ultrasonic transmitter-receiver module known as
the HC-SR04.
Figure 11.1: The type HC-SR04 ultrasonic transmitter/receiver module.
11.3 Project 1: Measuring Distance using the HC-SR04 Ultrasonic

Module with Arduino Uno
Description: In this project, you will use an ultrasonic transmitter-receiver module to
measure and display the distance to an object in front of the sensor.
Block diagram: Figure 11.2 shows the block diagram of the project. The distance to the
obstacle will be displayed on the screen via the Serial Monitor of the Arduino IDE.
● 199
The HC-SR04 Ultrasonic TX/RX

In the projects in this Chapter, the popular HC-SR04 ultrasonic transmitter-receiver module
is used. The basic features of this sensor module are:
• Operating voltage: 5V
• Operating current: 2 mA
• Detection distance: 2 – 450 cm
• Input trigger signal: 10 µs TTL level
• Sensor angle: under 15 degrees
HC-SR04 has the following pin names and descriptions:
Vcc: Power input

Trig: Trigger input
Echo: Echo output
Gnd: Power ground
• The basic principle of operation of the HC-SR04 ultrasonic sensor module is as

follows (see Figure 11.3):
• A 10-µs trigger pulse is sent to the module.
• The module then sends eight 40-kHz squarewave signals to the target and sets
the echo pin HIGH.
• The program starts a timer.
• The signal hits the target and echoes back to the module.
• When the signal is returned to the module, the Echo pin goes LOW.
• The timer is stopped.
• The duration of the echo signal is calculated and this is proportional to the
distance to the target.
The distance to the object is calculated as follows:
Distance to object (in meters) = (duration of echo time in seconds × speed of

sound) / 2
The speed of sound is 343 m/s, or 0.0343 cm / µs at 20 ºC air temperature.
Therefore,
Distance to object (in cm) = (duration of echo time in µs) × 0.0343 / 2
or
Distance to object (in cm) = (duration of echo time in µs) × 0.0171
For example, if the duration of the echo signal is 294 microseconds then the distance to the
object is calculated as follows:
● 200
Distance to object (cm) = 294 × 0.0171 = 5.03 cm
Figure 11.3: Operation of the ultrasonic sensor module.
lthough it is very easy to write a program to measure the distance using the HC-SR04, a
library is available for the Arduino Uno for you to use.
Circuit diagram: Figure 11.4 shows the circuit diagram of the project. The interface be-
tween the Arduino Uno and the ultrasonic TX/RX module are as follows:
HC-SR04 Arduino Uno

Ech 12
Trig 13
Vcc +5 V
Gnd GND
Before writing the program, you have to install the HC-SR04 library to our Arduino IDE.
The steps are:
• Download the library from the following web site. At the time of writing, this
book the library file was called Ultrasonic-3.0.0.zip
https://www.arduino.cc/reference/en/libraries/ultrasonic/
● 201
• Start your Arduino IDE and click Sketch  Include Library  Add .zip
Library.
• Browse to the library file and click Open.
Program listing: Figure 11.5 shows the program listing (Program: Unodistance). The
ultrasonic library is included at the beginning of the program. The Serial Monitor is initial-
ized to 9600 Baud in the setup() function. The main program loop reads and displays the
distance to an object in-front of the sensor module.
//--------------------------------------------------------------------------
// HC-SR04 ULTRASONIC DISTANCE MEASUREMENT
// =======================================
//
// This program uses the HC-SR04 ultrasonic module to measure distance
//
// File : Unodistance
//---------------------------------------------------------------------------
#include <Ultrasonic.h>
Ultrasonic ultrasonic(13, 12); // trig=13, echo=12
int Distance;
void setup()
{
Serial.begin(9600); // Serial Monitor
}
void loop()
{
Distance = ultrasonic.read(); // Get distance
Serial.print("Distance (cm): "); // Heading
Serial.println(Distance); // Display distance
delay(500); // 500ms delay
}
Figure 11.5: Program: Unodistance.
Figure 11.6 shows an example output displayed on the Serial Monitor.
● 202
Figure 11.6: Example output.
11.4 Project 2: Measuring Distance using the HC-SR04 Ultrasonic

Module with Raspberry Pi
Description: This project is similar to Project 1 but in this version the Raspberry Pi is used.
Circuit diagram: The circuit diagram of the project is shown in Figure 11.8. Note that
the Echo pin output of the sensor is at +5 V which is not compatible with the Raspberry Pi
inputs. A resistive potential divider circuit can be used to lower this voltage to +3.3 V. Also,
the Trig input of the HC-SR04 module is pulled up to +5 V internally and this may damage
the Raspberry Pi output circuitry. A logic level converter module (Figure 11.9) is used to
connect the Trig and Echo pins to the Raspberry Pi without damaging its ports.
● 203
Figure 11.9: Logic level converter module.
Although the program is simple, a HC-R04 library (called Bluetin_Echo library) is used
in this project to read the distance from the sensor to an obstacle. The steps to install
this library on your Raspberry Pi are as follows (for more information, see the website:
https://www.bluetin.io/sensors/python-library-ultrasonic-hc-sr04/ ):
• Enter the following command at your Raspberry Pi command mode:
pip install Bluetin_Echo
• If you have the Bluetin_Echo library on the Raspberry Pi already, try upgrading
with the following command.
pip install --upgrade Bluetin_Echo
The library must be imported to your program as follows:
from Bluetin_Echo import Echo
The trigger and echo pins and optionally the speed of sound must be specified and then
configured as follows. If the speed of sound is not specified, the default is 340 m/s:
● 204
echo = Echo(TRIGGER_PIN, ECHO_PIN, speed_of_sound)
The distance is returned in mm, cm, or in inches. It is possible to do more than one meas-
urement and return the average by specifying a samples value. For example, to do 3 meas-
urements and return the average distance in cm enter:
samples = 3
result = echo.read('cm', samples)
It is important to set enough delay between sensor echo reads for returning consistent val-
ues. The default for this property is 0.06 second (60 milliseconds) and can be changed with
the rest command. For example, to change the delay to 0.08 seconds (80 milliseconds),
use the following command:
echo.rest = 0.08
Program listing: Figure 11.10 shows the program listing (Program: RPdistance). At the
beginning of the program, Bluetin_Echo library is imported and the Trig and Echo pins are
defined. Then the speed of sound is defined as 340 m/s and number of samples to take is
set to 2. The program receives the distance in cm and displays the value on the screen. A
sample output is shown in Figure 11.11.
#-----------------------------------------------------------
# ULTRASONIC DISTANCE MESUREMENT
# ==============================
#
# This program measures the distance to an obstacle in-front
# of the ultrasonic sensor and displays the distance in cm
# 2 samples are taken and averaged in this program
#
# File : RPdistance.py
# Date : July 2022
#------------------------------------------------------------
import time
trigpin = 21 # Trigger pin

echopin = 20 # Echo pin
speed_of_sound = 340
samples = 2
echo = Echo(trigpin, echopin, speed_of_sound)
● 205
while True: # Do forever

distance = echo.read('cm', samples) # GEt distance
print(str(distance)[:5]) # Display distance
time.sleep(0.1) # 100ms delay
Figure 11.10: Program: RPdistance.
Figure 11.11: Sample output from the program.
11.5 Project 3: Step Input Response of the System with Raspberry Pi

Description: In this project, you derive the open-loop step response of the system. A step
input is applied to the pump and the water level is plotted in real time.
Block diagram: Figure 11.12 shows the block diagram of the project. A water pump (Fig-
ure 11.13) is used in the project. This is model DIFCUL submersible pump operating at 12 V
and requiring about 1.3 A on full power. The ultrasonic TX/RX sensor module measures the
distance to the surface of the water and from this data you can calculate the level of water
inside the tank. The MOSFET switch used in this project is same as the one used in temper-
ature control projects in Chapters 8 and 9. An external 12-V, 3-A power supply is used to
power the water pump. The length of the tank (D) was 24 cm.
● 206
Figure 11.13: Water pump used in the project.
Circuit diagram: The circuit diagram of the project is shown in Figure 11.14. The Trig and
Echo pins of the ultrasonic sensor are connected to the Raspberry Pi through a logic level
converter module as in the previous project.
Program listing: Figure 11.15 shows the program listing (Program: PiStepWater,py).
The Bluetin_Echo library and other libraries used for plotting real-time graphs are import-
ed to the program. A PWM step input with duty cycle of 60% is applied to the pump and
● 207
the level of the water in the tank is plotted in real-time. D is the length of the tank, d is the
distance from the ultrasonic sensor to the surface of the water, and L is the level of water
in the tank which is given by: L = D - d
#-------------------------------------------------------------------
# WATER LEVEL CONTROL OPEN-LOOP STEP RESPONSE
# ===========================================
#
# This program applies a step input to the pump. Then open-loop
# time response is plotted by the program
#
# File : PiStepWater.py
# Date : July 2022
#----------------------------------------------------------------------
import matplotlib
import numpy as np
import time
trigpin = 21 # trig pin

echopin = 20 # echo pin
PWM = 26 # PWM pin
D = 24 # Length of tank
GPIO.setup(PWM, GPIO.OUT)
#
#
#
# Plot the graph axes and labels
#
def SetupPlot():
plt.axis([0, 100, 0, 10])
● 208
plt.title('Water Level')
plt.xlabel('Time')
plt.ylabel('Level (cm)')
plt.ion()
return
SetupPlot()
i = 0
#
# Send step input to the motor with 10% PWM. Sample every second
#
try:
while True:
pass
d = echo.read('cm', 1) # Dist to surface

L = D - d # Water level
plt.scatter(i, L, color='Red') # Plot water level
i = i + 1
plt.pause(0.00001)
p.stop()
Figure 11.15: Program: PiStepWater.py.
The step response of the open-loop system is shown in Figure 11.16. After 3 seconds of de-
lay, the water level increases and settles down at 7.9 cm. The time constant of the system
is the point where the response rises to 63.2% of its final value. In Figure 11.16 this corre-
sponds to 19 seconds. Therefore, the open-loop transfer function of the system is given by:
or
● 209
Figure 11.16: Open-loop step time response of the system.
11.6 Project 4: PID-based Water Level Control with Raspberry Pi

Description: This is the PID controller of the water level using the Raspberry Pi. In this
project, as an assumption, the aim is to keep the water level at a constant 10 cm.
The block diagram and circuit diagram of the project are as in Figure 11.12 and Figure
11.14, respectively.
Figures 11.17 through 11.20 show a proposed construction of the project. The ultrasonic
sensor module is placed at the top of the tank. A hole is made at the bottom part of the tank
so that the water can be released. A pipe is connected to the pump and water is pumped
from the reservoir into the tank. Both the reservoir and the tank are plastic containers. A
container was placed under the tank so that the released water can be collected.
Figure 11.17: Construction of the project (top view).
● 210
Figure 11.18: Construction of the project (side view).
Figure 11.19: Ultrasonic sensor mounted at the top of the tank.
● 211
Figure 11.20: Pump integrated in the reservoir.
Program listing: Figure 11.21 shows the PID program listing (Program: PiWaterPID.
py). This program is similar to the temperature control or the motor control PID programs,
but here the water level is measured and controlled.
#-------------------------------------------------------------------
# PID WATER LEVEL CONTROL
# =======================
#
# This is the PID water level controller program. The desired water
# level is set to 12cm
#
# File : PiWaterPID.py
# Date : July 2022
#----------------------------------------------------------------------
import matplotlib
import numpy as np
import time
trigpin = 21 # trig pin
● 212
echopin = 20 # echo pin

pwm = 26 # PWM pin
D = 24 # Length of tank
global sk, Kp, Ti, pk, pk_1, ek_1, a, b, yk
GPIO.setup(pwm, GPIO.OUT)
#
#
p = GPIO.PWM(pwm, 1000)
#
# Plot the graph axes and labels
#
def SetupPlot():
plt.axis([0, 100, 0, 20])
plt.title('Water Level')
plt.xlabel('Time')
plt.ylabel('Level (cm)')
plt.ion()
return
#
# Initialize
#
def Init():
sk = 10 # SetTemp
Kp = 25.0
T = 1.0
Ti = 20.0
Td = 0.0
a = Kp*T/Ti
b = Kp*Td/T
pk = 0.0
pk_1 = 0.0
ek_1 = 0.0
return
#
#
def PID():
● 213

ek = sk - yk
pk = a*ek + pk_1
wk = Kp*ek
qk = b*(ek-ek_1)
uk = 100.0
uk = 0.0
return
Init()
SetupPlot()
i = 0
#
# Send step input to the motor with 10% PWM. Sample every second
#
try:
while True:
d = echo.read('cm', 1) # Dist to surface
yk = D - d # Water level
PID()
plt.scatter(i, yk, color='Red') # Plot water level
i = i + 1
plt.pause(0.00001)
pass
p.stop()
Figure 11.21: PiWaterPID.py.
The PID parameters were initially found using the PID Loop Simulator software and they
were adjusted to get a good response from the system. Figure 11.22 shows the PID loop
simulator response produced by the system. The PID loop simulator suggested the follow-
ing values for PI type controller. Note that it was found that adding the derivative term had
not improved the response much and was therefore not used.
● 214
Kp = 20, I = 1
Converting this to our PID parameters you get: Kp = 20 and Kp / Ti = 1 or Ti = 20. These
were the initial values suggested by the simulator program. A good response was obtained
by setting Kp = 25 and Ti = 20.
Figure 11.22: PID loop simulator response.
Figure 11.23 shows the closed-loop time response of the system as plotted by the Rasp-
berry Pi program. The water level settles down at 10 cm with no overshoot, exactly as
required.
11.7 Project 5: PID-based Water Level Control with Arduino Uno

Description: This is the Arduino Uno version of the PID-driven water level control system.
In this version of the project, as an assumption, the aim is to keep the water level at a
constant 7 cm.
● 215
Block diagram: The block diagram of the project is shown in Figure 11.24.
Circuit diagram: Figure 11.25 shows the circuit diagram of the project.
Figure 11.26 shows the construction of the project.
● 216
Figure 11.26: Suggested construction of the project.
Program listing: Figure 11.27 shows the program listing (Program: PIDWaterL). This
program is similar to the PID temperature controller program but here the manipulated
variable is the distance instead of the temperature. The PI controller was found to be sat-
isfactory for this system. Adding the derivative term did not appear to improve the system
response and consequently was not used. The following PID parameters were found to be
satisfactory after a few trial and errors:
Kp = 20, Ti = 11, Td = 0
In this program, the delay function is used to create the one second sample time delay. You
could have also used a timer interrupt for more accurate delays.
//--------------------------------------------------------------------------
// WATER LEVEL PID CONTROLLER
// ==========================
//
// This is the PID water level controller for the Arduino Uno. The desired
// water level is set to 10 cm
//
// File : PIDWaterL
//---------------------------------------------------------------------------
#include <Ultrasonic.h>
Ultrasonic ultrasonic(13, 12); // trig=13, echo=12
● 217
float d, D = 24.0;
float sk, Kp, Ti, Td, pk, pk_1, ek, ek_1, a, b, yk, qk, wk, uk, T;
int MOSFET = 3;
//
//
void setup()
{
sk = 7.0;
a = Kp*T/Ti;
b = Kp*Td/T;
pk = 0.0;
pk_1 = 0.0;
ek_1 = 0.0;
}
//
//
void PID()
{
ek = sk - yk;
pk = a*ek + pk_1;
wk = Kp*ek;
qk = b*(ek - ek_1);
uk = wk + pk + qk;
if(uk > 255.0)
uk = 255;
if(uk < 0)
uk = 0;
pk_1 = pk;
ek_1 = ek;
}
void loop()
{
d = ultrasonic.read();
● 218
yk = D - d;
PID();
Serial.println(yk);
}
Figure 11.27: Program: PIDWaterL.
Figure 11.28 shows the closed-loop system time response. The water level settled at 7 cm
without any noticeable overshoot.
● 219
Chapter 12 • PID-based LED Brightness Control
12.1 Overview
In this Chapter you will use an LED and an LDR sensor positioned next to it. The aim here
is to control the brightness of the LED using a PID controller so that it remains constant no
matter what the environment light level is.
12.2 Project 1: Step Time Response of LED Brightness Control using

the Raspberry Pi
Description: A bright LED is used in this project. An LDR (light-dependent resistor) sensor
is placed next to the LED so that the LDR senses the brightness of the LED. In this project,
the step response of the system is plotted as follows:
• Turn ON the LED and place a dark paper between the LED and LDR.
• Set the potentiometer to somewhere near 10 kΩ value.
• Run the program to plot the time response.
• Remove the paper quickly after about 10 seconds. The change in the LDR
output will be displayed as the step response of the system.
Circuit diagram: The circuit diagram of the project is shown in Figure 12.2. A 100-Ω re-
sistor is used in series with the LED and the LED is connected to port pin GPIO21 (pin 40).
Using a low value resistance makes the LED shine brighter. Using the 100-Ω resistor the
current through the LED is approximately: 3.3 V – 2 V / 100 = 13 mA. A 10-kΩ potentiom-
eter is used in series with the LDR and the voltage across the LDR is read by the Raspberry
Pi through an external ADC. The LDR was placed close to the LED so that the brightness
of the LED could be measured by the LDR. MCP3002 ADC chip is used to read the analog
output voltage across the resistor in series with the LDR. This reading is proportional to the
brightness of the LED.
● 220
Construction of the project: Figure 12.3 shows the project constructed on a breadboard.
Figure 12.3: The project constructed on a breadboard.
Program listing: Figure 12.4 shows the program listing (Program: LEDLDR.py). A piece
of dark paper blocks the light from the LED to the LDR. The program turns ON the LED so
that the LDR reads a constant value. Remove the paper quickly to display the step time re-
sponse of the system. Normally, the input to the system is the brightness of the LED which
is measured in lux. In this project you will assume that the input is the raw value read from
the ADC, which ranges from 0 to 1023.
● 221
#----------------------------------------------------------
#
# LED BRIGHTNES STEP RESPONSE
# ===========================
#
# This program is used to determine the step time response
#
# File : LEDLDR.py
# Date : July, 2022
#----------------------------------------------------------
import matplotlib
import numpy as np
import time
import spidev
import math

LED = 21
GPIO.setup(LED, GPIO.OUT)
GPIO.output(LED, 1)
#
#
def SetupPlot():
plt.title('LED BRIGHTNESS') # Title
plt.xlabel('Time (x0.1 seconds)') # X label
plt.ylabel('BRIGHTNESS') # Y label
plt.ion()
return
#
# This function returns the ADC result in variable
#
● 222

rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv

i = 0

LDR = Get_ADC_Data(0)
i = i + 1
plt.scatter(i, LDR,color='red')
plt.pause(0.00001)
pass
Figure 12.4 Program: RPPIDLED.py.
Figure 12.5 shows the step time response of the system. In this graph, the horizontal axis
is in units of 0.1 seconds. Notice that the time delay (approximately 10–20 ms) is ignored.
Also, the timing and graph plotting of Raspberry Pi is not accurate. When the dark paper is
removed this is like setting the input to full brightness and in Figure 12.5 this corresponds
to 575.
Assuming that the ADC reading is the system input, the open-loop system transfer function
is found to be approximately (see Figure 12.6):
Gain = 1
Time constant = 80 ms
Therefore:
● 223
Figure 12.5: Step time response.
Figure 12.6: Determining the step time response.
12.3 Project 2: PID-Based LED Brightness Control using the

Raspberry Pi
Description: This is the LED brightness PID controller program using the Raspberry Pi 4.
The block diagram and circuit diagram are as in Figure 12.1 and Figure 12.2, respectively.
PID parameters: The previously discussed PID Loop Simulator program was used to get
the initial settings for the PID parameters. As shown in Figure 12.7, the following parame-
ters were initially found to be satisfactory:
C = 0.01, I = 1, Td = 0
Converting these values to our PID model, Kp = 0.01, Kp / Ti = 1 / I or Ti = 0.01.
● 224
Figure 12.7: PID Loop Simulator response.
Program listing: Figure 12.8 shows the program listing (Program: RPLED.py). The LED
brightness is controlled by sending a PWM waveform from the Raspberry Pi. The duty cycle
of this waveform sets the average voltage sent to the LED, and hence the perceived bright-
ness. The desired LED brightness value was set to 600. As shown in Figure 12.9, the LED
brightness settled to the desired value with no overshoot.
It is recommended to possibly cover the LED-LDR pair with a carton box so that ambient
light does not affect the LDR output. This is necessary, since if you want to set the bright-
ness at, say, 800 then this will require the LDR to be darker, which cannot be implemented
by the system. The system can only increase the LDR readings by applying a PWM wave-
form to the LED.
#----------------------------------------------------------
#
# LED BRIGHTNES PID CONTROL
# =========================
#
# This program is the LED brightness PID controller
#
# File : RPLED.py
# Date : July, 2022
#----------------------------------------------------------
import matplotlib
import numpy as np
● 225
import time
import spidev
import math

pwm = 21 # PWM pin
global sk, Kp, Ti, pk, pk_1, ek_1, a, b, yk

GPIO.setup(pwm, GPIO.OUT)
#
#
p = GPIO.PWM(pwm, 1000)
#
#
def SetupPlot():
plt.title('LED BRIGHTNESS') # Title
plt.xlabel('Time (x0.1 seconds)') # X label
plt.ylabel('BRIGHTNESS') # Y label
plt.ion()
return
#
# Initialize
#
def Init():
sk = 600 # SetTemp
Kp = 0.01
T = 0.1
Ti = 0.01
Td = 0.0
a = Kp*T/Ti
b = Kp*Td/T
pk = 0.0
pk_1 = 0.0
● 226
ek_1 = 0.0
return
#
#
def PID():
ek = sk - yk
pk = a*ek + pk_1
wk = Kp*ek
qk = b*(ek-ek_1)
uk = 100.0
uk = 0.0
return
#
# This function returns the ADC result in variable
#
rcv = ((ADC[1] & 15) << 6) + (ADC[2] >> 2)
return rcv
Init()
i = 0
try:
yk = Get_ADC_Data(0)
PID()
i = i + 1
plt.pause(0.00001)
pass
● 227
p.stop()
Figure 12.8 Program: RPLED.py.
Figure 12.9: Time response of the closed-loop system.
Figure 12.10 shows the closed-loop system time response when disturbance was applied
to the system by shining light very briefly on the LDR (or by removing the cover on top of
the LED-LDR pair).
Figure 12.10: Disturbance response of the system.
Figure 12.11 shows the LED-LDR mounted next to each other on the breadboard.
● 228
Figure 12.11: LED-LDR pair mounting.
12.4 Project 3: PID-based LED Brightness Control using the Arduino

Uno
Description: This is the LED brightness PID controller program using the Arduino Uno. The
desired LED brightness was set to 600.
Circuit diagram: The circuit diagram of the project is shown in Figure 12.13. Your LED is
connected to port 3 which is a PWM output.
Figure 12.14 shows the project built on a breadboard.
● 229
Figure 12.14: Project built on a breadboard.
Program listing: Figure 12.15 shows the program listing (Program: ARDLED). The LED
brightness is controlled by sending a PWM waveform from the Arduino Uno. The following
PID parameters were found to give satisfactory response:
Kp = 0.15, Ti = 0.3, Td = 0.03
//--------------------------------------------------------------------------
// LED BRIGHTNESS PID CONTROL
// ==========================
//
// This is the PID controller to control the brightness of the LED
//
// File : ARDLED
//---------------------------------------------------------------------------
float sk, Kp, Ti, Td, pk, pk_1, ek, ek_1, a, b, yk, qk, wk, uk, T;
int LED = 3;
int LDR = A0;
//
//
void setup()
{
pinMode(LED, OUTPUT);
sk = 600.0;
● 230

a = Kp*T/Ti;
b = Kp*Td/T;
pk = 0.0;
pk_1 = 0.0;
ek_1 = 0.0;
}
//
//
void PID()
{
ek = sk - yk;
pk = a*ek + pk_1;
wk = Kp*ek;
qk = b*(ek - ek_1);
uk = wk + pk + qk;
if(uk > 255.0)
uk = 255;
if(uk < 0)
uk = 0;
analogWrite(LED, uk);
pk_1 = pk;
ek_1 = ek;
}
void loop()
{
yk = analogRead(LDR);
PID(); // Call PID
Serial.println(yk);
delay(100); // Wait 100 ms
}
Figure 12.15: Program: ARDLED.
Figure 12.16 shows the closed-loop time response of the system. The system settles to 600
as desired, with no overshoot.
● 231
Figure 12.16: Closed-loop system response.
Figure 12.17 shows the system response when a disturbance was applied by removing the
cover over the LED-LDR for a short time. The system recovers from the disturbance in a
short time.
Figure 12.17: Disturbance response of the system.
12.5 Project 4: PID-based LED Brightness Control using the

Arduino Uno Library
Description: This project is similar to the previous one but here the Arduino Uno IDE PID
library is deployed. This library was introduced in section 9.5. The desired LED brightness
was set to 600 as in the previous project.
● 232
The block diagram and circuit diagram of the project are as in Figures 12.12 and Figure
12.13 respectively.
Program listing: Figure 12.18 shows the program listing (Program: ARDLEDLIB).
//--------------------------------------------------------------------------
// LED BRIGHTNESS PID CONTROLLER - USING PID LIBRARY
// =================================================
//
// This is the Arduino Uno PID LED brightness controller using the IDE library. #
// The desired brightness is set to 600
//
// File : ARDLEDLIB
//---------------------------------------------------------------------------
#include <PID_v1.h>
int LDR = A0;
int LED = 3;
//
//Define Variables we will be connecting to
//
double Setpoint, Input, Output;
//
//Specify the PID tuning parameters
//
double Kp=0.02, Ki=0.2, Kd=0.0;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
//
//
void setup()
{
Setpoint = 500.0;
myPID.SetSampleTime(50);
pinMode(LED, OUTPUT);
myPID.SetMode(AUTOMATIC);
}
void loop()
{
Input = analogRead(LDR); // Calculate temperature
● 233
boolean flag = myPID.Compute(); // Compute PID

analogWrite(LED, Output); // Send to MOSFET switch
if(flag)
{
Serial.println(Input);
}
}
Figure 12.18: Program: ARDLEDLIB.
Figure 12.19 shows the closed-loop time response.
Figure 12.19: Closed-loop time response.
Figure 12.20 shows the disturbance response.
Figure 12.20: Disturbance response.
● 234
Index
Index
A Derivative-only Controller 72
A201 30 Desktop mode 132
Absolute pressure sensors 31 DHT11 25
Acceleration 29 DHT22 25
Accuracy 17 DIFCUL 206
AD590 24 Differential pressure sensors 31
AD592 24 digital control system 13
ADC 12 digital encoder 14
ADXL203 29 Digital PID Controller 89
Analog sensors 16 Digital sensors 16
Analog Temperature Sensors 18 digital system 53
attachInterrupt 178 Digital Temperature Sensors 25
Auto-tuning 85 DIR 191
displacement flow meters 33
B Distance to object 200
BDC Motors 161 disturbance 232
Bluetin_Echo 204 disturbance response 141
BMP280 32 Disturbance response 232
Brett Beauregard 155 disturbances 11
Brushed DC Motors 161 duty cycle 124
Brushless DC Motors 165 Dynamic response 17
dynamic system 11
C
Chien-Hrones-Reswick 80 E
chromel/alumel junction 18 Echo pin 203
Ciancone-Marline 80 Electric Motors 160
Cohen-Coon 78 EMG30 168
commutator 161 EncoderISR 178
Compare match register 152 error signal 11
compensator 12 e-Tape Liquid Level Sensor 34
Compound-wound 163
Compute 156 F
continuous-time system 11 feedback 11
control algorithm 12 feedback control 11
controller 12 First-order Systems 37
FlexiForce 30
D Flow Sensors 35
DAC 12 Force Sensors 30
Dahlin 69 FS2012 36
damping ratio 45 FT-210 36
DC Motor Control 160
dead-beat 69 G
derivative control 69 gauge 30
Derivative Kick 86 GetDirection 156
● 235
GetKd 156 LV170 34

GetKi 156 LVDT sensors 27
GetKp 156
GetMode 156 M
magnetic core 27
H magnetic flow meters 33
Hall-effect 28 MAX6675 19
Hall Sensor Encoder 169 MAX31865 21
H-Bridge 170 Maximum overshoot 47
HC-SR04 199 MC3002 109
hotbed 119 Microcontroller Implementation 91
Hysteresis 99 millis 178
MOSFET switch 123
I Motor Selection 165
Identification of the DC Motor 188 Motor Speed 184
initial slope 41 MPL3115A2 31
integral control 69 MPRLS 3965 31
Integral-Only Controller 71
Integral Wind-up 85 N
Integrated circuits 24 natural frequency 45
Interchangeability 23 NTC 22
Internal Model Control 80 NTC 3950 119
Inverse z-Transforms 60 numerator polynomial 60
ISR 152
O
J obstacle 199
JST connector 169 ODD/SIGN 110
Offset error 17
L On-Off Temperature Control 93
Lambda 80 Operating voltage 17
LDR 220 Optical encoders 28
lead-lag 69 overshoot 75
LED Brightness Control 220
LED-LDR 228 P
light detector 28 paddlewheel sensors 33
linear encoder 28 parallel structure 89
Linearity 17 PCF8574T 94
liquid level sensor 35 Peak time 47
Liquid Sensors 32 permanent-magnet 161
LM34 24 PhaseA 195
LM35DZ 24 PhaseB 195
LM134 24 photo-transistor 32
LMD18200 170 Physical size 17
Load cells 30 PID library 155
logic level converter 186 PID Loop Simulator 86
lux 221 piezoelectric sensor 30
● 236
Contents
plant parameters 77 Saturation 85

plastic wheel 168 SCL 181
pole assignment 69 SDA 181
Position Sensors 26 Second-order Systems 43
potential divider circuit 203 self-heating 23
potentiometer 26 Self-heating 17
Power series 60 Sensitivity 16, 22
Practical PID Tuning 84 Sensors 12, 16
Prescaler 152 Separately-excited 163
Pressure sensors 30 Serial Plotter 148, 159
process control systems 69 Series-wound 162
Program Description Language 92 Servo Motors 164
Proportional + Integral + Derivative SetMode 156
controller 74 SetOutputLimits 156
Proportional + Integral Controller 73 set-point 77
proportional control 69 SetSampleTime 156
proportional-only controller 70 SetTemp 93
PTC 22 settling time 41
pull-up resistor 177 Settling time 47
Pulse transfer function 61 SetTunings 156
Pulse Width Modulated 123 SetupPlot 191
purple wire 184 SGL/DIFF 110
PWM 14 Shunt-wound 163
speed of sound 205
R SPI bus 109
ramp input 55 stator 161
Range 16 Steinhart-Hart 23
reference junction 19 step change 77
Relative pressure sensors 31 Step-input 123
Repeatability 17 Stepper Motors 164
reservoir 210 Strain gauges 30
Resistance Temperature Detector 20 system modelling 11
Resolution 16
Response time 17 T
rise time 41, 75 tachometer 28
Rise time 47 tank 210
Rotary Encoder 104 TCCR0B 173
rotor 161 TCCR1B 173
RPLCD 113 TCCR2B 173
RTDs 18 Temperature Sensors 18
Thermal shutdown 171
S thermal systems 50
sampled signal 55 thermistors 18
sampler 53 Thermistors 21
Sampling Proces 53 thermocouple amplifier 19
Sampling Time 90 Thermocouples 18
● 237
THIGH 99
Thin-film RTDs 21
Thonny IDE 132
time constant 40
Time Delay 50
Time Response 39
timer interrupts 152
TLOW 99
TMP36 25
Tools 159
torque 160
Trig input 203
tuning the controller 75
two-phase encoder 169
TXS0102 110
Type K 18
Tyreus-Luyben 80
U
ultimate gain 82
ultrasonic techniques 33
Ultrasonic transmitter-receiver 33
Unit ramp function 58
Unit step function 57
V
Velocity and Acceleration Sensors 28
W
water level 206
Water Level Control 199
water pump 206
Wire-wound RTDs 21
Y
YF-S201 35
Z
zero-order hold 55
Ziegler and Nichols 76
Z-Transform 57
● 238
books books
PID-based Practical
PID-based Practical
PID-based Practical Digital Control • Dogan Ibrahim

Digital Control
The Arduino Uno is an open-source microcontroller development system
encompassing hardware, an Integrated Development Environment (IDE),
and a vast number of libraries. It is supported by an enormous community
Digital Control
of programmers, electronic engineers, enthusiasts, and academics. The
libraries in particular really smooth Arduino programming and reduce
programming time. What’s more, the libraries greatly facilitate testing
your programs since most come fully tested and working. Prof Dogan Ibrahim has a BSc,
Hons. degree in Electronic
Engineering, an MSc degree in
The Raspberry Pi 4 can be used in many applications such as audio and Automatic Control Engineering,
video media devices. It also works in industrial controllers, robotics, games,
# d e f in e P h a s e A 2 / / Phase A
and a PhD degree in Digital Signal
and in many domestic and commercial applications. The Raspberry Pi 4 Processing. # d e f in e P h a s e B 3 / / Phase B
also offers Wi-Fi and Bluetooth capability which makes it great for remote
and Internet-based control and monitoring applications. Dogan has worked in many industrial # d e f i n e P WM 5 / / P WM p i n
organizations before he returned
to academic life. He is the author # d e f i n e DIR 4 / / DIR p i n
This book is about using both the Raspberry Pi 4 and the Arduino Uno of over 70 technical books and has
in PID-based automatic control applications. The book starts with basic published over 200 technical articles f l o a t s k , K p , T i, T d , p k , T , p k _ 1, e k , e k _ 1, a , b , y k , q k , w k , u k ;
theory of the control systems and feedback control. Working and tested on electronics, microprocessors,
v o l a t i l e u n sig n e d l o n g C o u n t = 0; / / Encode r coun t
projects are given for controlling real-life systems using PID controllers. The microcontrollers, and related fields.
open-loop step time response, tuning the PID parameters, and the closed- f l o a t c o n v = 15 0.0 / 9 0.0;
The full program listings of all the
loop time response of the developed systems are discussed together with projects discussed in the book / /
the block diagrams, circuit diagrams, PID controller algorithms, and the may be downloaded free of charge
full program listings for both the Raspberry Pi and the Arduino Uno. The from the Elektor Store website, / / C o n f i g u r e P WM p i n a n d I n i t i a l i z e v a r i a b l e s
projects given in the book aim to teach the theory and applications of PID www.elektor.com (search for:
controllers and can be modified easily as desired for other applications. book title). / /
The projects given for the Raspberry Pi 4 should work with all other v o i d s e t u p ()
{
The book covers the following topics: T C C R 2 B = T C C R 2 B & B 11111 0 0 0 | B 0 0 0 0 0 0 11;
> Open-loop and closed-loop > ON-OFF temperature control with
control systems Raspberry Pi and Arduino Uno p i n M o d e ( D I R , O U T P U T ); / / Di r e c t i o n i s o u t p u
> Analog and digital sensors > PID-based temperature d i g i t a l W r i t e ( D I R , L O W);
> Transfer functions and control with Raspberry Pi and
continuous-time systems Arduino Uno p i n M o d e ( P WM, O U T P U T ); / / P WM i s o u t p u t
> First-order and second-order > PID-based DC motor control with Elektor International Media BV
p i n M o d e ( P h a s e B , I N P U T ); / / P h a s e B is in p u t
system time responses Raspberry Pi and Arduino Uno www.elektor.com
> Discrete-time digital systems > PID-based water level control p i n M o d e ( P h a s e A , I N P U T ); / / P h a s e A is in p u t
> Continuous-time PID controllers with Raspberry Pi and Arduino
> Discrete-time PID controllers > PID-based LED-LDR brightness
a t t a c h I n t e r r u p t ( d i g i t a l P i n T o I n t e r r u p t ( P h a s e B ), E n c o d e r I S R , R I S
control with Raspberry Pi and a t t a c h I n t e r r u p t ( d i g i t a l P i n T o I n t e r r u p t ( P h a s e A ), E n c o d e r I S R 2 , R
Arduino Uno
S e r i a l . b e g i n (1 9 2 0 0 ); Dogan Ibrahim

PID-based Practical Digital Control With Raspberry Pi and Arduino Uno

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PID-based Practical Digital Control With Raspberry Pi and Arduino Uno

Uploaded by

Copyright:

Available Formats

books books

PID-based Practical Digital Control • Dogan Ibrahim

● British Library Cataloguing in Publication Data

● ISBN 978-3-89576-519-3 Print

● Second, revised edition

Chapter 1 • Control Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.1 Open-loop and closed-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2 Microcontroller in the loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.3 Control system design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1 Sensors in Computer Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2 Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2.1 Analog Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2 Digital Temperature Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.3 Position Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.4 Velocity and Acceleration Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.5 Force Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.6 Pressure sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.7 Liquid Sensors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.8 Flow Sensors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Chapter 3 • Transfer Functions and Time Response . . . . . . . . . . . . . . . . . . . . . . . . 37

3.2 First-order Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3.2.1 Time Response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.3 Second-order Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.3.1 Time Response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.4 Time Delay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.5 Transfer Function of a Closed-loop System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Chapter 4 • Discrete Time (Digital) Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

4.2 The Sampling Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

4.3 The Z-Transform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.3.1 Unit step function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.3.2 Unit ramp function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.3.3 Tables of z-Transforms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.4 The z-Transform of a function expressed as a Laplace Transform. . . . . . . . . . . . . . 58

4.5 Inverse z-Transforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

4.6 Pulse transfer function and manipulation of block diagrams . . . . . . . . . . . . . . . . . 61

4.6.1 Open-loop systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

4.7 Open-loop time response . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

4.8 Closed-loop system time response. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Chapter 5 • The PID Controller in Continuous-Time Systems . . . . . . . . . . . . . . . . . 69

5.2 Proportional-only Controller with a First-Order System. . . . . . . . . . . . . . . . . . . . . 70

5.3 Integral-Only Controller with a First-order System. . . . . . . . . . . . . . . . . . . . . . . . 71

5.4 Derivative-only Controller with a First-order System . . . . . . . . . . . . . . . . . . . . . . 72

5.5 Proportional + Integral Controller with a First-order System . . . . . . . . . . . . . . . . . 73

5.6 Proportional + Integral + Derivative controller with a First-order System . . . . . . . . 74

5.7 Effects of Changing the PID Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.8 Tuning a PID Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.8.1 Open-loop Ziegler and Nichols Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

5.8.2 Open-loop Cohen-Coon PID Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5.8.3 Closed-loop Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

5.8.4 Practical PID Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

5.9 The Auto-tuning PID Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

5.10 Increasing and Decreasing PID Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

5.11 Saturation and Integral Wind-up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

5.12 Derivative Kick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

5.13 Using the PID Loop Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Chapter 6 • The Digital PID Controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.2 Digital PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3 Choosing a Sampling Time, T . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

6.4 Microcontroller Implementation of the PID Algorithm . . . . . . . . . . . . . . . . . . . . . . 91

Chapter 7 • On-Off Temperature Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

7.2 Temperature Controllers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

7.3 Project 1: ON-OFF Temperature Control with Arduino Uno . . . . . . . . . . . . . . . . . . 94

7.7 Project 5: ON-OFF Temperature Control with Raspberry Pi 4 . . . . . . . . . . . . . . . . 109

Chapter 8 • PID Temperature Control with the Raspberry Pi . . . . . . . . . . . . . . . . 119