IOT-OPEN.EU Reloaded Consortium partners proudly present the 2nd edition of the Introduction to the IoT book. The complete list of contributors is juxtaposed below.

• Raivo Sell, Ph. D., ING-PAED IGIP
• Rim Puks, Eng.
• Mallor Kingsepp, Eng.

• Agris Nikitenko, Ph. D., Eng.
• Karlis Berkolds, M. sc., Eng.
• Anete Vagale, M. sc., Eng.
• Rudolfs Rumba, M. sc., Eng.

• Piotr Czekalski, Ph. D., Eng.
• Krzysztof Tokarz, Ph. D., Eng.
• Oleg Antemijczuk, M. sc., Eng.
• Jarosław Paduch, M. sc., Eng.
• Godlove Suila Kuaban, M. sc., Eng.

• Raivo Sell, Ph. D., ING-PAED IGIP
• Karl Läll, B. sc., Eng.

• Karlis Berkolds, M. sc., Eng.

• Łukasz Lipka, M. sc., Eng.

• Salvatore Distefano
• Rustem Dautov
• Riccardo Di Pietro
• Antonino Longo Minnolo

• Aleksandr Kapitonov, Ph. D., Assoc. Prof.
• Dmitrii Dobriborsci, M. sc., Eng.
• Igor Pantiukhin, M. sc., Eng.
• Valerii Chernov, Eng.

• Blanka Czekalska, M. sc., Eng., Arch.
• Piotr Czekalski, Ph. D., Eng.

• Fabio Bonsignorio, Ph. D., Eng.– Professor at Scuola Superiore Sant'Anna, Institute of Biorobotics
• Artur Pollak, M. sc., Eng. – CEO at APAGroup
• Ivars Parkovs, M. sc., Eng. – R&D Senior Engineer at “SAF Tehnika” Ltd.
• Janis Lacaunieks, M. sc., Eng. – R&D Engineer at “SAF Tehnika” Ltd.

This page keeps track of the content reviews and versions done as a continuous maintenance process

This book and its offshoots were prepared to provide comprehensive information about the Internet of Things on the engineering level.
Its goal is to introduce IoT to bachelor students, master students, technology enthusiasts and engineers willing to extend their current knowledge with the latest hardware and software achievements in the scope of the Internet of Things.
This book is also designated for teachers and educators willing to prepare a course on IoT.

We (Authors) assume that persons willing to study this content possess some general knowledge about IT technology, i.e. understand what an embedded system is, know the general idea of programming (in C/C++) and are aware of wired and wireless networking as it exists nowadays.

This book constitutes a comprehensive manual for IoT technology; however, it is not a complete encyclopedia nor exhausts the market. The reason for it is pretty simple – IoT is so rapidly changing technology that new devices, ideas and implementations appear daily. Once you read this book, you can quickly move over the IoT environment and market, easily chasing ideas and implementing your IoT infrastructure.

We also believe this book will help adults that took their technical education some time ago to update their knowledge.

We hope this book will let you find brilliant ideas in your professional life, see a new hobby, or even start an innovative business.

Playing with real or virtual hardware and software is always fun, so keep going!

ThisBook was implemented under the Erasmus+ KA2 projects:

• Strategic Partnerships in the Field of Education, Training, and Youth – Higher Education, 2016, IOT-OPEN.EU – Innovative Open Education on IoT: Improving Higher Education for European Digital Global Competitiveness, project number: 2016-1-PL01-KA203-026471,
• Cooperation Partnerships in higher education, 2022, IOT-OPEN.EU Reloaded: Education-based strengthening of the European universities, companies and labour force in the global IoT market, project number: 2022-1-PL01-KA220-HED-000085090.

Erasmus+ Disclaimer
This project has been funded with support from the European Commission.
This publication reflects the views only of the author, and the Commission cannot be held responsible for any use which may be made of the information contained therein.

Copyright Notice
This content was created by the IOT-OPEN.EU Consortium: 2016–2019 and IOT-OPEN.EU Reloaded Consortium 2022-2025.
The content is Copyrighted and distributed under CC BY-NC Creative Commons Licence, free for Non-Commercial use.

In case of commercial use, please contact IOT-OPEN.EU Reloaded Consortium representative.

Here comes the Internet of Things. The name that recently makes red-hot people in business, researchers, developers, geeks and … students. The name that non-technology related people consider a kind of magic and even a danger to their privacy. The EU set the name as one of the emerging technologies and estimated the worldwide market will hit well over 500 billion US dollars in 2022, while the number of IoT devices in 2030 is expected to be over 3.2 billion.

What is IoT (Internet of Things), then? Surprisingly, the answer is not straightforward.

To simplify the selection of different topics, a simple colour coding was introduced, indicating the skills required to cover particular topics. Colour codes are organized in the form of colour bars enclosing chapter titles.

Explanation:

Let us roll back to the 1970s first. In 1973 the first RFID device was patented. This device was the key enabling technology even if it does not look nor remind modern IoT devices. The low power (actually here passive) solution with a remote antenna large enough to collect energy from the electromagnetic field and power the device brought an idea of uniquely identifiable items. That somehow mimics well-known EAN barcodes and the evolution used nowadays, like QR codes, but every single thing has a different identity here. In contrast, EAN barcodes present a class of products, not an individual one. The possibility to identify a unique identity remotely became fundamental to the IoT as it's known today. RFID is not the only technology standing behind IoT. In the 1990s, the rapid expansion of wireless networks, including broadband solutions like cellular-based data transfers with their consequent generations, enabled connecting devices in various, even distant geographical locations. Parallelly an exponential increase in the number of devices connected to the global Internet network was observed, including the smartphone revolution that started around mid the first decade of the XXI century. On the hardware level, microchips and processors became physically smaller and more energy efficient yet offering growing computing capabilities and memory size increase, along with significant price drops. All those facts drove the appearance of small, network-oriented, cheap and energy-efficient electronic devices. In recent years, the development of efficient AI technologies even boosted IoT applications.

The phrase “Internet of Things” was used for the first time in 1999 by Kevin Ashton – an expert on digital innovation. Formally IoT was introduced by the International Telecommunication Union (ITU) in the ITU Internet report in 2005 ^[1]. The understanding and definitions of IoT changed over the years, but now all agree that this cannot be seen as a technology issue only. According to IEEE “Special Report: Internet of Things” ^[2] released in 2014, IoT is:

It relates to the physical aspects of IoT only. The Internet of Things also addresses other aspects that cover many areas ^[3]:

• enabling technologies,
• software,
• applications and services,
• business models,
• social impact,
• security and privacy aspects.

IEEE, as one of the most prominent standardisation organisations, also works on standards related to the IoT. The primary document is IEEE P2413™ ^[4]. It covers the technological architecture of IoT as three-layered: sensing at the bottom, networking and data communication in the middle, and applications on the top. It is essential to understand that IoT systems are not only small, local-range systems. ITU-T has defined IoT as:

In the book ^[5] by European Commission, we can read a similar description of what IoT is: “The IoT is the network of physical objects that contain embedded technology to communicate and sense or interact with their internal states or the external environment.” IoT impacts many areas of human activity: manufacturing, transportation, logistics, healthcare, home automation, media, energy saving, environment protection and many more. In this course, we will consider the technical aspects mainly.

In the IoT world, the “thing” is always equipped with some electronic element that can be as simple as the RFID tag, an active sensor sending data to the global network, or an autonomous device that can react to environmental changes. In CERP-IoT book “Visions and Challenges” ^[6] in the context of “Internet of Things” a “thing” could be defined as:

It is quite easy to find other terms used in the literature like “smart object”, “device”, or “nodes” ^[7].

One can imagine that almost everything in our surroundings is tagged with an RFID element. They do not need a power supply; they respond with a short message, usually containing the identification number. Modern RFID can achieve 6 to 7 meters of the range. Using the active RFID reader, we can quickly locate lost keys and know if we still have the butter in the fridge and in which wardrobe there is our favourite t-shirt.

If the “thing” includes the sensor, it can send interesting data about current conditions. We can sense environmental parameters like temperature, humidity, air pollution, pressure, localisation data, water level, light, noise, and movement. Using different methods and protocols, this data can be sent to the central collector that connects to the Internet and the database or cloud. There the data can be processed, and Artificial Intelligence algorithms can be used to decide actions that could be taken in different situations. Active things can also receive control signals from the central controller to control the environment: turn on/off the heating or light, water flowers, and turn on the washing machine when there is enough sunlight to generate the required electricity or charge your electric car.

This thing does not even require the controller to realise the proper decision. An autonomous vacuum cleaner can clean our house when it detects that we aren't home and the floor needs cleaning. The fridge can order our favourite beverage once the last bottle is almost empty.

Sensor Networks are a subset of the IoT devices used as a collaborative solution to grab data and send it for further processing. Opposite to the general IoT devices, Sensor Network devices do not have any actuators that can apply an action to the external world. The data flow is unidirectional, then.

IoT systems and embedded systems share almost the same domain. They frequently use the same microcontrollers, sensors and actuators, development software and even programming models. What differs between IoT and embedded systems is that IoT, on its principles, uses communication to send and receive data outside of its instance, while embedded systems do not have to. Embedded systems do not have to be network-enabled, and they do not have a unique identity frequently, while IoT devices do. Moreover, IoT systems are complex and multilayered, often introducing cloud-based parts, while embedded systems are stand-alone devices. Shortly we can say that an IoT device is network enabled embedded system.

In this chapter, there is an approach to describe modern technologies that appeared in the last few years, enabling the idea of IoT to be widely implementable. In the ^[8] one can read that “The confluence of efficient wireless protocols, improved sensors, cheaper processors and a wave of startups and established companies made the concept of the IoT mainstream”. Similar analysis has been done in ^[9] where authors write that “the latest developments in RFID, smart sensors, communication technologies and Internet protocols enable the IoT”. RFID and smart sensors need the microprocessor system to read, convert the data into digital format, and send it to the Internet using the communication protocol. This process can be done by small- and medium-scale computer (embedded) systems. These are essential elements of technologies used in IoT systems.

In recent years one can observe rapid growth in the field of microprocessors. It includes not only the powerful desktop processors but also microcontrollers – elements that are used in small-scale embedded systems. We can also notice the popularity of microprocessor systems that can be easily integrated with other factors, like sensors, and actuators, connected to the network. Essential is also the availability of programming tools and environments supported by different companies and communities. An excellent example of such a system is Arduino. Those devices are low-power, constrained devices, usually battery-powered and, in most cases, communicating wirelessly.

The same growth can be observed in the advanced constructions comparable to low-end computers. They have more powerful processors, memory and networking connectivity built-in than small-scale computer systems. They can work under the control of multitasking operating systems like Linux and Windows and embedded or real-time operating systems like FreeRTOS. Having many libraries, they can successfully work as hubs for local storage, local controllers and gateways to the Internet. Raspberry Pi and the nVidia Jetson series are examples of such systems. This category of devices frequently contains hardware accelerated (such as GPU) AI-capable solutions, i.e. nVidia Jetson Nano or Xavier series. Those devices can be battery or mains powered. Often, they are green energy powered: i.e. with a larger backup battery and energy harvesting solution (such as solar panel).

Nowadays, the Internet is (almost) everywhere. There are lots of wireless networks available in private and public places. The price of cellular access (3G/4G/5G) is low, offering a suitable data transfer performance. Connecting the “thing” to the Internet has never been so easy.

The primary paradigm of IoT is that every unit can be individually addressed. With the addressing scheme used in IPv4, it wouldn't be possible. IPv4 address space delivers “only” 4 294 967 296 of unique addresses (2^32). If you think it's a considerable number, imagine that every person in the world has one IP-connected device – IPv4 covers about half of the human population. The answer is IPv6 with a 128-bit addressing scheme that gives 3.4 × 10^38 addresses. It will be enough even if everyone has a billion devices connected to the Internet.

IoT devices generate the data to be stored and processed somewhere. If there is a couple of sensors, the amount of data is not very big, but if there are thousands of sensors generating data hundreds of times every second. The cloud can handle it – the massive place for the data with tools and applications ready to help with data processing. Some big, global clouds are available for rent, offering not only storage but also Business Intelligence tools, Artificial Intelligence analytic algorithms. There are also smaller private clouds created to cover the needs of one company only. Many universities have their own High-Performance Computing Centre.

Many people want to be connected to the global network everywhere, anytime, having their “digital twin” with them. It is possible now with small, powerful mobile devices like smartphones. Smartphones are also elements of the IoT world, being together sensors, user interfaces, data collectors, wireless gateways to the Internet, and everything with mobility features.

The technologies we mentioned here are the most recognisable. Still, there are many others, more minor, described only in the technical language in some standard description document, hidden under the colourful displays between large data centres, making our IoT world operable. In this book, we will describe some of them.

Technology development instantly shifts devices between categories. A border between Fog and Edge class devices is conventional; many can share both worlds. It depends on their purpose, application and performance configuration; thus, i.e. Raspberry Pi can be an end-node (Edge) class device and a Fog class, working as a data aggregator and analytical device.

IoT has already been defined as a network of physical things or devices that might include sensors or simple data processing units, complex actuators, and significant hybrid computing power. Today IoT systems have transitioned from being perceived as sensor networks to smart-networked systems capable of solving complex tasks in mass production, public safety, logistics, medicine and other domains, requiring a broader understanding and acceptance of current technological advancements, including advanced data processing that includes AI.

Since the very beginning of sensor networks, one of the main challenges has been data transport and data processing, where significant efforts have been put by the ICT community towards service-based system architectures. However, The current trend already provides considerable computing power even in small mobile devices. Therefore, the concepts of future IoT already shifted towards smarter and more accessible IoT devices, and data processing has become possible closer to the Fog and Edge.

Cloud-based computing is a relatively well-known and adequately employed paradigm where IoT devices can interact with remotely shared resources such as data storage, data processing, data mining and other services are unavailable to them locally because of the constrained hardware resources (CPU, ROM, RAM) or energy consumption limits. Although the cloud computing paradigm can handle vast amounts of data from IoT clusters, the transfer of extensive data to and from cloud computers presents a challenge due to limited bandwidth^[10]. Consequently, there is a need to process data near data sources, employing the increasing number of smart devices with enormous processing power and a rising number of service providers available for IoT systems.

Fog computing addressed the bottlenecks of cloud computing regarding data transport while providing the needed services to IoT systems. It is a new trend in computing that aims to process the data near the data source. Fog computing pushes applications, services, data, computing power, and decision-making away from the centralised nodes to the logical extremes of a network. Fog computing significantly decreases the data volume that must be moved between end devices and the cloud. Fog computing enables data analytics and knowledge generation at the data source. Furthermore, the dense geographic distribution of fog helps to attain a better-localised accuracy for many applications than the cloud processing of the data ^[11].
The recent development of energy-efficient hardware with AI acceleration enters the fog class of the devices, putting Fog Computing in the middle of the interest of IoT application development and extending new horizons to them. Fog Computing is more energy efficient than raw data transfer to the cloud and back, and in the current scale of the IoT devices, the application is meant for the future of the planet Earth. Fog Computing usually also brings a positive impact on IoT security, i.e. sending to the cloud preprocessed and depersonalised data and providing distributed computing capabilities that are more attack resistant.

Recent development in hardware, power efficiency and a better understanding of the IoT data nature, including such aspects as, i.e. privacy and security, led to solutions where data is being processed and preprocessed right to their source in the Edge class devices. Edge data processing on end-node IoT devices is crucial in systems where privacy is essential and sensitive data is not to be sent over the network (i.e. biometric data in a raw form). Moreover, distributed data processing can be considered more energy efficient in some scenarios where, i.e. extensive, power-consuming processing can be performed during green energy availability.

According to ^[12], Cognitive IoT, besides a proper combination of hardware, sensors and data transport, comprises cognitive computing, which consists of the following main components:

• understanding – in the case of IoT, it means systems' capability to process a significant amount of structured and unstructured data, extract the meaning of the data – produce a model that binds data to reality;
• reasoning – involves decision-making according to the understood model and acquired data;
• learning – creating new knowledge from the existing, sensed data and elaborated models.

Usually, cognitive IoT systems or C-IoT are expected to add more resilience to the solution. Resilience is a complex term and is differently explained under different contexts; however, there are standard features for all resilient systems. As a part of their resilience, C-IoT should be capable of self-failure detection and self-healing that minimises or gradually degrades the system's overall performance. In this respect, the non-resilient system fails or degrades in a step-wise manner. In case of security issues, that system should be able to change its security keys, encryption algorithms and take other measures to cope with the detected threats. Self-optimisation abilities are often considered part of the C-IoT feature list to provide more robust solutions. Recent development in the Fog and Edge class devices and the efficient software leverage cognitive IoT Systems to a new level.

All three approaches, from cloud to cognitive systems, focus on adding value to IoT devices, system users and related systems on-demand. Since market and technology acceptance of mobile devices is still growing, and the amount of produced data from those devices is growing exponentially, mobility as a phenomenon is one of the main driving forces of the technological advancements of the near future.

Data management is a critical task in IoT. Due to the high number of devices (things) already available, that is tens of billions, and considering the data traffic generated by each of them through, i.e. sensor networks, infotainment (soft news) or surveillance systems, mobile social network clients, and so on, we are now even beyond the ZettaByte (ZB 2^70, 10^21 bytes) era. This opened up several new challenges in (IoT) data management, giving rise to data sciences and big data technologies. Such challenges have not to be considered as main issues to solve but also as significant opportunities fuelling the digital economy with new directions such as Cloudonomics ^[13] and IoTonomics, where data can be considered as a utility, a commodity to manage, curate, store, and trade appropriately. Therefore, properly managing data in IoT contexts is not only critical but also of strategic importance for business players as well as for users, evolving into prosumers (producers-consumers).

From a technological perspective, the main aspects of dealing with IoT data management are:

• data source: data generation and production is a relevant part of IoT, involving sensors probing the physical system. In a cyber-physical-social system view, such sensors could be virtual (e.g. software) or even human (e.g. citizens, crowdsensing). The main issues in data production are related to the type and format of data, heterogeneity in measurements and similar issues. Semantics is the key to solving these issues, also through specific standards such as Sensor Web Enablement and Semantic Sensor Network;
• data collection/gathering: once data are generated, these should be gathered and made available for processing. The collection process needs to ensure that the data gathered are defined and accurate so that subsequent decisions based on the findings are valid. Some types of data collection include census (data collection about everything in a group or statistical population), sample survey (collection method that includes only part of the total population), and administrative by-product (data collection is a byproduct of an organisation’s day-to-day operations). Usually, wireless communication technologies such as Zigbee, BlueTooth, LoRa, Wi-Fi and 3G/4G networks are used by IoT smart objects and things to deliver data to collection points;
• filtering: is a specific preprocessing activity, usually performed at data source or data collector (IoT) nodes (e.g. motes, base stations, hotspots, gateways), aiming at cleaning noisy data, filtering noise and not helpful information;
• aggregation/fusion: to reduce bandwidth before sending data to processing nodes, these are further elaborated, compressed, aggregated and fused (sensor/data fusion) to reduce the overall volume of raw data to be transmitted and stored;
• processing: once data are adequately collected, filtered, aggregated, and fused, they can be processed. Processing can be both local and remote and usually includes preprocessing activities to prepare data for real processing. Local processing, when possible, is mainly tasked with a fast, lightweight computation on edges (Edge computing) and in the Fog layer, wherever possible, quickly providing results and local analytics. More complex computations are usually demanded to remote (physical or virtual) servers provided by local nodes (e.g. communication servers, cloudlets) in a Fog computing fashion or by Cloud providers as virtual machines hosted in data centres. This kind of computation can also involve historical data, providing global analytics, but hardly meets time-constrained applications and real-time requirements;
• storage/archive: remote servers are also used for permanently storing and archiving data, making these available for further processing, even to third parties. The database is often used for that, mainly based on distributed, NoSQL key-store technologies to improve reliability and performance;
• delivering/presentation/visualization: processing activity results must then be delivered to requestors and users. These have to be, therefore, adequately organised and formatted, ready for end-users. IoT data visualisation is becoming an integral part of the IoT. Data visualisation provides a way to display this avalanche of collected data in meaningful ways that clearly present insights hidden within this mass amount of information;
• security and privacy: data privacy and security are among the most critical issues in IoT data management. Good results and reliable techniques for secure data transmission, such as TLS and similar, are available. This way, IoT data security issues mainly concern ^[14] securing IoT devices, since they are usually resource-constrained and therefore do not allow to adopt traditional cryptography scheme to data encryption/decryption. Data privacy and integrity should also be enforced in remote storage servers, anonymising data and allowing owners to properly manage (monitoring, removing) them while ensuring availability. Indeed, security and privacy issues vertically span the whole IoT stack. A promising technique to address IoT security issues, attracting growing interest from both academic and business communities, is blockchain ^[15].

Application domains of the Internet of Things solutions are vast. Most prominent applications include (among others) ^[16]:

• building and home automation,
• smart water,
• internet of food,
• smart metering,
• smart city (including logistics, retail, transportation),
• industrial IoT,
• precision agriculture and smart farming,
• security and emergencies,
• healthcare and wellness (including wearables),
• smart environment,
• energy management,
• robotics,
• smart grids.

Smart Homes are one of the first examples that come to mind when discussing Internet of Things domain applications. Smart home benefits include reduced energy wastage, the quality and reliability of devices, system security, reduced cost of basic needs, etc. Some home automation examples are environmental control systems that monitor and control heating, ventilation, air conditioning and sunscreens; electrical charging of vehicles; solar panels for electrical power and hot water; ambient lighting control, smart lighting for aquaria; home cooking and food ordering; access control (doors, garage, gate); smart plant irrigation systems (both indoors and outdoors); baby monitoring; timed pet food dispensers; monitoring perishable goods (for example, in the refrigerator); household items remote monitoring (for instance, of washer cycle status); tracking and proactive maintenance scheduling (such as, i.e. electric car charging); event-triggered task execution. Home security also plays a significant role in smart homes. Examples of applications are automatic door locks, sensors for opening doors and windows, pressure, motion and infrared sensors, security cameras, notifications about security (to the owner or the police) and fitness-related applications.

In Smart City, multiple IoT-based services are applied to different areas of urban settings. The aim of the smart city is the best use of public resources, improvement of the quality of resources provided to people and reduction of operating costs of public administration ^[17]. A smart city can include many solutions like smart buildings, smart grids for improving energy management, smart tourism, monitoring of the state of the roads and occupation of parking lots, public transportation optimisation, public safety, environment monitoring, automatic street lighting, signalling with smart power devices, control of water levels for hydropower or flood warnings, electricity-generating devices like solar panels and wind turbines, weather monitoring stations. Transportation in smart cities may include aviation, monitoring and forecasting of traffic slowdowns, timetables and current status, navigation and route planning, as well as vehicle diagnostics and maintenance reports, remote maintenance services, traffic accident information collection, fleet management using digital tachographs, smart parking, car/bicycle sharing services ^[18]. IoT in transportation makes cars interconnected, particularly in the approaching autonomous vehicles era.

Smart Grid is a digital power distribution system. This system gathers information using smart meters, sensors and other devices. After these data are processed, power distribution can be adapted accordingly. Smart grids deliver sustainable, economical and secure electricity supplies efficiently.

In Precision Agriculture and Smart Farming IoT solutions can be used to monitor the moisture of the soil and conditions of the plants, control microclimate conditions and monitor the weather conditions to improve farming ^[19]. The goal of using IoT in agriculture is maximising the harvest, reducing operational costs, being more efficient, and reducing environmental pollution using low-cost automated solutions. An interaction between the farmer and the systems can be done using a human-machine interface. In the future smart precision farming can be a solution for such challenges as increasing worldwide demand for food, a changing climate, and a limited supply of water and fossil fuels ^[20].

Internet of Food integrates many of the aforementioned techniques and encompasses different stages of the food delivery chain, including smart farming, food processing, transportation, storage, retail, and consumption. It provides more safety and improved efficiency at each food production and consumption stage, including reduced waste and increased transparency.

Similar to precision agriculture, which is part of IoT in industry, Smart Factories also tend to improve manufacturing by monitoring pollutant gas emissions, locating employees and with many other solutions.

Industrial IoT and smart factories are part of the Industry 4.0 revolution. In this model, modern factories can automate complex manufacturing tasks, thanks to the Machine-To-Machine communication model, which provides more flexibility in the manufacturing process to enable personalised, short-volume product manufacturing easily.

In the healthcare and wellness, IoT applications can monitor and diagnose patients and manage people and medical resources. It allows remote and continuous monitor the vital signs of patients to improve medical care and wellness of patients ^[21]. An essential part of smart welfare is wearables, including wristbands and smartwatches that monitor the activity level, heart rate and other parameters. Smart healthcare includes remote monitoring, care of patients, self-monitoring, smart pills, smart home care, Real-Time Health Systems (RTHS) and many more. Medical robotics can also be part of the healthcare IoT system that includes medical robots in precision surgery or distance surgery; some robots are used in rehabilitation and hospitals (for example, Panasonic HOSPI ^[22]) for delivering medication, drinks, etc. to patients.

Wearables used in IoT applications should be highly energy efficient, ultra-low power and small-sized. Wearables are installed with sensors and software for data and information collected about the user. Devices used in daily life like Fitbit ^[23] are used to track people's health and exercise progress in previously impossible ways, and smartwatches allow to access smartphones using this device on the wrist. But wearables are not limited only to wearing them on the wrist. They can also be glasses equipped with a camera, a sports bundle attached to the shoes or a camera attached to the helmet or as a necklace ^[24].

[ktokarz][✓ ktokarz, 2023-08-23]Describe in general IoT MCUs: CPU, FPU, RAM, Storage (flash), GPIO, Interrupts system, DMA, built-in radio interfaces (if any).

IoT device is, in almost all cases, based on microcontroller. A microcontroller, often called a single-chip computer, is an integrated circuit that incorporates all units required to function as the computer. It includes a central processing unit (CPU), memory for programs, memory for data, inputs, outputs, timers, serial communication ports and other peripherals. Complex microcontrollers, called embedded processors, can include more processor cores, display controllers, advanced internal data transfer mechanisms (like DMA), programmable connections between modules, specialized coprocessors for ciphering and deciphering, compression and decompression, video and audio coding and decoding, and other modules. Microcontrollers are even more complex in the IoT world due to wireless networking capability. A complex microcontroller equipped with an internal radio communication module is also known as a System on Chip (SoC).

The typical microcontroller includes general-purpose units like:

• CPU core,
• Program memory,
• Data memory,
• Timers, Counters,
• Interrupt controller,
• I/O ports,
• Serial synchronous and asynchronous communication ports,
• Analog to Digital converter,
• PWM (Pulse width Modulation unit for Digital to Analog conversion),
• DMA controller,
• Supervisory units (Watchdog, Reset, Brownout).

Embedded Processor or System on Chip can contain also:

• Network interface,
• USB controller,
• Memory interface module,
• Floating point unit (FPU),
• Cryptographic module,
• Other application-specific extensions.

The CPU core is the unit that executes the main program. It controls program flow, executes general-purpose instructions, calculates addresses, and processes integer values. For fast floating point calculations, an FPU coprocessor is built-in. It executes instructions that perform calculations on real numbers and advanced mathematical functions. The program instructions are fetched from program memory, usually implemented as internal or external flash memory. Data is stored in internal data memory implemented as static RAM. If more memory is needed, some microcontrollers have a memory management unit that allows them to connect external DRAM memory. Flash memory is often used as a place for file storage. Timers and counters are units that help to generate pulses of specified length and square signals of specified frequency. They can also measure delays and synchronise the work of other modules like serial ports, converters, and displays. Timers can generate pulse width modulated signals to control the speed of motors and light brightness. Microcontrollers have digital input and output ports to connect other elements of the systems. Connecting external sensors to collect information from the surroundings and output devices to manipulate environmental parameters is possible. Analogue inputs can read the voltage value generated by simple sensors. Serial communication ports are used to connect more complex sensors and displays to communicate with the user or another computer system. An interrupt controller is a unit that automatically executes subroutines responsible for handling tasks specific to the hardware that signalled the situation that needs the processor's attention. The processor doesn’t have to waste execution time by periodically checking if there is a need to take care of the device. It helps to make the code more efficient and reliable. Supervisory units help to recover from some abnormal situations. Watchdog resets the processor in case the software hangs up. Brownout detector constantly monitors the power supply voltage. It stops the processor if the voltage is too low for proper operation to avoid execution errors, flash write errors, and other malfunctions. Supervisory interfaces like JTAG allow writing the programs into flash memory and debugging the code. Direct Memory Access (DMA) module performs memory operations without processor intervention. It is usually used for copying data blocks between memory and other peripheral units. For example, data from the network unit is stored automatically in the buffer, and the CPU is informed while the data transfer is complete.

Details of the internal construction and operation of many internal modules of popular microcontrollers are described in further chapters of this book.

IoT systems share programming paradigms with embedded systems. Each microcontroller manufacturer has its own set of tools (usually called SDK or Development Framework) that frequently contain an IDE dedicated to the platform. There are some cross-platform solutions and frameworks, however.
Programming languages include:

• C/C++ - undoubtedly the most popular, versatile, yet demanding programming language. With modern supporting tools such as syntax highlights, code samples, code generators (AI-based) and instant syntax checking, C/C++ programming became relatively easy but still requires solid software development foundations. On the other hand, it is probably the only programming language that is natively supported with hardware debugging features. C/C++ bare metal programming allows the developer to control all MCU features on the lowest level and implement energy-efficient, fast and compact solutions.
• Java and Javascript - with low entry-level for developers, usually represented by the variation of NodeJS, limited and applicable to beginners. Within the constraints of the interpreter, it provides rapid prototyping and the fastest market delivery but the lowest flexibility and extensibility beyond what the manufacturer plans. Also, the Java development framework implemented in the microcontroller is compact because of the constrained resources. Usually, it does not keep standards, so the feature of the portability of the code is somewhat limited.
• Python (Micropython) - similarly to Java, offers an easy start but low flexibility and control over the hardware. Acceptable for prototyping.
• Other.

IoT device programming can be done on a variety of levels. Below we present the most popular models and briefly discuss their pros and cons.

The bare metal programming model is where the software developer builds firmware (usually from scratch or based on a stub generated by the SDK) and flashes it to the MCU. The MCU usually does not contain software other than technical ones necessary for starting and updating the device, i.e. a bootloader. The developer must implement all algorithms, communication, interfacing, storage, etc., on a low level. They may use 3rd party libraries to implement it, which speeds up development significantly. There is no operating system running in the background. Eventually, it comes with the firmware as part of it, as included by the developer, i.e. FreeRTOS ^[25].

Bare metal programming requires a good understanding of the hardware configuration of the IoT device as well as the configuration of the software development toolchain. The MCU manufacturer usually provides SDK and related tools, but there do exist middleware solutions (such as PlatformIO ^[26]) that significantly simplify installation.

In most cases, source code is written in C or C++ language or their combination (e.g. in the case of the STM). The development process for bare metal programming is present in the following figure 2 and its features are discussed in table 2. In short, it requires developing, compiling and uploading the firmware to the device's flash memory. Programming uses a programmer (physical or Over The Air - OTA, virtual interface). The bare metal model usually provides the capability of hardware development.

The bare metal programming model is considered the only one to enable developers to have absolute control over the hardware on a very low level. On the one hand, it brings opportunities to implement non-standard solutions and optimal code in terms of compactness and efficiency; on the other, it increases time-to-market delivery. Recent advances in development supporting tools (i.e. AI-based code generation), wide availability of the libraries, standardisation of their presence and automated management, such as, e.g. in PlatformIO Library Management ^[27] significantly lower this time.

Opposite to bare metal programming, script programming does not involve compilation or firmware burning into the flash memory. This programming model uses interpreted languages such as Python (actually Micropython: an edition of Python for microcontrollers dedicated to constrained devices), NodeJS, Javascript, Java, C#, etc. A virtual machine middleware (programming language interpreter) running bare metal (installed as firmware) or as a part of the operating system (if any), and the developer prepares an algorithm as a script, usually in a textual form, later uploaded and executed on the device. The middleware brings an overhead on execution; thus, this solution is intended for not so constrained IoT devices, still acceptable for Edge and quite common for Fog class. It requires much more CPU, RAM and storage than bare metal programming, has limitations from the interpreter implementation and only indirectly accesses hardware. It is not suitable for real-time solutions.

The development process for scripting programming is present in the following figure 3 and its features are discussed in table 3. In short, it requires limited SDK (or none), but debugging is complex, if possible.

This programming model is suitable wherever standard solutions are implemented and where code execution efficiency is not critical, and there is no demand for real-time operations; eventually, the IoT device is unconstrained, providing developers with decent CPU (e.g. modern ARM), RAM and storage. Note those solutions are usually less energy efficient than bare metal programming; still, they offer great flexibility in algorithm implementation, far beyond a predefined list of choices or limited configuration as presented in the following section. On the other hand, it speeds up delivery time to the market because of the ease of implementation, the lack of need to install the complex software development environment and the high level of abstraction.

Several middleware (IoT frameworks) are available for various IoT devices. This development model focuses on reconfiguring the sealed firmware delivered “as is” using some configuration interface or script (or both). Eventually, modifying and recompiling it yourself is possible if it is open source. Still, the process is usually very complex, and understanding all relations and development toolchain sometimes is more complicated than developing a solution from scratch as a bare metal. Proprietary frameworks do not bring this opportunity at all and are delivered “as is” with a predefined set of features. The development is limited to reconfiguring the elements from simply switching them on and off through setting up access and credentials, even up to the GPIO assignment. This usually does not bring capabilities to modify the algorithm, eventually to choose a behaviour from the predefined list proposed by the middleware author. Such a model does not bring debugging capabilities; finally, simple tracking with error codes and log files (if at all). Moreover, in many scenarios, middleware is dependent on some external resources (i.e. authorisation via a cloud or firmware updates delivered with this channel).

The development process for the middleware configuration model is present in the following figure 4 and its features are discussed in table 4.

Configuration range varies among IoT frameworks but commonly requires compatible hardware. Proprietary firmware provides sealed configuration software and encryption; thus, it virtually excludes any non-standard modifications or makes them very complex. IoT hardware used to be compatible with more than one firmware, and proprietary ones can be replaced with another open source, i.e. Tasmota ^[28]. Configuration in proprietary middleware scenarios can be provided indirectly via a cloud solution that raises serious questions about privacy (i.e. configuring your private WiFi router credentials via a public or 3rd party cloud, not directly to the device).

In the beginning, it is essential to distinguish an IoT Framework that is a set of tools, firmware for a variety of devices, sometimes also hardware, delivered as is and providing developers with configuration capabilities on the high abstraction level from the Programming Framework that is related to the low-level programming, here in C/C++, referred to as an SDK. SDK tends to be a narrower definition than a programming framework as the former one contains not only SDK but also tools, development toolchain and code organisation rules.
This chapter presents and discusses programming frameworks (SDKs and source code organisation) that define how the IoT code is organised on the low level in the Bare Metal programming model for Edge class devices.

Almost every MCU (microchip/microcontroller) vendor develops its own SDK, providing programmers with a specific programming framework. It is worth nothing to mention that, in many cases, it follows the general programming construction of the source code for C or C++, such as below:

int main() {
    std::cout << "Hello IoT!";
    return 0;
}

A common approach is to use a GUI to automate the generation of the source code stub that contains the hardware-specific configuration, i.e. timers, GPIOs, and interrupts, to avoid monotonous and complex tasks and speed up time to market.
Still, as hardware differs, it is particular for each platform, and usually, software development requires a rigorous approach to inject user-specific code only in predefined locations. Otherwise, it may break source code or even delete it when re-generating configuration using SDK tools and automation. Sample main() function for the STM32 MCU is presented below. Developers are intended to fill their code only in predefined areas, such as starting from USER CODE BEGIN Init and finishing before USER CODE END Init; otherwise, the source code will be gone when updating the configuration:

int main(void)
{
  /* USER CODE BEGIN 1 */
 
  /* USER CODE END 1 */
  HAL_Init();
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
  SystemClock_Config();
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
  MX_GPIO_Init();
  MX_LPUART1_UART_Init();
  MX_NVIC_Init();
  /* USER CODE BEGIN 2 */
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
      nUARTBufferLen = sprintf((char*)tUARTBuffer, "Hello World!\n\r");
      HAL_UART_Transmit_IT(&hlpuart1, tUARTBuffer, nUARTBufferLen);
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

Studying specific platforms is time-consuming, and as each vendor has its own approach, knowledge and source codes are usually not portable between microcontrollers.
Specific frameworks for hardware vendors are (among others):

• Espressif ESP8266:
  • ESP8266 RTOS SDK,
  • ESP8266 Non-OS SDK,
  • Arduino.
• AVR/Atmel:
  • AVR Studio (Atmel Studio),
  • Arduino.
• Espressif ESP32:
  • ESP-IDF,
  • Arduino.
• Nordic Semiconductors nRF52:
  • Mbed,
  • Zephyr RTOS,
  • nRF5 SDK,
  • Arduino.
• ST Microelectronics STM32 series:
  • Mbed,
  • CMSIS,
  • Zephyr RTOS,
  • Registers programming model (RAW),
  • STM32Cube (HAL),
  • Arduino.

Typical C++ code, as presented above, is a single-pass execution. On the other hand, IoT devices used to work infinitely, handling their duties such as reading sensors, communicating over the network, sending and receiving data, routing messages and so on, thus, requiring setting up an infinite while (1) loop for processing. Many tasks need to be done in parallel, so it is common to include a task scheduling mechanism to run multiple tasks asynchronously. A common is to use the FreeRTOS ^[29] or its modified versions for the specific hardware platform provided by the hardware vendor, i.e. as in the case of the ESP32 ^[30] to provide support for multicore MCUs.

Observing the list of software frameworks above, one can easily find that many platforms have common frameworks, but the Arduino framework is present for all of them. Arduino framework is a cross-platform approach providing a slightly higher level of abstraction over dedicated software frameworks, and it is the most popular among hobbyists, students, professionals and even researchers at the moment. Arduino Framework is a reasonable balance between uniform code organisation and elements of cross-hardware HAL, still bringing opportunities to access hardware on a low level and get the advantage of the advanced features of modern IoT microcontrollers such as, e.g. power management. Most hardware vendors support this framework natively, and it has become almost an industry standard. Some advanced hardware control may require integration or other native frameworks, anyway. Still, the Arduino framework has real-time capacity. It is powerful and flexible enough to handle most IoT-related tasks, and most of all, it has excellent community support with dozens of software libraries, examples and applications worldwide.

A dummy C/C++ code for the Arduino framework looks as follows:

void setup()
{
 
}
 
void loop()
{
 
}

The void setup() function is executed only once after the microcontroller reboots. Its purpose is to initialise, instantiate objects, read configuration, check working conditions, and so on: generally, all tasks that are to be executed only once in a work cycle of the IoT device.
The void loop() function is executed in a loop automatically and infinitely once a single pass is finished. Its purpose is to implement repeating tasks such as periodical reading of a sensor and sending the data to the cloud. There is no need to implement a dummy while(1) inside the loop(); moreover, it is usually not advised or even forbidden. It is because, for every execution of the loop() statement, many other tasks, such as handling communication, may be executed once. Making a single pass of the loop() function infinite (i.e. with implementing an infinite while(1) loop, could cause starvation of the other underlying processes the framework handles, such as network communication, embedded protocols handling, etc.).

The book presents code and examples in the Arduino framework context for Edge class devices but also for Fog class devices (scripting). Wherever other framework is used, it will be clearly stated. Note, following introduction to the C and C++ programming and task handling contents, are universal and can be applied to the other frameworks, whether directly or indirectly, with some adaptation on the code level.

Software development in the bare metal model requires a development toolchain installed on the developer's computer. The vendor of the MCU usually provides a set of tools. This set frequently includes a dedicated compiler, linker, library management tools, configuration tools, debugger software, etc. These tools are command lines in most cases. Using a GCC ^[31] C/C++ compiler is also quite common. On top of it, a GUI with a rich UI interface is built to simplify software development. Some vendors provide their own GUIs, such as, e.g. STMicroelectronics' STM32CubeIDE (image 5), while others use already available universal code editing solutions and integrate with them, i.e. in the form of plugins or extensions.

Because documentation for the command line tools composing SDK is usually available, there are also universal solutions that enable developers to use a single GUI environment for various tasks and microcontrollers, switching among them quickly, such as Visual Studio Code (figure 6). Each platform requires its dedicated toolchain, anyway, and integration with universal code editors such as the aforementioned VS Code may be tricky. Luckily, there are tools to help with the automated installation of all required components, such as PlatformIO ^[33], that we describe below.

As the Arduino programming framework became a cross-platform standard, vendors provided low-level libraries implementing standard functionalities such as embedded communication protocols (Serial, SPI, I2C, 1Wire) and networking communication. Arduino, a manufacturer of popular development boards, provides an IDE (figure 7: Arduino IDE ^[34]) that is intended to be an entry-level development environment. It can be extended beyond genuine Arduino boards, i.e. with the Espressif toolchain for ESP8266 and ESP32. This software, however, is very limited in features and is suitable only for simple projects.

A number of additional tools usually come with the development toolchain provided by the hardware vendors. They include programmers (flashers, injecting firmware into the IoT device), configuration tools, power consumption calculators, etc. Installation is not always straightforward, and updating is tricky. Developers who use a variety of platforms (MCUs) struggle with instant updates, browsing the web for tools and sources. Moreover, handling libraries they use for development is time-consuming and involves instant monitoring of changes, manual copy-paste operations on files, etc. And it has to be done for every project individually.

The solution is a developer's middleware that integrates with selected IDE and helps to install, configure and maintain toolchains for hardware, software development libraries, and also contains a set of additional tools (i.e. serial port monitor, JTAG debugger, code repository integration, collaboration tools, remote development, etc.). As mentioned above, one example of a handy middleware for IoT and embedded development is PlatformIO. It is a command-line toolset that provides a whole ecosystem for virtually any hardware platform; it still uses the vendor's proprietary toolchains. It perfectly integrates with Visual Studio Code (among others) via VS Code's extension (plugin) systems. VS Code works also as a GUI for PlatformIO. In the following figures, we present its look and UI when integrated with Visual Studio Code (figures 8, 9 and 10).

A PlatformIO-enabled IoT project is a set of files with a platformio.ini file in the root folder and main.cpp in the ./src/ subfolder (as, i.e. in the figure 8, project folder tree is to the left)). The platformio.ini file describes all technical parts of the project: the hardware platform, the method of uploading the firmware (usually via a serial port), software libraries that are included in the code and should be automatically pulled from the libraries repository during compilation and many other options ^[35]. Sample platformio.ini file is presented in the code below:

[env:d1_mini]
platform = espressif8266
board = d1_mini
framework = arduino
upload_port = /dev/ttyUSB0
upload_speed = 9600
monitor_port = /dev/ttyUSB0
lib_deps = 
	arduino-libraries/LiquidCrystal@^1.0.7
	adafruit/Adafruit Unified Sensor@^1.1.7
	adafruit/DHT sensor library@^1.4.4

This code configures the ESP8266 (Espressif) hardware project, with specific developer board D1 Mini and programming done in the “Arduino” framework development model.
Communication with the IoT device is via serial port (here /dev/ttyUSB0 for Linux or, i.e. COM3 for Windows) and uses the same port for monitoring (serial port monitor for tracing messages from the MCU and code).
It uses three libraries registered in the library registry for PlatformIO: LiquidCrystal, Adafruit Unified Sensor and DHT sensor library, with explicit versions. PlatformIO's Library Manager automatically checks for updates and proposes to update libraries to the latest available if a version is not explicitly stated. The Library Registry in the PlatformIO is a repository of the Gitlab project, available online ^[36]. Libraries are currently held per project instead of shared between projects.
At the start of the PlatformIO GUI and then periodically, it checks for PlatformIO updates and development toolchain updates, proposing to update them when a new version is available.

The following sub-chapters cover programming fundamentals in C/C++, which comply with most C/C++ notations. Those who feel comfortable in programming will find these chapters somewhat introductory, while for those having no or little experience, it is highly recommended to cover this introduction. This chapter and its sub-chapters target the basics and general syntax of C/C++ programming for different platforms, including Arduino, Espressif, Nordic, STM32, and partially for Raspberry Pi devices; however, in any case, the programming environment configuration is different for every platform. The Arduino programming framework is common for many MCU manufacturers of the IoT Edge class devices in bare metal programming mode, even if bringing some overhead and does not let the developer push the devices to their limits. Thus we refer mostly to this one. To enjoy full power, efficiency and control of the specific device, one needs to use a dedicated SDK and Framework, but for teaching purposes and many even professional applications, Arduino Framework is suitable and a good balance between the cost of the development and the result.

Almost every computer program manipulates the data. Data representation in the program is variable. In C/C++, the variable needs to be defined before using it, giving it some name and assigning chosen type, dependent on the kind of data. Here we show some common data types and how to use variables.

Data type specifies how it is encoded and represented in the computer memory. For example, integer numbers are binary-encoded, the texts are represented as a series of ASCII-encoded characters, and real numbers have a particular encoding scheme that consists of two binary numbers - mantissa and exponent. Other data types are tables that consist of elements of the same type or structures with elements of different types. There are plenty of different data types, some of them are predefined, but user-own types can be defined based on existing ones. Creating a variable requires specifying its type, which determines its place in the memory of the microcontroller and also the way how it can be used. Further will be viewed the most used ones together with examples of defining variables.

• byte – a numeric type of 8 bits that stores numbers from 0 to 255.

byte exampleVariable;

The example above defines a variable, reserves its memory, and assigns the memory address to the variable name. It is also possible to give the variable the initial value as below:

byte exampleVariable = 123;

• int – the integer number. Its size depends on the microcontroller class. In the case of AVR (Arduino), it consists of 16 bits that can contain values from –32 767 to 32 768. In ARM-based microcontrollers (like STM32), its size is 32 bits.

int exampleVariable = 12300;

• float – a data type for real numbers that uses 32 bits and stores numbers approximately from –3.4 × 10^38 to 3.4 × 10^38.

float exampleVariable = 12300.546;

• array – a set of data of the same type that can be accessed using a serial number or index. The index of the first element is always 0. The values of an array can be initialized at the definition of it or set during the execution of the program. In the following example, the array of four elements with the name “first array” and data type int has been created. The value of the array with an index of 0 will be 12, and the value with an index of 3 will be 15.

int firstArray[] = {12,-3,8,15};

Square brackets of the array can be used to access some value in the array by index. In the following example, the element with index 1 (that is –3) is assigned to the secondVariable variable.

int secondVariable = firstArray[1];

An array can be quickly processed in the loop. The following example shows how to calculate the sum of all elements from the previously defined array (for statement will be explained in detail in the following chapters).

//The loop that repeats 4 times
int sum = 0;
for(int i = 0; i < 4; i = i + 1){         
     sum = sum + firstArray[i]; 
}

The loop in the example starts with index 0 (i = 0) and increases it by 1 while smaller than 4 (not including). That means the index value will be 3 in the last cycle because when the i equals 4, the inequality i < 4 is not true, and the loop stops working.

• bool – the variables of this data type can take values TRUE or FALSE. Arduino environment allows the following values to these variables: TRUE, FALSE, HIGH (logical 1 (+5 V)) and LOW (logical 0 (0 V)).

Data type conversion can be done using multiple techniques – casting or data type conversion using specific functions.

• Casting – cast operator translates one data type into another type straight forward. The desired variable type should be written in the brackets before the variable data type, which needs to be changed. In the following example, where the variable type is changed from float to int, the value is not rounded but truncated. Casting can be done to any variable type.

int i;
float f=4.7;
 
i = (int) f; //Now it is 4

• Converting – byte(), char(), int(), long(), word(), float() functions are used to convert any type of variable to the specified data type.

int i = int(123.45); //The result will be 123

• Converting String to float – function toFLoat() converts String type of variable to the float. The following example shows the use of this function. If the value cannot be converted because the String doesn't start with a digit, the returned value will be 0.

String string = "123fkm";
float f = string.toFLoat(); //The result will be 123.00

• Converting String to Int – function toInt() converts String type of variable to the Int. In the following example, the use of this function is shown.

String string = "123fkm";
int i = string.toInt(); //The result will be 123

A typedef specifier can give another name for existing types or declares a new one. Renaming types is possible, but software development frameworks used have a number of aliases already. It is helpful, however, when combined with enumerations, classes and structures to give them reasonable names and re-use them later in the code to improve their readability. We present more details on structures in the chapter Structures and Classes, but here is an example presenting a reasonable use of the typedef specifier.

typedef struct {int x; int y;} tWaypoint; //Declare complex type named waypoint
...
//Declare a variable of the type of tWaypoint
tWaypoint wp1;

Enumerations are helpful to give meaning to the integer values and present some logic in a code instead of putting numbers into it. It can be, i.e., the device's state, error code, etc. In the case a new enumeration is needed, it is possible to declare one using the enum keyword and specifying a list:

enum errorcodes {ER_OK, ER_DOWNLOAD, ER_UPLOAD, ER_NOWIFI};  //define enumeration
...
errorcodes Errorcode;                                        //declare a variable
...
Errorcode = ER_DOWNLOAD;                                     //assign a value

The default numbering starts with 0 (ER_OK=0) and increases by 1 with every next item on the enumeration list. However, explicitly defining values represented by the item labels is possible.

enum errorcodes {ER_OK=0, ER_DOWNLOAD=3, ER_UPLOAD=4, ER_NOWIFI=1};

Operators represent mathematical, relational, bitwise, conditional, or logical data manipulations. There are many operators in the C/C++ language. In this chapter, the most important are presented. Logical operators will be shown in the next chapter as they are used together with conditional statements.

• Assignment operator ( = ) – the operator that assigns the value on the right to the variable on the assignment operator's left. The left side should represent the variable (must be able to be modified), and the right side can be the number (constant), variable, or expression. In the case of an expression, its value is first calculated, and then the result is assigned to the variable on the left. The work of an assignment operator can be seen in any of the following operation examples.

Arithmetic operations are used to do mathematical calculations with numbers or numerical variables. The arithmetic operators are the following.

• Addition ( + ) – one of the four primary arithmetic operations used to add numbers. The addition operator can add only numbers, numeric variables, or a mix of both. The following example shows the use of the addition operator.

int result = 1 + 2; //The result of the addition operation will be 3

• Subtraction ( - ) – the operation that subtracts one number from another where the result is the difference between these numbers.

int result = 3 - 2; //The result of the subtraction operation will be 1

• Multiplication ( * ) – the operation that multiplies numbers and gives the result.

int result = 2 * 3; //The result of the multiplication operation will be 6

• Division ( / ) – the operation that divides one number by another. If the result variable has the integer type, the result will always be the whole part of the division result without the fraction behind it. If the precise division is necessary, using the float type of variable for this purpose is important.

//The result of the division operation will be 3 
//(Only the whole part of the division result)
int result = 7 / 2;        
//The result of the division operation will be 3.5
float result2 = 7.0 / 2.0; 

• Modulo ( % ) – the operation that finds the remainder of the division of two numbers.

//The result of the modulo operation will be 1, 
//Because if 7 is divided by 3, the remaining is 1
int result = 7 % 3; 

Bitwise operators perform operations on bits in the variable. Among them, there exist bitwise logic operations. It means the same logic function is applied to every pair of bits in two arguments. Bitwise or ( | ) means that if at least one bit is “1” at the chosen bit position, the resulting bit will also be “1”. Bitwise and ( & ) means that if at least one bit is “0”, the resulting bit is “0”. Bitwise operators shouldn't be confused with Logic Operators ( || ), ( && ), which operate on a single boolean logic value.

byte result = 5 | 8;
; //The operation in numbers gives the result of 13
; //in bits can be shown as follows
; // 00000101b
; // 00001000b
; // ---------
; // 00001101b

byte result = 5 & 1;
; //The operation in numbers gives the result of 1
; //in bits can be shown as follows
; // 00000101b
; // 00000001b
; // ---------
; // 00000001b

Bitwise operators also allow shifting data left ( « ) or right ( » ) chosen number of bit positions. Shifting is often used in embedded programming to access the bit at a specific position. Shifting data one bit left gives the result of multiplication by 2 while shifting one bit right gives the effect of dividing by 2.

byte result = 5 << 1;
; //The operation in numbers gives the result of 10
; //in bits can be shown as follows
; // 00000101b
; // 00001010b

Compound operators in C/C++ are a short way of writing down the arithmetic operations with variables. All of these operations are done on integer variables. These operands are often used in the loops when it is necessary to manipulate the same variable in each cycle iteration. The compound operators are the following.

• Increment ( ++ ) – increases the value of integer variable by one.

int a = 5;
a++; //The operation a = a + 1; the result will be 6

• Decrement ( - - ) – decreases the value of the integer variable by one.

int a = 5;
a--; //The operation a = a – 1; the result will be 4

• Compound addition ( += ) – adds the right operand to the left operand and assigns the result to the left operand.

int a = 5;
a+=2; //The operation a = a + 2; the result will be 7

• Compound subtraction ( -= ) – subtracts the right operand from the left operand and assigns the result to the left operand.

int a = 5;
a-=3; //The operation a = a – 3; the result will be 2

• Compound multiplication ( *= ) – multiplies the left operand by the right operand and assigns the result to the left operand.

int a = 5;
a*=3; //The operation a = a × 3; the result will be 15

• Compound division ( /= ) – divides the left operand with the right operand and assigns the result to the left operand.

int a = 6;
a/=3; //The operation a = a / 3; the result will be 2

• Compound modulo ( %= ) – takes modulus using two operands and assigns the result to the left operand.

int a = 5;
//The result will be the remaining 
//Part of the operation a/2; it results in 1
a%=2; 

• Compound bitwise OR ( |= ) – bitwise OR operator that assigns the value to the operand on the left.

int a = 5;
a|=2; //The operation a=a|2; the result will be 7

• Compound bitwise AND ( &= ) – bitwise AND operator that assigns the value to the operand on the left.

int a = 6;
a&=; //The operation a=a&2; the result will be 2

Simple and complex types can be referred to with the use of pointer variables. A pointer is a variable that holds the address of the variable. The length of the pointer is equivalent to the length of the memory address (usually 16, 32 or 64 bits). A pointer does not contain a value but rather points to the variable (a memory) where the value is stored. A pointer variable must be initialised and dereferenced with Address-Of and Dereferencing operators.
The following example presents a simple type declaration and the use of a pointer variable.

& operator returns an address of a variable.
* operator dereferences a variable (it provides access to a value that the pointer variable points to).

int n = 10;     //Declare a variable of type int and initialize it with 10
int *ptr;       //Declare a pointer variable.
                //At this point, *ptr does not contain any address yet, 
                //rather some random address or null.
ptr = &n;       //Assign to the pointer ptr an address of the variable n
                //ptr contains now an address of the memory where variable n is located, 
                //not a value 10
int k;          //Declare another variable
k = *ptr;       //Assign k a value that is pointed by ptr

Simple type variables such as int, double, float and so on are passed to the function arguments as values, so the original value is copied, and a copy is presented to the function code (more on functions one can find in the Sub-programs, Functions). Modifications to the argument do not change the original value but just a copy. This is not the case when passing a complex type, such as an array, as an argument. The importance of pointers is not to be underestimated in this case: you simply declare a pointer pointing to the array's first element and pass it to the function. Then modifying the pointer value (an address), it is possible to refer to the following elements of the array. In this case, any modification to the referred array element modifies an original one, so the change in the value is instant. It does not need a return variable from a function.

It is essential to understand that if no statements change the normal program flow, the microcontroller executes instructions one by one in the order they appear in the source code (from the top - to the down direction). Control statements modify normal program flow by skipping or repeating parts of the code. Often to decide if the part of the code should be executed or to choose one of the number of possible execution paths, conditional statements are used. For repeating the part of the code, loop statements can be used.

if is a statement that checks the condition and executes the following statement if the condition is TRUE. There are multiple ways how to write down the if statement:

//1st example
if (condition) statement;     
 
//2nd example
if (condition)
statement;                    
 
//3rd example
if (condition) { statement; } 
 
//4th example
if (condition)
{
  statement;
}                             

The version with curly braces is used when there is a need to execute part of the code that consists of more than a single statement. Many statements taken together with pair of curly braces are treated as a single statement in such cases. When both TRUE and FALSE cases of the condition should be viewed, the else part should be added to the if statement in the following ways:

if (condition) {
  statement1;    //Executes when the condition is true
}
else {
  statement2;    //Executes when the condition is false
}

If more conditions should be viewed, the else if part is added to the if statement:

if (condition1) {
  statement1;    //Executes when the condition1 is true
}
else if (condition2) {
  statement2;    //Executes when the condition2 is true
}
else {
  statement3;    //Executes in all other cases
}

For example, when the x variable is compared and when it is higher than 10, the digitalWrite() method executes.

if (x>10) 
{
  //Statement is executed if the x > 10 expression is true
  digitalWrite(LEDpin, HIGH)  
}

To allow checking different conditions, logical operators are widely used with the condition statement if described above.

Comparison Operators

There are multiple comparison operators used for comparing variables and values. All of these operators compare the variable's value on the left to the value on the right. Comparison operators are the following:

• == (equal to) – if they are equal, the result is TRUE, otherwise FALSE;
• != (not equal to) – if they are not equal, the result is TRUE, otherwise FALSE;
• < (less than) – if the value of the variable on the left is less than the value of the variable on the right, the result is TRUE, otherwise FALSE;
• < = (less than or equal to) – if the value of the variable on the left is less than or equal to the value of the variable on the right, the result is TRUE, otherwise FALSE;
• > (greater than) – if the value of the variable on the left is greater than the value of the variable on the right, the result is TRUE, otherwise FALSE;
• > = (greater than or equal to) – if the value of the variable on the left is greater than or equal to the value of the variable on the right, the result is TRUE, otherwise FALSE.

Examples:

if (x==y){ //Equal
  //Statement
}
 
if (x!=y){ //Not equal
  //Statement
}
 
if (x<y){ //Less than
  //Statement
}
 
if (x<=y){ //Less than or equal
  //statement
}
 
if (x>y){ //Greater than
  //Statement
}
 
if (x>=y){ //Greater than or equal
  //Statement
}

Boolean Operators

The Boolean logical operators in C/C++ are the following:

• ! (logical NOT) – reverses the logical state of the operand. If a condition is TRUE the logical NOT operator will turn it to FALSE and the other way around;
• && (logical AND) – the result is TRUE when both operands on the operator's left and right are TRUE. If even one of them is FALSE the result is FALSE;
• || (logical OR) – the result is TRUE when at least one of the operands on the left and on the right of the operator is TRUE. If both of them are FALSE, the result is FALSE.

Examples:

//Logical NOT
if (!a) { //The statement inside if will execute when the a is FALSE
  b = !a; //The reverse logical value of a is assigned to the variable b
}
 
//Logical AND
//The statement inside if will execute when the 
//Values both of the a and b are TRUE
if (a && b){  
  //Statement
}
 
//Logical OR
//The statement inside if will execute when at least one of the 
//a and b values are TRUE
if (a || b){  
  //Statement
}

A switch statement similar to the if statement controls the flow of a program. The code inside switch is executed in various conditions. A switch statement compares the values of a variable to the specified values in the case statements. Allowed data types of the variable are int and char. The break keyword exits the switch statement.

Examples:

switch (x) { 
   case 0:  //Executes when the value of x is 0
   // statements
   break;   //Goes out of the switch statement
 
   case 1:  //Executes when the value of x is 1
   // statements
   break;   //Goes out of the switch statement
 
   default:  //Executes when none of the cases above is true
   // statements
   break;   //Goes out of the switch statement
}

Check Yourself

1. Which code part is the correct one?

• if(value == 1) digitalWrite(13, HIGH)
• if (value == 1); digitalWrite(13, HIGH)
• if (value == 1) DigitalRead(13,1)

2. What is the output of the next code part?

int x = 0;
 
    switch(x)
    {
 
      case 1: cout << "One";
 
      case 0: cout << "Two";
 
      case 2: cout << "Hello, world!";
 
    }
 

3. In which case should theswitch structure be used?

Loops are critical to control flow structures in programming. They allow executing statements or some part of the program repeatedly to process elements of data tables and texts, making iterative calculations and data analysis. In the world of microcontrollers, where sometimes there is no operating system, the whole software works in the main loop called a super loop. It means the program never ends and works until the power is off. This is clearly visible in the Arduino programming model, with one part of the code executed once after power-on setup() , and another executed repeatedly loop() . In C/C++, there are three loop statements shown in this chapter.

for is a loop statement that allows specifying the number of times of execution statements inside it. Each time all statements in the loop's body are executed is called an iteration. In this way, the loop is one of the basic programming techniques used for all programs and automation in general.

The construction of a for loop is the following:

for (initialization ; condition ; operation with the cycle variable) {
  //The body of the loop
}

Three parts of the for construction are the following:

• initialisation section usually initialises the value of the cycle variable that will be used to iterate the loop; the initialisation value is ofter 0 but can be any other value;
• condition allows managing the number of loop iterations; the statements in the body of the loop are executed when the condition is TRUE;
• operation with the cycle variable specifies how the cycle variable is modified every iteration (incremented, decremented); allows defining the number of loop iterations.

The example of the for loop:

for (int i = 0; i < 4; i = i + 1) 
{
    digitalWrite(13, HIGH); 		
    delay(1000);			
    digitalWrite(13, LOW);			
    delay(1000);	
}

On the initialisation of the for loop, the cycle variable i = 0 is defined. The condition states that the for loop will be executed while the variable i value will be less than 4 (i < 4). In operation with the cycle variable, it is increased by 1 each time when the loop is repeated.

In the example above, Arduino function digitalWrite is used. It sets the logical state high or low at the chosen pin. If a LED is connected to pin 13 of the Arduino board, it will turn on/off four times.

while loop statement is similar to the for statement but does not contain the cycle variable. Because of this, the while loop allows executing a previously unknown number of iterations. The loop management is realised using only condition that needs to be TRUE for the next cycle to execute.

The construction of the while loop is the following:

while (condition is TRUE)
{
  //The body of the loop
}

That way, the while loop can be used as a good instrument for the execution of a previously unpredictable program. For example, if it is necessary to wait until the signal from pin 2 reaches the defined voltage level = 100, the following code can be used:

int inputVariable = analogRead(2);
while (inputVariable < 100)
{
    digitalWrite(13, HIGH); 		
    delay(10);			
    digitalWrite(13, LOW);			
    delay(10);	
    inputVariable = analogRead(2);
}

In the loop above, the LED that is connected to pin 13 of the Arduino board will be turned on/off until the signal reaches the specified level.

The do…while loop works similarly to the while loop. The difference is that in the while loop, the condition is checked before entering the loop, but in the do…while, the condition is checked after the execution of the statements in the loop, and then if the condition is TRUE the loop repeats. As a result, the statements inside the loop will execute at least once, even if the test condition is FALSE.

The construction of a do while loop is the following:

do {
  //The body of the loop
} while (a condition that is TRUE);

If the same code is taken from the while loop example and used in the do…while loop, the difference is that the code will execute at least once, even if the inputVariable value is more than or equal to 100. The example code:

int inputVariable = analogRead(2);
do {
    digitalWrite(13, HIGH); 		
    delay(10);			
    digitalWrite(13, LOW);			
    delay(10);	
    inputVariable = analogRead(2);
} while (inputVariable < 100);

In many cases, the program grows to a size that becomes hardly manageable as a single unit. It is quite difficult to navigate through the code that occupies many screens. In such a situation, subprograms can help. Subprograms are named functions in C, and in C++, while they are associated with an object, they are named methods (in this chapter, the name function will be used). The function contains a set of statements that usually form some logical part of the code that can be separately tested and verified, making the whole program easy to manage. It is possible to group many functions by creating a library that is stored in a separate file. This is how external libraries are created.

Functions are the set of statements that are always executed when the function is called. A function can accept arguments as its input data and return the resulting value. Two functions from the Arduino programming model that were mentioned before are already known – setup() and loop(). The programmer usually tries to make several functions containing all the statements and then calls them in the setup() or loop() functions.

The structure of the function is following:

type functionName(arguments) //A return type, name, and arguments of the function
{
  //The body of a function – statements to execute
}

For example, a function that periodically turns on and off the LED can look like this:

void exampleFunction() 
{
  digitalWrite(13, HIGH); //the LED is ON		
  delay(1000);			
  digitalWrite(13, LOW);  //the LED is OFF				
  delay(1000);	
}

The example above shows that the return type of aexampleFunction function is void, which means the function does not return any value. This function also does not have any arguments because the brackets are empty.

This function should be called inside the loop() function in the following way:

void loop()
{
  exampleFunction(); //the call of the defined function inside loop()
}

The whole code in the Arduino environment looks like this:

void loop()
{
  exampleFunction(); //the call of the defined function inside loop()
}
 
void exampleFunction() 
{
  digitalWrite(13, HIGH); //the LED is ON		
  delay(1000);			
  digitalWrite(13, LOW);  //the LED is OFF				
  delay(1000);	
}

It can be seen that the function is defined outside the loop() or setup() functions.

When some specific result must be returned as a result of a function, then the function return type should be indicated, for example:

//the return type is "int"
int  sumOfTwoNumbers(int x, int y) 
{
    //the value next to the "return" should have the "int" type; 
    //this is what will be returned as a result.
    return (x+y); 
}

In the loop(), this function would be called in the following way:

void loop()
{
  //the call of the defined function inside the loop()
  int result = sumOfTwoNumbers(2, 3); 
}

Every programming SDK, including Arduino IDE, comes with several ready-made functions that help develop applications, significantly reducing the effort and time of writing programs. These functions are written to handle inputs and outputs, process texts, communicate using serial ports, manipulate bits and bytes, and perform mathematical calculations. Refer to Arduino or other SDK documentation for details.

The popularity of microcontrollers and embedded programming caused the growth of communities of enthusiasts who create a vast of useful software. This usually comes in the form of a set of functions created to handle some specific tasks, e.g. interfacing with a family of graphical displays or communicating using the chosen protocol. Functions created for one purpose are grouped together, forming the library. The number of libraries and their different version is so big that software developers use a special library manager to ensure that libraries are up-to-date or keep them in stable versions.

In the MCU world, is is common to use libraries that require a user (software developer) to implement a specific part of the code that is later automatically called by the library routines. Those functions are frequently called handlers and enable developers to inject their actions for a predefined set of activities without needing to modify library code. For this reason, the library contains a placeholder variable that can be assigned an executable code (a function body). Obviously, this is handled with the use of pointers. A sample function handler variable is presented in the following code, along with the user function definition, assignment to the handler variable and a call to the handler:

int (*hUserImplementedFunction)(int);       //Function handler variable 
                                            //(no code is here; it is just a pointer to the code, 
                                            //currently NULL, pointing to "nowhere"
...
int fMulx2(int a) {                         //User's implementation of the function. 
  return (2*a);                             //Multiply the argument 'a' value by 2 and return it to the callee.
  }                                         //Note: argument types and return types must match with the variable above
...
hUserImplementedFunction = fMulx2;          //assign a function to the handler
                                            //starting from now, hUserImplementedFunction contains an address of the 
                                            //fMulx2 function
...
int j;                                      
if (hUserImplementedFunction!=NULL)         //check if the handler is not null to avoid NULL pointer exception and code hang
    j = hUserImplementedFunction(10);        //call a handler, j is 20 now

Structures and classes present complex data types, definable by the developer. Not all C/C++ programming environments provide support for classes (i.e., STM32 in HAL framework mode does not), but luckily, the Arduino framework supports it. Structures, conversely, are part of the C language definition and are present in almost every implementation of software frameworks for IoT microcontrollers.

In C and C++, a structure is a user-defined data type that allows you to combine different types of variables under a single name. A structure primarily groups related variables, forming a complex data type. A custom data structure (type) that can hold multiple variables, each with its own data type. These variables, called members or fields, can be of any built-in or user-defined type, including other structures. The sample named structure (equivalent to the complex type), variable declaration and use of member fields are presented below:

struct address {
  String city;
  String PO;
  String street;
  double longitude;
  double latitude;
};
...
address adr1;

Note it is also possible to declare a structure variable directly without defining a type:

struct {
  String city;
  String PO;
  String street;
  double longitude;
  double latitude;
} adr2, adr3;

Structures with type definitions are common when authoring libraries to let library users be able to declare new variables on their own, simply using a type.

Access to the fields of the structure's member variables (short: members, fields) is possible using the “.” (dot) operator.

adr1.city = "Gliwice";
adr2.city = "Oslo";
adr3.street = "Rodney";

The structure's data can be initialised member by a member or at once using the simplified syntax. Order is meaningful, and types need to fit the definition (C++ only):

adr3 = {"Liverpool", "L1 9EX", "27 Rodney", -2.973083901947872, 53.401615049766406 };

In C++, structures can also have member functions that manipulate the data (in C, they cannot). That is not so far from the Classes idea described in the following chapter. In the case of using C (or poor implementation of C++ that does not support classes nor member functions, i.e. STM32), it is common to prepare a set of data handling functions that operate on the structure referenced with a pointer. A common rule of thumb is the structure is the first argument in the function:

struct calcdata
{ 
  double x,y;
} args;
 
//Adds x and y of the "arguments" structure
double fCalcDataAdd(calcdata *arguments){
  return (arguments->x + arguments->y);
}
//Multilies x and y of the "arguments" structure
double fCalcDataMul(calcdata *arguments){
  return ((arguments->x)*(arguments->y));
}
//Sets x and y of the "arguments" structure
void fCalcDataSet(calcdata *arguments, double px, double py){
  arguments->x = px;
  arguments->y = py;
}

In the examples above, we use a “→” dereference operator to access the member fields by using the pointer to the structure rather than the structure itself.

Sample use of the functions is then:

args = {2,7};                //initialise structure x=2, y=7
fCalcDataSet(&args, 12,12);  //reinitialise structure x=12, y=12
int z = fCalcDataAdd(&args); //z equals to 24 now

Classes were introduced in C++ to extend structures encapsulating data and methods (functions) to process this data. A method presented above in the structure context brings an overhead with a need to pass a pointer to the structure for each call. Moreover, it makes access levels tricky, i.e. when you do not want to expose some functions but rather use them for internal data processing. Thus classes can be considered as an extension of the structures.

Sample class definition is presented below:

class Calculator
{
  public: //you can access this part
  int x,y;
    Calculator() {  //Default constructor
      clear();
    }
    Calculator(int px, int py) { //Another constructor
      x=px; 
      y=py;
    }
    ~Calculator(){} //This is dummy destructor
    int Add(){ return x+y; }
    int Mul(){ return x*y; }
    void setX(int px){ x=px; }
    void setY(int py){ y=py; }
  private: //that part is private, and you cannot access it      
    void clear(){
      x=0; y=0;
    }
};

The code above declares a new type, Calculator, with member fields (members in short) x and y and methods (functions) Calculator, Add, Mul, setX and setY. Some are marked as private: and accessible only from the code of the functions (methods) within the class; some are exposed to external users when marked as public:.
Constructors
There are “special” functions whose name is equivalent to the class name in this example above. Those are called constructors and are executed once the object of the class type is instantiated:

Calculator calc1=Calculator(2,15);

The above code instantiates an object calc1 of the class Calculator and calls the constructor explicitly Calculator(int px, int py). The other constructor, Calculator(), is the default one, and if not explicitly called by the code developer, it is automatically called when the object is instantiated.
There can be multiple constructors, and the one executed is selected based on the arguments set.
Destructor
A destructor is called automatically when an object's lifetime is to end. It allows, i.e. to release resources, disconnect open connections, and, in general, do some cleanup before the object is gone. The destructor function in the example above does nothing and is not obligatory in the code. Destructor name starts with a ~ sign (tilde) and has the same name as a class (or constructor):

~Calculator(){} //This is dummy destructor

Members
Member fields can be of any type. When marked as private they are accessible only from the code of the constructors, destructor and methods within the class. When public, one can reference them using a “.” (dot) operator, as in the case of the structures. When using a pointer to the class instance (object) rather than an instance itself (quite common), a “→” operator works as in the case of structures.
Methods
A method can have any name other than reserved (i.e. for constructors and destructor). Methods marked as public are available for the object user and are referenced similarly to member fields (“.” and “→” operators). private methods are not exposed externally; their purpose is to be called from another method internally. Sample use of methods is presented below:

  //continuing initialisation above: calc1.x=2, calc1.y=15 
  int z = calc1.Add(); //z=17
  calc1.setX(10);      //calc1.x=10
  calc1.setY(20);      //calc1.y=20
  z = calc1.Mul();     //z=200

Class inheritance
Classes can be inherited. This mechanism enables the real power of C++, where existing models (classes) can be extended with new logic without a need to rewrite and fork existing source code. In the example above, the Calculator class misses some features, such as i.e. subtracting. A code below defines a new type BetterCalculator that inherits from the Calculator class, using “:” operator:

class BetterCalculator:public Calculator
{
  public:
    BetterCalculator() {
    }
    BetterCalculator(int px, int py):Calculator(px,py) {
    }
    int Sub(){return x-y;}
};

Members x and y are in the Calculator class. Inheritance before C++ release 11 requires explicit constructor definitions, as in the example above. We use public inheritance to give access to all public methods in the base Calculator class available from within the level of the BetterCalculator class. Note the public keyword in the class definition: class BetterCalculator:public Calculator.
Instantiation and use are similar to the presented ones in the previous examples:

  BetterCalculator calc2=BetterCalculator(10,6); //BetterCalculator->Calculator->x=10, y=6
  ...
  z = calc2.Sub(); //z=4
  z = calc2.Add(); //z=16 - you can use the underlying code in the Calculator 
                   //class without a need to rewrite it again

The description above does not deplete all features of C++ Object Oriented Programming. Please note, however, that in the case of the embedded C++, their implementation can be limited and may not contain all the features of the modern, standard C++ patterns.

A special note on the libraries with separate definition (header) and implementation (body)
Many libraries come with a class definition in the header file (.h) and its implementation in the code file (.cpp). This is convenient for separating use patterns and implementations. A special operator, “::” (double colon), is used in the implementation to refer the code to the definition in the header file.
The sample header file myclass.h with the aforementioned Calculator class is present below. It contains only the class definition but does not contain any implementing code.

#ifndef h_MYCLASS
#define h_MYCLASS
class Calculator{
  public: //you can access this part
  int x,y;
    Calculator();  //Default constructor
    Calculator(int px, int py); //Another constructor
    ~Calculator(); //This is dummy destructor
    int Add();
    int Mul();
    void setX(int px);
    void setY(int py);
  private: //that part is private, and you cannot access it      
    void clear();
};
#endif

The implementation code refers to the class definition in the header:

#include "myclass.h"
 
Calculator::Calculator() {}
Calculator::Calculator(int px, int py) { x=px; y=py; }
Calculator::~Calculator(){}
int Calculator::Add(){ return x+y;}
int Calculator::Mul(){ return x*y; }
void Calculator::setX(int px){ x=px; }
void Calculator::setY(int py){ y=py; }
void Calculator::clear(){ x=0; y=0; }

Writing code that handles interrupts that come from internal peripherals, for example, timers, is possible but depends strongly on the hardware. Because this chapter presents just an introduction to programming, some essential timing functions will be shown.

The simplest solution to make functions work for a particular time is to use the delay() ^[37] function. delay() function halts program execution for the time specified as the argument (in milliseconds).

The blinking LED code is a simple demonstration of delay functionality:

  digitalWrite(LED_BUILTIN, HIGH);   //Turn the LED on 
  delay(1000);                       //Stop program for a second
  digitalWrite(LED_BUILTIN, LOW);    //Turn the LED off 
  delay(1000);                       //Stop program for a second

Using delay() is convenient but has a severe drawback: the algorithm is halted, and only interrupts (or tasks in the background) are executed. The main algorithm is present in the figure 11. Some of the tasks, like, i.e. receiving serial transmissions, networking, and outputting set PWM values, continue to work as background tasks, using interrupts or task management (such as FreeRTOS).

The alternative to using delay is to switch to the non-blocking method, based on timing with the use of millis() as presented below.

millis() ^[38] returns the number in milliseconds since MCU began running the current program. Note it has nothing to do with a real-time clock, as most microcontrollers and development boards simply do not have one. The readings are 32-bit and will roll over in approximately 49 days. millis() can be used to replace delay() but needs some additional coding. Instead of blocking the algorithm, here we check if the desired time has passed. Meanwhile, we can handle other tasks instead of blocking execution, as presented in the algorithm in figure 12.

Here is an example code of blinking LED using millis(). Millis is used as a timer. Every new cycle time is calculated since the last LED state change. If the time passed is equal to or greater than the threshold value, the LED is switched:

//Unsigned long should be used to store time values as the millis() returns a 32-bit unsigned number
//Store value of current millis reading
unsigned long currentTime = 0; 
//Store value of time when last time the LED state was switched
unsigned long previousTime = 0; 
 
bool ledState = LOW; //Variable for setting LED state
 
const int stateChangeTime = 1000; //Time at which switch LED states
 
void setup() {
  pinMode (LED_BUILTIN, OUTPUT); //LED setup
}
 
void loop() {
  currentTime = millis(); //Read and store current time
 
  //Calculate passed time since the last state change
  //If more time has passed than stateChangeTime, change the state of the LED
  if (currentTime - previousTime >= stateChangeTime) { 
 
    previousTime = currentTime; //Store new LED state change time
    ledState = !ledState; //Change LED state to oposite
    digitalWrite(LED_BUILTIN, ledState); //Write current state to LED
  }
}

Some IoT-dedicated microcontrollers have special features such as sleep modes that hold program execution for a predefined time or unless an external trigger occurs. This can be used for periodic, time-based activities. Its side effect is energy efficiency. The model of this behaviour and its features are very vendor-specific and vary much: i.e. Espressif MCUs have the only option to restart the code. At the same time, STM32 can hold execution and then continue. Because of the variety of models, modes and features, we do not present here any specific solution but rather a general idea.

/data01/virt87891/domeenid/www.robolabor.ee/htdocs/homelab/data/pages/en/iot-open/introductiontoembeddedprogramming2/cppfundamentals/digital_IO.txt— MISSING PAGE — /data01/virt87891/domeenid/www.robolabor.ee/htdocs/homelab/data/pages/en/iot-open/introductiontoembeddedprogramming2/cppfundamentals/analog_IO.txt— MISSING PAGE —

Interrupt is a signal that stops the normal execution of a program in the processor and starts the function assigned to a specific source of it. Such a function usually is called Interrupt Service Routine (ISR) or interrupt handler. The ISR can be recognized as a task with higher priority than the main program. Interrupt signals can be generated by the external source, like a change of value on the pin, and by the internal source, like a timer or any other peripheral device. When the interrupt signal is received, the processor stops executing the code and starts the ISR. After completing the interrupt handler, the processor returns to the normal program execution state.

ISR should be as short as possible; good practice is avoiding delays and long code sequences. Suppose there is a need to trigger the execution of a long part of the code with an incoming interrupt signal. In that case, the good practice is to define the synchronization variable, modify this variable in the ISR with a single instruction, and handle all other steps in the main program. The interrupt handler does not have arguments and does not return any value, so its type is void. To ensure fast execution of the programs, some of the Arduino functions do not work or behave differently in the ISR; for example, the delay() function does not work inside the ISR. Variables used in the ISR must be declared as volatile.

Interrupts are used to detect important real-time events which occur during normal code execution of the code. ISR is executed only when there is a need to do it.

Interrupts can help in efficient data transmission. Using interrupts and checking if some situation occurred periodically is unnecessary. Such continuous checking is named polling. For example, a serial port interrupt is executed only when new data comes without polling the incoming buffer in a loop. This approach saves the processor time and, in many situations, creates code that is more energy efficient.

Because interrupts need support from the hardware layer of the microcontroller, the availability of specific interrupt sources depends heavily on the microcontroller model. For example, different Arduino models have different external interrupt pin availability. In most Arduino boards, pins numbered 2 and 3 can be used for interrupts; in Arduino Uno, only these two, while in ESP32 and STM32, almost any digital pin is valid.

Very often, interrupts are used together with hardware timers to generate stable frequency signals. It ensures accurate timing independent of the main loop content and delays. Because internal peripherals are very different for different microcontrollers in this chapter, the example for the external interrupt is shown.

The function attachInterrupt(digitalPinToInterrupt(pin), ISR, mode) is called to attach an interrupt to the handler. This function has 3 arguments.

1. pin – the pin number where the interrupt signal-generating device will be attached.
2. ISR – the name of an ISR function.
3. mode – defines when an interrupt signal is triggered. There are five basic mode values:
   • LOW – interrupt is triggered when the pin value is LOW,
   • HIGH – interrupt is triggered when the pin value is HIGH,
   • RISING – interrupt is triggered when the pin value is changed from LOW to HIGH,
   • FALLING – interrupt is triggered when the pin value is changed from HIGH to LOW,
   • CHANGE – interrupt is triggered when the pin value is changed in any direction.

The example program that uses external interrupt:

volatile bool button_toggle = 0; //A variable to pass the information from ISR to the main program
 
void setup() {
  //Define LED pin
  pinMode(13,OUTPUT);       
  //Define button pin
  pinMode(2,INPUT_PULLUP);  
  //Attach interrupt to button pin
  attachInterrupt(digitalPinToInterrupt(2),ButtonIRS,FALLING); 
}
 
void ButtonIRS() {  //IRS function
  button_toggle =!button_toggle;
}
 
void loop() {
  digitalWrite (13,button_toggle);
}

In this example, the code needed to handle the interrupt signal is just one instruction. Still, it shows how to use the synchronization variable to pass information from ISR to the main program keeping the ISR very short.

This chapter presents some programming templates and fragments of the code that are common in embedded systems. Some of those patterns, such as i.e. non-blocking algorithms, which do not use delay(x) to hold program execution but use a timer-based approach instead. It has also been discussed in other chapters, such as in the context of timers Timing or interrupts Interrupts.

Almost any MCU has a hardware debugging capability. This technique is complex and usually requires an external debugger such as JTAG. Setting up hardware and software for simple projects may not be worth a penny; thus, the most frequent case is tracing over debugging. Tracing uses a technique where the Developer explicitly sends some data to the external device (usually a terminal, over a serial port, and eventually a display) that visualises it. The Developer then knows the variables' values and how the algorithm runs. The use of the serial port is common because this is the one that is most frequently used for programming. Thus, it can be used in reverse for tracing. For this reason, Arduino Framework implements a singleton object Serial present in every code. It is implemented by each Arduino Framework vendor at the level of the general library with Arduino Framework.
Note to use a Serial it is obligatory to initialise it with the use of the Serial.begin(x) method, providing the correct bps, where x is a transmission speed (rate) that suits the rate configured in the terminal. The most common rates are 9600 (default) and 115200, but other options are possible. On the terminal side, configuration is usually done in the menu or a configuration file, such as in the case of the platformio.ini file. Calling Serial.begin(x) is usually done as one of the first actions implemented in the Setup() function of the application code:

void setup(){
  delay(100);
  Serial.begin(115200);
  Serial.println();
  ...
}

The Serial object has a number of handy methods that can help represent various variable types in a textual form to be sent via a serial port to the terminal. The most common are:

• Serial.print(x) where x is any simple type available in the Arduino Framework, such as integers and floats, but also visualises arrays of characters and String objects.
• Serial.println(x) prints as above but additionally adds the end of line/newline character by the end of the transmission. Note that the Linux style is used in Arduino, so only ASCII 13 character is sent.

The serial port and a class Serial handling the communication are bi-directional. It means that you can send a message from MCU to the terminal and the opposite. This can be used as a simple user interface. All aforementioned configuration steps to ensure seamless cooperation of the MCU serial interface and terminal (application) are also in charge here. As data is streamed byte by byte, it is usually necessary to buffer it. Technically, the serial port notifies MCU every time a character comes to the serial port with the use of the interrupts. Luckily part of the job is done by the Serial class: all characters are buffered in an internal buffer, and one can check their availability using Serial.available(). This function returns the number of bytes received so far from the external device (here, i.e. a terminal) connected to the corresponding serial port.

Data in the serial port are sent as bytes; thus, it is up to the developer to handle the correct data conversion. Reading a single byte of the data is done using Serial.read(): it gets another character from the FIFO queue that stands behind the serial port software buffer. As most of the communication is done textual way, the Serial class has support to ease the reading of the strings: Serial.readString(), but use involves some extra logic such as the function may timeout. Also, it may contain the END-OF-LINE / NEXT-LINE characters that should be trimmed before use ^[39].

Hardware buttons tend to vibrate when switching. This physical effect causes bouncing of the state forth and back, generating, in fact, a number of pulses instead of a single edge during switching. Getting rid of this is called debouncing. In most cases, switches (buttons) short to 0 (GND) and use pull-up resistors, as in the figure 13.

The switch, when open, results in VCC through R1 driving the GPIO2 (referenced as HIGH), and when short, 0 is connected to it, so it becomes LOW:

• button short → GPIO2=LOW
• button released → GPIO2=HIGH

Some MCUs offer internal pull-ups and pull-downs, configurable from the software level. The transition state between HIGH and LOW causes bouncing.

A dummy debouncing mechanism only checks periodically for a press/release of the button. The common period for debouncing is between 50ms and 200ms. The code below shows an example that has been provided for presentation purposes. Yet, it is not flexible nor pragmatic due to the exhausting use of the loop() function and extensive use of delay(). An internal pull-up resistor is in use in this example:

#define BUTTON_GPIO 2
 
bool bButtonPressed=false;
 
void setup() {
  Serial.begin(9600);
  pinMode(BUTTON_GPIO, INPUT_PULLUP);
}
 
void loop() {
  if (digitalRead(BUTTON_GPIO)==LOW && !bButtonPressed)
  {
    Serial.println("Button pressed");
    delay(200);
    bButtonPressed=true;
  }
  if (bButtonPressed && digitalRead(BUTTON_GPIO)==HIGH)
  {
    Serial.println("Button released");
    bButtonPressed=false;
    delay(200);
  }
}

A more advanced technique for complex handling of the buttons is presented below in the context of the State Machines.

A Finite State Machine (FSM) idea represents states and flow conditions between the states that reflect how the software is built for the selected system or its component. An example of button handling with the use of the FSM is present here. The FSM reflects the physical state of the device, sensor or system on the software level, becoming a digital twin of a real device.

For the simple case (without detecting double-click or long press), 3 different button states can be distinguished: released, debouncing and pushed. An enumerator is a good choice to model those states (it is easily expandable):

typedef enum {
  RELEASED = 0,
  DEBOUNCING,
  PRESSED
} tButtonState;

A flow between the states can be then described in the following diagram (figure 14).

• In the RELEASED state, there is waiting until the button is pressed (LOW, for the pull-up model). The time is noted when it occurs, and the state changes to the DEBOUNCING.
• In the DEBOUNCING state, if debouncing time passes and the button is still pressed (LOW) machine changes its state to PRESSED. If the button in DEBOUNCING becomes released (HIGH), then the machine returns to the state RELEASED.
• In the PRESSED state, it transits to the RELEASED whenever the button goes HIGH.

The state machine is implemented as a simple class and has 2 additional fields that store handlers for functions that are called when the state machine enters PRESSED or RELEASED. Those functions are called callbacks. There are 2 public functions for callback registration as callback handlers class members are private. fButtonAction() is intended to be called in a loop(), as many times as possible to “catch” all pushes of the button:

class PullUpButtonHandler{
  private:
    tButtonState buttonState=RELEASED;
    uint8_t ButtonPin;
    unsigned long tDebounceTime;
    unsigned long DTmr;
    void(*ButtonPressed)(void);       //On button pressed callback
    void(*ButtonReleased)(void);      //On button relased callback
    void btReleasedAction() {         //Action to be done when current state is RELEASED
      if(digitalRead(ButtonPin)==LOW) {
        buttonState = DEBOUNCING;
        DTmr = millis();
      }
    }
    void btDebouncingAction() {       //Action to be done when current state is DEBOUNCING
      if(millis()-DTmr > tDebounceTime)
        if(digitalRead(ButtonPin)==LOW) {
          buttonState = PRESSED;
          if(ButtonPressed!=NULL) ButtonPressed();
        }
        else
          buttonState=RELEASED;
    }
    void btPressedAction() {          //Action to be done when current state is PRESSED
      if(digitalRead(ButtonPin)==HIGH) {
        buttonState=RELEASED;
        if(ButtonReleased!=NULL) ButtonReleased();
      }
    }
  public:
    PullUpButtonHandler(uint8_t pButtonPin, unsigned long pDebounceTime) {  //Constructor
      ButtonPin = pButtonPin;
      tDebounceTime = pDebounceTime;
    }
    void fRegisterBtPressCalback(void (*Callback)()) {    //Function registering a On PRESSED callback
      ButtonPressed = Callback;
    }
    void fRegisterBtReleaseCalback(void (*Callback)()) {  //Function registering a On RELEASED callback
      ButtonReleased = Callback;
    }
    void fButtonAction()  //Main, non blocking loop. Handles state machine logic 
    {                     //along with private functions above
      switch(buttonState) {
        case RELEASED: btReleasedAction();
          break;
        case DEBOUNCING: btDebouncingAction();
          break;
        case PRESSED: btPressedAction();
          break;
        default:
          break;
      }
    }
};

Sample use looks as follows:

#define BUTTON_GPIO 2
 
PullUpButtonHandler bh = PullUpButtonHandler(BUTTON_GPIO, 200);
void onButtonPressed() {
  Serial.println("Button pressed");
}
void onButtonReleased() {
  Serial.println("Released");
}
void setup() {
  Serial.begin(9600);
  pinMode(BUTTON_GPIO, INPUT_PULLUP);
  bh.fRegisterBtPressCalback(onButtonPressed);
  bh.fRegisterBtReleaseCalback(onButtonReleased);
}
 
void loop() {
  bh.fButtonAction();
}

The great feature of this FSM is that it can be easily extended with new functions, such as i.e. detection of the double click or long button press.

Some generic programming techniques and patterns mentioned above require adaptation for different hardware platforms. It may occur whenever hardware-related aspects are in charge, i.e., accessing GPIOs, ADC conversion, timers, interrupts, multitasking (task scheduling and management), multicore management, power saving extensions and most of all, integrated communication capabilities (if any). It can be different for almost every single MCU or MCU family.
It is common for hardware vendors to provide rich examples, either in the form of documentation and downloadable samples (i.e. STM) or via Github (Espressif), presenting specific C/C++ code for microcontrollers.

Some MCUs use specific setups. Analogue input may work out of the box. Still, low-level control usually brings better results and higher flexibility (i.e. instead of changing the input voltage to reflect the whole measurement range, you can regulate internal amplification and sensitivity.

Please note implementation varies even between the ESP32 chips family, and not all chips provide all of the functions, so it is essential to refer to the technical documentation ^[40].

ESP32 has 15 channels exposed (18 total) of the up to 12-bit resolution ADCs. Reading the raw data (12-bit resolution is the default, 8 samples per measure as default) using the analogRead() function is easy.
Technically, under the hood on the hardware level, there are two ADCs (ADC1 and ADC2). ADC 1 uses GPIOs 32 through 39. ADC2 GPIOs 0,2,4, 12-15 and 25-27. Note that ADC2 is used for WiFi, so you cannot use it when WiFi communication is enabled.
Just execute analogRead(GPIO).
Several useful functions are here (not limited to):

• analogReadResolution(res) - where res is a value between 9 and 12 (default 12). For 9-bit resolution, you get 0..511 values; for 12-bit resolution, it is 0..4095 respectively.
• analogSetCycles(ccl) - where ccl is number of cycles per ADC sample. The default is 8: the valid number is between 1 and 255.
• analogSetClockDiv(divider) - sets base clock divider for the ADC. That has an impact on the speed of conversion.
• analogSetAttenuation(a) and analogSetPinAttenuation(GPIO, a) - sets input attenuation (for all channels or selected channels). The default is ADC_11db. This parameter reflects the dynamic scaling of the input value:
  • ADC_0db - no attenuation (1V on input = 1088 reading on ADC), so full scale is 0..1.1V,
  • ADC_2_5db - 1.34 (1V on input = 2086 reading on ADC), so full scale is 0..1.5V,
  • ADC_6db - 1.5 (1V on input = 2975 reading on ADC), so full scale is 0..2.2V,
  • ADC_11db - 3.6 (1V on input = 3959 reading on ADC), so full scale is 0..3.9V.

PWM frequently controls analogue-style, efficient voltage on the GPIO pin. Instead of using a resistance driver, PWM uses pulses to change the adequate power delivered to the actuator. It applies to motors, LEDs, bulbs, heaters and indirectly to the servos (but that works another way).

The classical analogWrite method, known from Arduino (Uno, Mega) and ESP8266, does not work for ESP32.
ESP32 has up to sixteen (0 to 15) PWM channels (controllers) that can be freely bound to any of the regular GPIOs.
The exact number of PWM channels depends on the family member of the ESP chips, i.e. ESP32-S2 and S3 series have only 8 independent PWM channels while ESP32-C3 has only 6. In the Arduino software framework for ESP32, it is referred to as ledc. ESP32 can use various resolutions of the PWM, from 1 to 20 bits, while regular Arduino uses only 8-bit one. Note - there is a strict relation between resolution and frequency: i.e. with high PWM frequency, you cannot go with a resolution too high as the internal frequency of the ESP32 chip is limited.

To use PWM in ESP32, one must perform the following steps:

• configure GPIO pin as OUTPUT,
• initiate PWM controller by fixing PWM frequency and resolution,
• bind the controller to the GPIO pin,
• write to the controller (not to the PIN!) providing a duty cycle related to the resolution selected above - every call persistently sets the PWM duty cycle until the next call to the function setting duty cycle.

More information and detailed references can be found in the technical documentation for the ESP32 chips family ^[41].

Sample code controlling an LED on GPIO 26 with 5kHz frequency and 8-bit resolution is presented below:

#include "Arduino.h"
 
...
 
#define RGBLED_R 26
#define PWM1_Ch   5
#define PWM_Res   8
#define PWM_Freq  5000
 
...
 
ledcSetup(PWM1_Ch, PWM_Freq, PWM_Res); //Instantiate timer-based PWM -> PWM channel
ledcAttachPin(RGBLED_R, PWM1_Ch); //Bind a PWM channel to the GPIO
ledcWrite(PWM1_Ch,255); //Full on: control via the PWM channel, not via the GPIO
...

This technique can be easily adapted to control, e.g. standard and digital servos. PWM signal specification to control servos is presented in the chapter hardware actuators.

Arduino boards used to have a limited set of GPIOs to trigger interrupts. In other MCUs, it is a rule of thumb that almost all GPIOs (but those used, i.e. for external SPI flash) can trigger an interrupt; thus, there is much higher flexibility in, i.e., the use of user interface devices such as buttons.

Suppose the interrupt routine (function handler) uses any variables or access flash memory. In that case, it is necessary to use some tagging of the ISR function because of the specific, low-level memory management. A use of IRAM_ATTR is necessary (part of the code present in Interrupts:

void IRAM_ATTR ButtonIRS() {  //IRS function
  button_toggle =!button_toggle;
}

The number of hardware timers, their features, and specific configuration is per MCU. Even single MCU families have different numbers of timers, i.e., in the case of the STM32 chips, the ESP32, and many others. Those differences, unfortunately, also affect Arduino Framework as there is no uniform HAL (Hardware Abstraction Layer) for all MCUs so far.

The number of hardware timers varies between family members. Most ESP32s have 4, but ESP32-C3 has only two ^[42]. A timer is usually running at some high speed. The most common is 80MHz and requires a prescaller to be useful. Timers periodically call an interrupt (a handler) written by the developer and bound to the timer during the configuration. Because interrupt routines can run asynchronously to the main code and, most of all, because ESP32s (most) are double core, it is necessary to take care of the deadlocks that can appear during the parallel access to the shared memory values, such as service flags, counters etc.
Special techniques using the critical section, muxes and semaphores are needed when more than one routine writes to the shared variable between processes (usually main code and an interrupt handler). However, It is unnecessary in the scenario where the interrupt handler writes to the variable and some other code (i.e. in the loop() section reads it without writing, as in the case of the example presented below.
In this example, the base clock for the timer in the ESP32 chip is 80MHz, and the timer (tHBT - short from Hear Beat Timer) runs at the 1MHz speed (PRESCALLER is 80) and counts up to 2 000 000. So, the interrupt handler is effectively called once every 2 seconds. This code runs separate from the loop() function, asynchronously calling the onHBT() interrupt handler.
onHBT() interrupt handler swaps the boolean value every two seconds. The value then is translated by the main loop() code to drive an LED on the ESP32 development board (here it is GPIO 0), switching it on and off. The onHBT() handler function could directly drive the GPIO to turn the LED on and off. Still, we present a more complex example with a volatile variable LEDOn just for education purposes.

#include "esp32-hal-timer.h"
 
#define LED_GPIO 0      //RED LED on GPIO 0 - vendor-specific
#define PRESCALLER 80   //80MHz->1MHz
#define COUNTER 2000000 //2 million us = 2s
 
volatile bool LEDOn = false;
hw_timer_t *tHBT = NULL; //Heart Beat Timer
 
void IRAM_ATTR onHBT(){  //Heart Beat Timer interrupt handler
  LEDOn = !LEDOn;        //Change true to false and opposite; every call
}
 
void setup() {
  Serial.begin(9600);
  pinMode(LED_GPIO, OUTPUT);
 
  tHBT = timerBegin(0, PRESCALLER, true);  //Instantiate a timer 0 (first)
  // Most ESP32s (but ESP32-C3) have 4 timers (0-3), and ESP32-C3 has only two (0-1).
  if (tHBT==NULL) //Check timer is created OK, NULL otherwise
  {
    Serial.println("Timer creation error! Rebooting...");
    delay(1000);
    ESP.restart();
  }
  timerAttachInterrupt(tHBT, &onHBT, true); //Attach interrupt to the timer
  timerAlarmWrite(tHBT, COUNTER, true);     //Configure to run every 2s (2000000us) and repeat forever
  timerAlarmEnable(tHBT);
 
}
//Loop function only reads LEDOn value and updates GPIO accordingly
void loop() {
  digitalWrite(LED_GPIO, LEDOn);
}

Timers can also be used to implement a Watchdog. Regarding the example above, it is usually a “one-time” triggered action instead of a periodic one. All one needs to do is to change the last parameter of the timerAlarmWrite function from true to false.

Several programming models for IoT script programming are available. Depending on the hardware model used (SoC or OS-based MCU), it may involve single script execution (e.g. Raspberry Pi Pico RP2040, Edge-class IoT) or multithreaded, parallel, multiple scripts, doing multiple tasks (e.g. Raspberry Pi 4, Fog-class IoT). The idea and model of the scripting programming for SoC class devices (edge) were presented in the chapter Script Programming with Middleware.
In the case of far more powerful, Fog-class IoT devices that are OS-based devices, a variety of programming languages and, thus, scripting interpreters are available.

Among others, the most common scripting languages for fog class devices are :

• Bash scripting (OS command scripting) usually does not provide support for the GPIO, intended to automate OS tasks;
• Python scripting, cross-platform for both Edge-class devices (Micrpython) and Fog-class (regular Python, usually run on Linux);
• C#, limited to the Windows IoT for Raspberry Pi;

As Bash scripting is well covered by many manuals for Linux, in the following chapters, we focus on two others: Python and C#. Moreover, accessing the GPIO in the case of the bash requires installing external tools; thus, it does not apply to IoT programming straightforwardly but rather as a supplementary tool to automate tasks other than core programming.

Python programming for IoT devices is dual:

• Python Fundamentals for IoT Regular Python interpreter can be used in Fog class devices such as Raspberry Pi and its clones. In this case, the Python interpreter is run as a separate process in the Linux OS, the same way as in regular PC computers. It has full access to the GPIO, however.
• Micropython Micropython is dedicated to SoCs and is distributed as the firmware that must be flashed into the device. It is common that Micropython exposes serial communication on dedicated pins, exposing a Python console that looks similar to the command line Python interface in the PCs

csharpfundamentals When writing this publication, the .NET framework with C# interpreter is available only for Raspberry Pi devices as a part of the Windows IoT operating system ^[43].

[pczekalski]Add existing pages with C# and Python for RPI [pczekalski]Author a course on Micropython

A program in Python is stored in text files on the device's file system, as Python's source code is interpreted, not compiled, opposite to C++. A typical file extension for programs in Python is .py. In the context of IoT programming, both Python and Micropython share the same syntax and mostly the same libraries, so source code, in many cases, is portable. General hardware-related libraries like GPIO handling or timers are shared between those two Python worlds, and hardware-specific differences are minor compared to the Arduino framework.
Python is simple and efficient in programming the not-so-complex IoT algorithms but does not offer the level of control needed in real-time applications. It can be easily used for prototyping, testing hardware and implementing simple tasks.

Nowadays, Python interpreter usually comes with OS (Linux) preinstalled. The sample installation procedure for Raspbian OS is presented in the manual maintained by the Raspberry Pi manufacturer ^[44]. In the case of the popular Raspbian or Ubuntu for Raspberry Pi, there are usually 2 versions of Pythons preinstalled: Python 2 and Python 3, because of the historical differences between implementations. Many OS applications are written in Python.
Python version can be started from the terminal simply by calling:

~$ python --version
Python 3.8.10

In the case one needs to use a specific version, you can start the interpreter explicitly referring to Python 2 or Python 3:

~$ python2
Python 2.7.18 (default, Jul 29 2022, 09:29:52) 
[GCC 9.4.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> quit()
 
~$ python3
Python 3.8.10 (default, May 26 2023, 14:05:08) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> quit()

Python can be executed via a desktop graphical interface (in the graphical terminal), in a text-based Linux installation via terminal, or remotely via ssh. As it is possible to write applications with visual GUI, starting them in a non-graphical installation of the Linux OS will throw an error. To execute a Python script (program), one needs to execute the following:

~$ python mypythoniotapp.py

Linux, Windows and Mac systems used to bind a .py file extension with a default Python interpreter, so it is possible to run Python script directly, either with the use of file manager or execute it from the command line:

~$ ./mypythoniotapp.py

In the following chapters, we present Python coding elements that are specific to the microcontrollers. A full Python course is beyond the scope of this publication, but it can be easily obtained online (links presented by the end of the chapter).

A dozen of IDEs can be used to program in Python. The most common are:

• IDLE Editor, formerly delivered with Raspbian OS in the bundle, requires GUI. It is currently obsolete but still popular among hobbyists.
• Thonny Python IDE, which comes with Raspbian OS, recently took over IDLE.
• Visual Studio Code with plugins for Python, common with Arduino framework and easily integrates remote Python development - it provides two development scenarios: local on the IoT device (Raspberry Pi, requires GUI) and remote from the PC to the IoT device, that works with headless Raspberry Pi OSes installations.
• PyCharm Community Edition requires additional installation ^[45] and requires GUI.
• Simple code can be authored in the terminal using any text editor (i.e. Nano), as Python source files do not require compilation and are plain text ones. This is not very convenient, but it can help if no dedicated IDE and GUI are available, e.g., for rapid work remotely.

The following subchapters present some IoT and embedded systems-specific Python programming and a very basic introduction:

• First Program in Python
• Python Types and Variables
• Python Flow Control Structures
• Python Loops
• Python Structural Programming
• Hardware Specific Python

For in-depth Python courses and more, follow the links:

1. The Python syntax and semantics: Python Semantics.
2. The Python Package Index (PyPi): PyPi.
3. The Python Standard Library:PSL.
4. Free online Python course: learnpython.org.

[pczekalski][✓ pczekalski, 2023-08-26] Port info from the old manuals subpages in the namespace

[pczekalski]Add a simple app in Python. Check if Micropython has printing support over serial for tracing

Python aims to be consistent and straightforward in the design of its syntax. The best advantage of this language is that it can dynamically set the variable types depending on values types which are set for variables.

Python has a wide range of data types, like many simple programming languages:

• number,
• string,
• list,
• tuple
• dictionary.

Standard Python methods are used to create the numbers:

var = 1234     #Creates Integer number assignment
var = 'George' #Creates String type var

Python can automatically convert types of the number from one type to another. Type can be also defined explicitly.

int a = 10
long a = 123L
float a = 12.34
complex a = 3.23J
<code>
 
==String==
To define Strings use eclosing characters in quotes. 
Python uses single quotes ', double " and triple """ to denote strings.
<code Python>
Name = "George'
lastName = "Smith"
message = """this is the string message which is spanning across multiple lines."""

List contains a series of values. To declare list variables uses brackets [].

A = [] #Blank list variable
B = [1, 2, 3] #List with 3 numbers
C = [1, 'aa', 3] #List with different types

List are zero-based indexed. Data can be assigned to a specific element of the list using an index into the list.

mylist[0] = 'sasa'
mylist[1] = 'wawa'
 
print mylist[1]

List aren't limited to a single dimension.

myTable = [[],[]]

In two-dimensional array the first number is always the rows number, when the second is the columns number.

Python Tuples are defined as a group of values like a list and can be processed in similar ways. When assigned Tuples got the fixed size. In Python, the fixed size is immutable. The lists are dynamic and mutable. To define Tuples, parenthesis () must be used.

TestSet = ('Piotr', 'Jan', 'Adam')

To define the Dictionaries in the Python the lists of key–value pairs are used. This datatype is used to hold related information that can be associated through Keys. The Dictionary is used to extract a value based on the key name. Lists use the index numbers to access its members when dictionaries use a key. Dictionaries generally are used to sort, iterate and compare data.

To define the Dictionaries the braces ({}) are used with pairs separated by a comma (,) and the key values associated with a colon (:). Dictionaries Keys must be unique.

box_nbr = {'Alan': 111, 'John': 222}
box_nbr['Alan'] = 222     #Set the associated 'Alan' key to value 222'
print (box nbr['John'])   #Print the 'John' key value
box_nbr['Dave'] = 111     #Add a new key 'Dave' with value 111
print (box_nbr.keys())    #Print the keys list in the dictionary
print ('John' in box_nbr) #Check if 'John' is in the dictionary
                          #This returns true

All variables in Python hold references to objects, and are passed to functions. Function can't change the value of variable references in its body. The object's value may be changed in the called function with the “alias”.

>>> alist = ['a', 'b', 'c']
>>> def myfunc(al):
    al.append('x')
    print al

>>> myfunc(alist)
['a', 'b', 'c', 'x']
>>> alist
['a', 'b', 'c', 'x']

If an expression returns TRUE statements are carried out. Otherwise they aren't.

if expression:
  statements

Sample:

no = 11
  if no >10:
   print ("Greater than 10")
   if no <=30
     printf ("Between 10 and 30")

Output:

>>>
Greater than 10
Between 10 and 30
>>>

An else statement follows an if statement and contains code that is called when the if statement is FALSE.

x = 2
if x == 6
  printf ("Yes")
else:
  printf ("No")  

The elif (shortcut of else if) statement is used when changing if and else statements. A series of if…elif statements can have a final else block, which is called if none of the if or elif expression is TRUE.

num = 12
if num == 5:
  printf ("Number = 5")
elif num == 4:
  printf ("Number = 4")
elif num == 3:
  printf ("Number = 3")
else:
  printf ("Number = 12")

Output:

>>>
 Number = 12
>>>

Python uses logic operators like AND, OR and NOT.

The AND operator uses two arguments, and evaluates to TRUE if, and only if, both of the arguments are TRUE. Otherwise, it evaluates to FALSE.

>>> 1 == 1 and 2 == 2
True
>>> 1 == 1 and 2 == 3
False
>>> 1 != 1 and 2 == 2
False
>>> 4 < 2 and 2 > 6
False
>>>

Boolean operator or uses two arguments, and evaluates as TRUE if either (or both) of its arguments are TRUE, and FALSE if both arguments are FALSE.

The result of NOT TRUE is FALSE, and NOT FALSE goes to TRUE.

>>> not 2 == 2
False
>>> not 6 > 10
True
>>>

Operator Precedence uses mathematical idea of operation order, e.g. multiplication begin performed before addition.

>>> False == False or True
True
>>> False == (False or True)
False
>>> (False == False) or True
>>>True
>>>

An if statement is run once if its condition evaluates to TRUE, and never if it evaluates to FALSE.

A while statement is similar, except that it can be run more than once. The statements inside it are repeatedly executed, as long as the condition holds. Once it evaluates to FALSE, the next section of code is executed.

i = 1
while i<=4:
  print (i)
  i+=1
print ('End') 

Output:

>>>
1
2
3
4
End
>>>

The infinite loop is a particular kind of the while loop, it never stops running. Its condition always remains TRUE.

while 1 == 1:
 print ('in the loop')

To end the while loop prematurely, the break statement can be used. When encountered inside a loop, the break statement causes the loop to finish immediately.

i = 0
while 1==1:
  print (i)
  i += 1
  if i >=3:
    print('breaking')
    break;
print ('finished')    

Output:

>>>
0
1
2
3
breaking
finished
>>>

Another statement that can be used within loops is continue.

Unlike break, continue jumps back to the top of the loop, rather than stopping it.

i = 0
while True:
  i+=1
  if i == 2:
    printf ('skipping 2')
    continue
  if i == 5:
    print ('breaking')
    break
  print (i)
print ('finished')  

Output:

>>>
1
skipping 2
3
4
breaking
finished
>>>

n = 9
for i in range (1,5):
  ml = n * i
  print ("{} * {} = {}".format (n, i, ml))

Output:

>>>
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
>>>

One of the most important in mathematics concept is to use functions. Functions in computer languages implement mathematical functions. The executing function produces one or more results, which are dependent by the parameters passed to it.

In general, a function is a structuring element in the programming language which groups a set of statements so they can be called more than once in a program. Programming without functions will need to reuse code by copying it and changing its different context. Using functions enhances the comprehensibility and quality of the program. It also lowers the memory usage, development cost and maintenance of the software.

Different naming is used for functions in programming languages, e.g. as subroutines, procedures or methods.

Python language defines function by a def statement. The function syntax looks:

def function-name(Parameter list):
  statements, i.e. the function body

Function bodie can contain one or more return statement. It can be situated anywhere in the function body. A return statement ends the function execution and returns the result, i.e. to the caller. If the return statement does not contain expression, the value None is returned.

def Fahrenheit(T_in_celsius):
  """ returns the temperature in degrees Fahrenheit """
  return (T_in_celsius * 9 / 5) + 32
 
for t in (22.6, 25.8, 27.3, 29.8):
  print(t, ": ", fahrenheit(t))

Output:

>>>
22.6 :  72.68
25.8 :  78.44
27.3 :  81.14
29.8 :  85.64
>>>

Functions can be called with optional parameters, also named default parameters. If function is called without parameters the default values are used. The following code greets a person. If no person name is defined, it greets everybody:

def Hello(name="everybody"):
  """ Say hello to the person """
  print("Hello " + name + "!")
 
Hello("George")
Hello()

Output:

>>>
Hello George!
Hello everybody!
>>>

The string is usually the first statement in the function body, which can be accessed with function_name.doc. This is Docstring statement.

def Hello(name="everybody"):
  """ Say hello """
  print("Hello " + name + "!")
print("The docstring of the function Hello: " + Hello.__doc__)

Output:

>>>
The function Hello docstring:  Say hello
>>>

The alternative way to make function calls is to use keyword parameters. The function definition stay unchanged.

def sumsub(a, b, c=0, d=0):
  return a - b + c - d
print(sumsub(12,4))
print(sumsub(42,15,d=10))

Only keyword parameters are valid, which are not used as positional arguments. If keyword parameters don't exist, the next call to the function will need all four arguments, even if the c needs just the default value:

print(sumsub(42,15,0,10))

In above examples, the return statement exist in sumsub but not in Hello function. The return statement is not mandatory. If explicitly return statement doesn't exist in the sample code it will not show any result:

def no_return(x,y):
  c = x + y
res = no_return(4,5)
print(res)

Any result will not be displayed in:

>>>

Executing this script, the None will be printed. If a function doesn't contain expression the None will also be returned:

def empty_return(x,y):
    c = x + y
    return
res = empty_return(4,5)
print(res)

Otherwise the expression value following return will be returned. In this example 11 will be printed:

def return_sum(x,y):
  c = x + y
  return c
res = return_sum(6,5)
print(res)

Output:

>>>
9
>>>

Any function can return only one object. An object can be a numerical value – integer, float, list or a dictionary. To return i.e. three integer values, we can return a list or a tuple with these three integer values. It means that function can indirectly return multiple values. This following example calculates the Fibonacci boundary for a positive number, returns a 2-tuple. The Largest Fibonacci Number smaller than x is the first and the Smallest Fibonacci Number larger than x is next. The return value is stored via unpacking into the variables lub and sup:

def fib_intervall(x):
  """ returns the largest Fibonacci number, smaller than x and the lowest
  Fibonacci number, higher than x"""
  if x < 0:
    return -1
  (old, new, lub) = (0,1,0)
  while True:
    if new < x:
      lub = new 
      (old,new) = (new,old+new)
    else:
      return (lub, new)
 
while True:
  x = int(input("Your number: "))
  if x <= 0:
    break
  (lub, sup) = fib_intervall(x)
  print("Largest Fibonacci Number < than x: " + str(lub))
  print("Smallest Fibonacci Number > than x: " + str(sup))

The following code presents a sample Python application that flashes an LED connected to Raspberry Pi's GPIO pin 5. One must build a circuit (LED + resistor of a proper value) and connect it to the GPIO before running the code.
This example uses a dedicated GPIO handling library (specific for hardware): RPi.GPIO. For other IoT platforms, this may vary, i.e. Micropython uses a Machine library instead that covers all microcontroller's hardware.

#Raspberry Pi Python sample code
 
import RPi.GPIO as GPIO  
import time
 
#Blinking function  
def blink(pin):  
GPIO.output(pin,GPIO.HIGH)  
time.sleep(1)  
GPIO.output(pin,GPIO.LOW)  
time.sleep(1)  
return  
 
#Use the Raspberry Pi GPIO pin numbers  
GPIO.setmode(GPIO.BOARD)  
#Set up GPIO output channel  
GPIO.setup(5, GPIO.OUT)  
#Blink GPIO5 5 times  
for i in range(0,5):  
blink(5)  
GPIO.cleanup()

Similarly to the GPIO, interrupts are hardware-specific; thus, libraries may differ among platforms. The samples present below are for Raspberry Pi.
Following Python rules for working with signals and their handlers are listed below.

1. A particular signal handler, once set, remains installed until it is explicitly reset (Python emulates the BSD style interface), except the SIGCHLD handler, which follows the underlying implementation.
2. The critical section signal can't be “blocked” temporarily (all Unix flavours do not support it).
3. Python signal handlers are called asynchronously as far as the Python user is concerned; they can only occur between the “atomic” instructions of the Python interpreter. Signals arriving during long calculations implemented in C (such as regular expression matches on large bodies of text) may be delayed for an arbitrary amount of time.
4. When a signal arrives during an I/O operation, it is possible that the I/O operation raises an exception after the signal handler returns. It depends on the underlying Unix system’s semantics.
5. The C signal handler always returns; it makes little sense to catch synchronous errors like SIGFPE or SIGSEGV.
6. Python installs several signal handlers by default: SIGPIPE is ignored, and SIGINT is translated into a KeyboardInterrupt exception. All of them can be overridden.
7. Some care must be taken if both signals and threads are used in the same program. When using signals and threads simultaneously, always perform signal() operations in the main thread of execution.
8. Any thread can perform an alarm(), getsignal(), pause(), setitimer() or getitimer(); only the main thread can set a new signal handler, and the main thread will be the only one to receive signals. It means that signals can’t be used for inter-thread communication.
9. Use locks instead.

The example program is shown below. It uses the alarm() function to limit the time spent waiting to open a file; very useful if the file needs to be transmitted over a serial device that may not be turned on, which would typically cause the os.open() to hang indefinitely. The best solution is to make a 5-second alarm before opening the file; if the operation takes too long, the alarm signal will be sent, and the handler will raise an exception.

#Raspberry Pi Python sample code
import RPi.GPIO as GPIO
import time
 
state = 0
 
GPIO.setmode(GPIO.BCM)
GPIO.setup(26, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(19, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 
def interrupt_handler(channel):
  global state
 
  print("interrupt handler")
 
  if channel == 19:
    if state == 1:
      state = 0
      print("state reset by event on pin 19")
    elif channel == 26:
      if state == 0:
        state = 1
        print("state set by event on pin 26")
 
GPIO.add_event_detect(26, GPIO.RISING,
                      callback=interrupt_handler,
                      bouncetime=200)
GPIO.add_event_detect(19, GPIO.RISING,
                      callback=interrupt_handler,
                      bouncetime=200)
while (True):
  time.sleep(0)

/data01/virt87891/domeenid/www.robolabor.ee/htdocs/homelab/data/pages/en/iot-open/scriptingprogramming/micropythonfundamentals.txt— MISSING PAGE — /data01/virt87891/domeenid/www.robolabor.ee/htdocs/homelab/data/pages/en/iot-open/scriptingprogramming/csharpfundamentals.txt— MISSING PAGE —

IoT systems and related data flows are typically structured into three basic layers 15, eventually into five 16, which is less popular and used mostly in advanced research ^{[46] [47]}.
The lowest layer is the Perception (physical, acquisition) Layer, the intermediate is the Network Layer, and the higher is the Application Layer. The function of the Perception layer is to keep in contact with the physical environment. Devices working in this layer are designed as embedded systems with a network module. The modern embedded device includes a microcontroller, sensors, and actuators. External memories and other typical microcomputer peripherals are usually built into the microcontroller, so they do not require a special connection. Sensors are elements that convert a value of some physical parameter into an electrical signal, while actuators are elements that control environmental parameters. Sensors and actuators are interfaced with the microcontroller using different connection types, including simple digital or analogue connections or much more complex communication links and protocols. IoT nodes in the Perception layer communicate with higher layers using much more complex data transmission methods. The wire and wireless transmission protocols used between the Perception layer and other layers are described in communications_and_communicating_sut.

This chapter describes some popular internal protocols used to communicate between microcontrollers and other electronic elements called “embedded protocols”.

The embedded protocol that can be used in specific implementation depends mainly on the type of peripheral element. The method of connection and data exchange strictly depends on the kind of element. Some parts are analogue sensors that should be connected to an analogue-digital converter; some can be connected to digital pins working as inputs (for sensors) or outputs (for actuators).

Simple sensors do not implement the conversion and communication logic, and the output is just the analogue signal – voltage level, depending on the value of the measured parameter. It needs to be further converted into a digital representation; this process can be made by the Analogue to Digital Converters (ADC), implemented as the internal part of a microcontroller or separate integrated circuit. Examples of sensors with analogue output are a photoresistor, thermistor, potentiometer, and resistive touchscreen. ADC conversion is a process of conversion of the continuous-time signal into a discrete one. It has 2 crucial parameters to consider:

• Sampling rate: usually measured in Hz (kHz, MHz) is a sampling frequency, or in other words, defines a time period between two consecutive reads. A Nyquist-Shannon theorem defines minimum sampling frequency. Oversampling (using higher than Nyquist-Shannon) is common because many ADC converters built into the MCUs tend to be noisy due to the electromagnetic inference of other components, such as e.g. built-in radio. Oversampling brings the capability to average consecutive reads and obtain more reliable and less noisy ADC conversion.
• Sampling resolution: measured in bits, defines the minimum change in the input voltage that the device can measure, i.e. 12-bit resolution brings 4096 values that are mapped to the input range. Obviously, the ideal ADC converter maps the discrete values to the voltage input range in a linear way. Still, in real-life applications, input characteristics of the ADC used to be non-linear, and software correction may be required once input characteristics are evaluated.

It is worth noting to mention that each ADC has its useable input range (voltage), and the input and analogue signal should be altered accordingly. In real applications, input signal adaptation requires external electronics; thus, many ADC converters provide the ability to amplify the input signal, and it can be programmed.

Simple, true/false information can be processed via digital I/O. Most devices use positive logic, where, i.e. +5 V (TTL) or +3.3 V (the most popular, yet other voltage standards exist) presents a logical one, also referenced as HIGH. In contrast, 0V presents a logical zero, referenced as LOW. In real systems, this bounding is fuzzy. It brings some tolerance, simplifying, e.g. communication from 3.3 V output to 5 V input, without a need for the conversion (note, the reverse conversion is usually not so straightforward, as 3.3 V inputs driven by the 5V output may burn quickly). A sample sensor providing binary data is a button (On/Off).
Alternating HIGH and LOW constitutes a square wave signal, usually used as a clock signal (when symmetrical) or used to control the power delivered to the external devices with means of so-called PWM.

Elements that need more data to be transferred (e.g. displays) usually use some digital data transmission protocol. It is often a serial protocol, meaning that data is transmitted bit by bit. Serial communication can be done in three modes.

• In simplex mode, only one of the two devices on a link can transmit; the other can only receive. The simplex mode can use the entire capacity of the channel to send data.
• In half-duplex mode, each station can transmit and receive, but not simultaneously. When one device sends, the other can only receive, and vice versa.
• In full-duplex mode, both stations can transmit and receive simultaneously. The link must contain two physically separate transmission paths, one for sending and the other for receiving.

Serial data transmission can be done synchronously or asynchronously. In synchronous data transmission, bits are synchronized with a clock signal common to the transmitter and receiver. Examples of synchronous protocols are TWI (Two Wire Interface) and SPI (Serial Peripheral Interface). Asynchronous data transmission does not need any separate synchronization signal, but the transmitter and receiver must use the exact timings and synchronization information must be included in the information transmitted. Examples of asynchronous interfaces implemented in microcontrollers are 1-Wire and UART (Universal Asynchronous Receiver Transmitter).

• SPI,
• I2C,
• 1-Wire,
• UART.

The PWM signal controls the energy delivered to the device, usually a DC motor, LED light, bulb, etc. To control voltage, instead of using inefficient resistance-based voltage dividers (where the remaining part of the voltage is distracted as heat), PWM is based on approximating the energy delivered to the device with periodical switching on and off (HIGH and LOW). Only two voltages are delivered to the device: low (0V) and HIGH (Vcc, e.g. +5V). One can easily observe how PWM works, e.g. when dimming the LED, if recorded with a high fps camera: the LED light flashes with the PWM signal frequency.
PWM controls, in fact, the ratio between HIGH and LOW signals in one period: the higher the ratio, the more energy is being delivered to the device. It is called a duty cycle. A perfect square wave signal, usually referenced as a clock signal, has a duty cycle of 50% (or 0.5); thus, its energy is half of the energy that can be carried when the signal is HIGH all the time. An LED light with a duty cycle of 100% will be fully bright, and with a duty cycle of 0 will be off.

PWM signal is then characterised by the following:

• voltage (values when HIGH and LOW),
• frequency,
• duty cycle.

In microcontrollers, PWM used to be generated with timers and interrupts to ensure asynchronous operation and stability of the operation. Due to the digital nature of the signal generation, a duty cycle generation precision is given by the PWM timer resolution. An 8-bit resolution splits a period into 256 chunks, and a single chunk defines the minimum time one can increment or decrement the duty cycle. Modern MCUs provide developers with much higher resolution, even up to 14-bit.

A frequency of 5kHz is equivalent to 0.2ms period that can be controlled in steps of 0.2/256 ms ~= 781 ns.
Sample visualisation of the 5kHz PWM signal (3.3V) is presented in the following figures, with a duty cycle of, respectively:

• 50/256→~39us (19.5%) in image 17,
• 100/256→~78us (28%) in image 18,
• 150/256→~117us (58.6%) in image 19,
• 200/256→~156us (78.1%) in image 20,
• 250/255→~195us (98%) in image 21,.

A voltage delivered to the device powered with a PWM signal can be calculated as an integral of the PWM signal over time: e.g., a 50% duty cycle of the 5V signal is equivalent to the delivery of the constant 2.5V.

One of the most popular interfaces to connect different external devices is SPI (Serial Peripheral Interface). It is a synchronous serial interface and protocol that can transmit data with speeds up to 20 Mbps. SPI is used to communicate microcontrollers with one or more peripheral devices over short distances – usually internally in the device. High transmission speed enables SPI to be suitable even for sending animated video data to colourful displays. In SPI connection, there is always one master device, in most cases the microcontroller (μC) that controls the transmission, and one or more slave devices – peripherals. To communicate, SPI uses three lines common to all connected devices and one enabling line for every slave element.

The MISO line is intended to send bits from slave to master, the MOSI wire transmits data from master to slave, and the SCK line sends clock pulses that synchronize data transmission. The master device always generates the clock signal. Every SPI-compatible device has the SS (Slave Select) input that enables communication in this specific device. Master is responsible for generating this enable signal – separately for every slave in the system.

SPI is used in many electronic elements:

• analogue to digital converters (ADC),
• real-time clocks (RTC),
• EEPROMs,
• LCD, OLED, and e-paper displays,
• communication interfaces (e.g. Ethernet, WiFi),
• and many others.

Due to different hardware implementations, there are four SPI protocol operation modes. The mode used in the master must fit the mode implemented in the slave device.

It results in different timings of the clock signal concerning the data sent. Clock polarity = 0 means that the idle state of the SCK is 0, so every data bit is synchronised with the pulse of logic 1. Clock polarity = 1 reverses these states. Output edge (rising/falling) says at which edge of active SCK signal sender puts a bit on the data line. The data capture edge says at what edge of SCK signal data should be captured by the receiver.

Even if a 20MHz frequency ensures good transmission speed, it can be too slow for some use. Some modern microcontrollers use external flash memory for program storage and execute programs from internal SRAM memory, downloading executable code in chunks as required. This requires a higher data rate to avoid stalls in program execution. A QSPI (Quad-SPI) link was developed to achieve higher transmission speed. It has four bidirectional data lines instead of two unidirectional to increase speed four times. Additionally, it supports higher clock frequency, increasing speed even higher, currently more than 100MBps. Operation of QSPI requires a special protocol with a set of commands, so hardware implementation is much more complex than the original SPI.

TWI (Two Wire Interface) is one of embedded systems' most popular communication links and protocols. Philips has designed it as an I2C (Inter-Integrated Circuit) for audio-video appliances controlled by the microprocessor. Many chips can be connected to the processor with this interface, including:

• EEPROM memory chips,
• RAM memory chips,
• AD/DA converters,
• real-time clocks,
• sensors (temperature, pressure, gas, air pollution),
• port extenders,
• displays,
• specialised AV circuits.

TWI, as the name says, uses two wires for communication. One is the data line (SDA); the second is the clock line (SCL). Both lines are common to all circuits connected to the one TWI bus. The method of communication of TWI is the master-slave synchronous serial transmission. It means that data is sent bit after bit synchronised with the clock signal. The SCL line is always controlled by the master unit (usually the microcontroller); the signal on the SDA line is generated by the master or one of the slaves – depending on the direction of communication. The frequency rate of the transmission is up to 100 kHz for most of the chips; for some, it can be higher – up to 400 kHz. The new implementation allows an even higher frequency rate, reaching 5 MHz. At the output side of units, the lines have the open-collector or open-drain circuit. This means that external pullup resistors are needed to ensure the proper operation of the TWI bus. The value of these resistors depends on the number of connected elements, the speed of transmission, and the power supply voltage. It can be calculated with the formulas presented, e.g. in the Texas Instrument Application Report ^[48]. Usually, it is assumed between 1 kΩ and 4.7 kΩ.

The data is sent using frames of bytes. Every frame begins with a sequence of signals called the start condition. Slaves detect this sequence, which causes them to collect the next eight bits that form the address byte – unique for every circuit on the bus. If one of the slaves recognises its address remains active until the end of the communication frame, others become inactive. To inform the master that some unit has been appropriately addressed slave responses with the acknowledge bit – it generates one bit of low level on the SDA line (the master generates clock pulse). After sending the proper address, data bytes are sent. The direction of the data bytes is controlled by the last bit of the address; for 0, data is transmitted by the master (Write), and for 1, data is sent by the slave (Read). The receiving unit must acknowledge every full byte (eight bits). There is no limitation on the number of data bytes in the frame; for example, samples from the AD converter can be read continuously byte after byte. At the end of the frame, another special sequence is sent by the master–stop condition. It is also possible to generate another start condition without the stop condition. It is called a repeated start condition.

Address byte only activates one chip on the bus, so every unit must have a unique physical address. This byte usually consists of three elements: a 4-bit field fixed by the producer. This 3-bit field can be set by connecting three pins of the chip to 0 (ground) or 1 (power supply line), a 1-bit field for setting the direction of communication (R/#W). Some elements (e.g. EEPROM memory chips) use the 3-bit field for internal addressing, so only one such circuit can be connected to one bus. There are no special rules for the data bytes. The first data byte sent by the master can be used to configure the slave chip. In memory units, it is used for setting the internal address of the memory for writing or reading in multi-channel AD converters to choose the analogue input. Detailed information on the meaning of every bit of the transmission is present in the documentation of the specific integrated circuit. The I2C standard also defines the multi-master mode, but in most small projects, there is one master device only.

1-Wire is a master-slave communication asynchronous bus interface designed formerly by Dallas Semiconductor Corp^[49]. It can transmit data at long distances at the cost of transmission speed. The typical data speed of the 1-Wire interface is about 16.3 kbit/s, and the maximum length is approx. 300m. Name 1-Wire comes from the feature that the data line can directly power elements connected to the bus. A network chain of 1-Wire devices consists of one master device and many slave devices. Such a chain is called a MicroLAN. 1-Wire devices may be a part of a product's circuit board, a single component device such as a temperature probe, or a remote device for monitoring purposes.

Each 1-Wire device must contain a logic unit to operate on the bus. A dedicated bus converter is needed to connect a 1-wire bus to a PC. The most popular PC/1-Wire converters use a USB plug to connect to the PC and the RJ11 connectors (telephones 6P2C/6P4C modular plugs) for MicroLAN. 1-Wire devices can also be connected directly to the microcontroller boards.

Within the MicroLAN, there is always one master device, typically a PC or a microcontroller unit. The master always initiates activity on the bus to avoid collisions on the network chain. If a collision occurs, the master device retries the communication. In the 1-Wire network, many devices can share the same bus line. To identify devices in the MicroLAN, each connected device has a unique 64-bit ID number. The ID number's least significant byte defines the type of the device (temperature, voltage, etc.). The most significant byte represents a standard 8-bit CRC. The 1-Wire protocol description contains several broadcast commands and commands used to address the selected device. The master sends a selection command, then the address of the selected slave device. This way, the following command is executed only by the addressed device. The 1-Wire bus implements an enumeration procedure that allows the master to get information about the ID numbers of all connected slave devices to the MicroLAN network. The device address includes the device type, identifying what type of slaves are connected to the network chain. The 64-bit address space is searched as a binary tree. It makes it possible to find up to 75 devices per second.

The physical implementation of the 1-Wire network is based on an open drain master device connected to one or more open drain slaves. One single pull-up resistor for all devices pulls the bus up to 3/5 V and can be used to power the slave devices. 1-Wire communication starts when a master or slave sets the bus to low voltage (connects the pull-up resistor to ground through its output MOSFET).

The 1-Wire protocol allows for bursting the communication speed up by 10 factors. In this case, the master starts a transmission with a reset pulse, pulling down the data line to 0 volts for at least 480 µs. It resets all slave devices in the network chain bus. Then, any slave device shows it exists, generating the “presence” pulse. It holds the data line low for at least 60 µs after the master releases the bus. To send a “1”, the bus master sends a 1–15 µs low pulse. To send a “0”, the master sends a 60 µs low pulse. The negative edge of the pulse is used to start a slave's monostable multivibrator. The slave's multivibrator clocks to read the data bus about 30 µs after the falling edge. The slave's multivibrator has analogue tolerances that affect its timing accuracy, for the “0” pulses are 60 µs long, and “1” pulses are limited to a max of 15 µs. When the designed solution doesn't contain a dedicated 1-Wire interface peripheral, a UART can be used as a 1-Wire master. Dallas also offers Serial or USB “bridge” chips, which are very useful when the distance between devices is long (greater than 100 m). For longer, up to 300 m buses, the simple twisted pair telephone cable can be used. It will require adjustment of pull-up resistances from 5 kΩ to 1 kΩ. The basic sequence is a reset pulse followed by an 8-bit command, and after it, data can be sent/received in groups of 8-bits. In the case of transmission errors, the weak data protection 8-bit CRC checking procedure can be used.

To find the devices, the enumeration broadcast command must be sent by a master. The slave device responds with all ID bits to the master, and at the end, it returns a 0.

The Dallas/Maxim integrated 1-Wire devices list contains a wide range of implementations. The 1-Wire protocol can be quickly implemented into the current IoT boards; most manufacturers share the software libraries, allowing developers to include them in their projects in C, C++, and assembly languages. The 1-Wire sensors (temperature, humidity, pressure, etc.) are factory calibrated and reading the physical measurements follows the International System of Units (SI). 1-Wire products can be grouped as follows:

• secure authenticators,
• memory EPROM, EEPROM ROM,
• temperature sensors and temperature switches,
• data loggers,
• 1-Wire interface products,
• battery monitors, protectors, and selectors,
• battery ID and authentication,
• timekeeping and real-time clocks.

UART name is an abbreviation of Universal Asynchronous Receiver Transmitter. It is one of the most often used communication methods, traditionally named serial interface or serial port. In contrast to previously presented interfaces, UART uses direct point-to-point communication. UART is the communication unit implemented in microcontrollers rather than the communication protocol. It sends the series of bits via the TxD pin and receives a stream of bits with the RxD pin. It is important to remember that pin TxD from one device should be connected to pin RxD in another device. This is a general rule, but please always check the documentation for some non-standard markings.

The transmission speed and bit duration must be the same at the transmitter and receiver to properly transmit data. Although the transmission speed can be freely chosen, some standard, commonly used baud rates exist. They differ from 300 to 115200 bits per second. Higher baud rates are also available in modern microcontrollers, like 230400, 250000, 500000, 1M, 2M or 3Mbps. In UART, data is sent in frames. The frame begins with the start bit of value “zero”. Next, from five to eight data bits are transmitted. Next, an optional parity bit can appear. The frame is finished with the stop bit of value “one”. Stop bit can be prolonged to 1.5 or 2 times the standard bit duration. After at least one stop bit, the next frame can be sent, beginning with a start bit. Start and stop bits are used to synchronise the receiver and transmitter.

UART, namely Serial Port, is used in many modern microcontrollers to upload the executable program, debug, and as the standard input/output for the user interface. For example, in Arduino, functions that operate on the serial port are included in a common set of built-in functions.

IoT hardware infrastructure is mainly inherited from the embedded systems of the SoC type for Edge class IoT devices and from PCs for Fog class. As IoT devices are by their nature network-enabled, many of the existing embedded platforms evolved towards network-enabled solutions, sometimes indirectly through delivering network communication module (wired or wireless) as an external device yet integrated on the development board (e.g. Arduino Uno with Ethernet Networking shield, GSM shield, etc.), sometimes a new system, integrating networking capabilities in one SoC (e.g. Espressif SoCs). More advanced devices that require OS to operate preliminarily benefited from externally connected peripheral network interfaces via standard wired ports like USB (i.e. early versions of the Raspberry Pi, where WiFi card was delivered as USB stick), currently, usually integrate most of the network interfaces in a single board (e.g. RPi 4, including Ethernet, WiFi and Bluetooth). Still, in the case of the Fog class devices, those are separate chips to the CPU, and they communicate over, e.g. PCI or ISB protocol.

A microcontroller with network capabilities is the key, but not the only element forming an IoT node device. Additional elements, including sensors and actuators, are needed to keep in touch with the environment.

In the following chapters, there is a description of the families of popular microcontrollers, sensors and actuators:

• Most Noticeable Platforms
• Sensors and Sensing
• Actuators and Output Devices

Finally, in the last sub-chapter, there is an introduction to the powering of IoT devices:

• Powering of the IoT Devices

The IoT market is an emerging one. New hardware solutions appear almost daily, while others disappear quickly. At the moment of writing the first version of this book (2016-2019), some hardware solutions that seemed to be prominent for at least a couple of years existed. After a few years, while the 2nd edition of the publication is being prepared (2023–2025), most of the hardware solutions described previously are still present on the market, even strengthening their position and having modernized and improved versions (e.g. ESP32 as the successor of ESP8266). However, some other platforms increased their popularity, mainly because of their appearance in the VSCode programming environment with PlatformIO, and what is even more important, the possibility of writing programs in the Arduino model. In the following sections, a short review of these platforms is provided.

• AVR: Arduino – a development board using the Atmel microcontroller, undoubtedly the most popular development platform for enthusiasts and professionals. Arduino itself barely offers networking capabilities yet; there is a vast number of extension boards, including network interfaces (both wired and wireless);
• ESP: Espressif (Espressif Systems) – the great SoC solutions with wireless network interfaces built-in; the family of Espressif chips includes ESP8266 (WiFi) and ESP32 (WiFi, Bluetooth)
• nRF52: Nordic Semiconductor SoC that is based on ARM architecture and offers NFC, Bluetooth and ZigBee capabilities
• STM32: Another ARM-based family of SoCs; some of them have Bluetooth wireless module built-in
• ARM: Raspberry Pi (and its clones) – advanced boards, including Linux operating system with GUI interface, even able to replace desktop computers.

The following chapters are dedicated to the families of the devices, describing their main features:

• Arduino

• ESP8266

• ESP32

• nRF52

• STM32

• Raspberry PI

A sensor is an element that can turn a physical outer stimulus into an output signal, which can then be used for further analysis, management, or making decisions. People also use sensors like eyes, ears and skin to gain information about the outer world and act according to their aims and needs. Sensors can be divided into many categories according to the measured parameter of the environment.

Usually, every natural phenomenon – temperature, weight, speed, etc. – needs specially customised sensors that can change phenomena into electric signals, usually the voltage, that microprocessors or other devices could use. Sensors can be divided into many groups according to the physical nature of their operations – touch, light, an electrical characteristic, proximity and distance, angle, environment and other sensors.

• Touch Sensors

• Light Sensors

• Optical Sensors

• Electrical Characteristic Sensors

• Proximity and Distance Sensors

• Angle & Orientation Sensors

• Environment Sensors

• Other Sensors

A pushbutton is an electromechanical sensor that connects or disconnects two points in a circuit when force is applied. The button output discrete value is either HIGH or LOW.

A microswitch, also called a miniature snap-action switch, is an electromechanical sensor that requires very little physical force and uses a tipping-point mechanism. Microswitch has three pins, two of which are connected by default. When the force is applied, the first connection breaks and one of the pins is connected to the third pin.

The most common use of a pushbutton is as an input device. Both force solutions can be used as simple object detectors or as end switches in industrial devices. The button can be connected to any available digital pin that must be configured as input or input with a pullup. In the configuration presented in the figure below, a pull-up resistor is connected externally, so enabling it in the microcontroller is unnecessary.

An example code:

int buttonPin = 2; //Initialization of a push button pin number
int buttonState = 0; //A variable for reading the push button status
 
void setup() {
  Serial.begin(9600);  //Begin serial communication
  pinMode(buttonPin, INPUT); //Initialize the push button pin as an input
}
 
void loop() {
  //Read the state of the pin where a button is connected
  //it is LOW if a button is pressed, HIGH otherwise
  //the buttonState variable holds the compliment state of the buttonPin
  buttonState = !digitalRead(buttonPin);
  //Check if the push button is pressed. If it is, the buttonState variable is HIGH
  if (buttonState == HIGH) { 
    //Print out text in the console
    Serial.println("The button state variable is HIGH - it is pressed."); 
  } else {
    Serial.println("The button state variable is LOW - it is not pressed.");
  }
  delay(10); //Delay in between reads for stability
}

A force sensor predictably changes resistance depending on the applied force to its surface. Force-sensing resistors are manufactured in different shapes and sizes, and they can measure not only direct force but also tension, compression, torsion and other types of mechanical forces. Because the force sensor changes its resistance linearly, it should be connected to the analogue input. It is also required o connect another resistor to form the voltage divider, as shown in the figure below. The voltage is measured by the internal ADC of the microcontroller.

Force sensors are used as control buttons, object presence detectors, or to determine weight in electronic scales.

An example code:

//Force Sensitive Resistor (FSR) is connected to the analogue 0 pin
int fsrPin = A0; 
//The analog reading from the FSR resistor divider
int fsrReading;      
 
void setup(void) {
  //Begin serial communication
  Serial.begin(9600);   
  //Initialize the FSR analogue pin as an input
  pinMode(fsrPin, INPUT); 
}
 
void loop(void) {
  //Read the resistance value of the FSR
  fsrReading = analogRead(fsrPin); 
  //Print 
  Serial.print("Analog reading = "); 
  Serial.println(fsrReading);
  delay(10);
}

Capacitive sensors are a range of sensors that use capacitance to measure changes in the surrounding environment. A capacitive sensor consists of a capacitor that is charged with a certain amount of current until the threshold voltage. A human finger, liquids or other conductive or dielectric materials that touch the sensor can influence the sensor's charge time and voltage level. Measuring charge time and voltage level gives information about changes in the environment. Ready-to-use sensors include an electronic element that performs measurements and returns digital information at the output so that they can be connected directly to a digital input pin.

Capacitive sensors are used as input devices and can measure proximity, humidity, fluid level and other physical parameters or serve as an input for electronic device control.

//Capacitive sensor is connected to the digital 2 pin
int touchPin = 2; 
 
//The variable that stores digital value read from the sensor
boolean touchReading = LOW; 
//The variable that stores the previous state of the sensor
boolean lastState = LOW; 
 
void setup() {
  //Begin serial communication
  Serial.begin(9600);  
  //Initialize the capacitive sensor analogue pin as an input
  pinMode(touchPin, INPUT);  
}
 
void loop() {
  //Read the digital value of the capacitive sensor
  touchReading = digitalRead(touchPin); 
  //If the new touch has appeared
  if (currentState == HIGH && lastState == LOW){ 
    Serial.println("Sensor is pressed");
    delay(10); //short delay
  }
  //Save the previous state to see relative changes
  lastState = currentState; 
}

A photoresistor is a sensor that perceives light waves from the environment. The resistance of the photoresistor is changing depending on the intensity of light. The higher the intensity of the light, the lower the sensor's resistance. A light level is determined by applying a constant voltage through the resistor to the sensor forming a voltage divider, and measuring the resulting voltage. Photoresistors are cheap, but the resulting resistance is influenced by temperature and changes slowly, so they are used in applications where speed and accuracy are not crucial. Photoresistors are often used in energy-effective street lighting control.

Photoresistor connected, as it is shown in the figure above, gives a lower voltage level while the light is more intense. Results can be read with the following example code. The value will be just a number not expressed in any units, e.g. Lux. To express light intensity in luxes, additional calculations must be encoded in the program.

//Define an analog A0 pin for photoresistor
int photoresistorPin = A0; 
//The analogue reading from the photoresistor 
int photoresistorReading;  
 
void setup()
{
    //Begin serial communication
    Serial.begin(9600);  
    //Initialize the analogue pin of a photoresistor as an input
    pinMode(photoresistorPin, INPUT); 
}
 
void loop()
{
    //Read the value of the photoresistor
    photoresistorReading = analogRead(photoresistorPin); 
    //Print out the value of the photoresistor reading to the serial monitor
    Serial.println(photoresistorReading); 
    delay(10); //Short delay
}

A photodiode is a sensor that converts light energy into electrical current. A current in the sensor is generated by exposing a p-n junction of a semiconductor to the light. Information about the light intensity can be determined by measuring a voltage level. Photodiodes react to changes in light intensity very quickly, so they can be used ad receivers of light-based data transmission systems (e.g. fibre data communication). Solar cells are just large photodiodes.

Photodiodes are used as precise light-level sensors, receivers for remote control, electrical isolators (optocouplers), and proximity detectors.

Although the photodiode can generate current, the schematic in the figure above shows its connection similar to the photoresistor in the previous example. In such a circuit, the photodiode changes its current according to a change in light intensity, resulting in the voltage change at the microcontroller's analogue input. As in the example for a photoresistor, the higher the light intensity, the lower the voltage. An example code:

//Define an analog A0 pin for photodiode
int photodiodePin = A0;  
//The analogue reading from the photodiode
int photodiodeReading;  
 
void setup()
{
    //Begin serial communication
    Serial.begin(9600);  
    //Initialize the analogue pin of a photodiode as an input
    pinMode(photodiodePin, INPUT); 
}
 
void loop()
{
    //Read the value of the photodiode
    photodiodeReading = analogRead(photodiodePin); 
    //Print out the value of the photodiode reading to the serial monitor
    Serial.println(photodiodeReading); 
    delay(10); //Short delay
}

The phototransistor is a normal bipolar transistor with a transparent enclosure that exposes the base-emitter junction to light. In a bipolar transistor, the current that passes through the collector and emitter depends on the base current. In the phototransistor, the collector-emitter current is controlled with light. A phototransistor is slower than a photodiode but can conduct more current; additionally, it amplifies the incoming signal. In specific conditions, if the light is completely off or intense enough to make the output current maximal, a phototransistor can be considered a light-controlled electronic switch (e.g. in optocouplers which are usually connected to digital inputs of the microcontroller).

Phototransistors are used as optical switches, proximity sensors and electrical isolators.

An example code:

//Define an analog A1 pin for phototransistor
int phototransistorPin = A1;  
//The analogue reading from the phototransistor
int phototransistorReading;  
 
void setup()
{
    //Begin serial communication
    Serial.begin(9600);  
    //Initialize the analogue pin of a phototransistor as an input
    pinMode(phototransistorPin, INPUT); 
}
 
void loop()
{
    //Read the value of the phototransistor
    phototransistorReading = analogRead(phototransistorPin); 
    //Print out the value of the phototransistor reading to the serial monitor
    Serial.println(phototransistorReading); 
    delay(10); //short delay
}

An optocoupler is a device that combines light-emitting and receiving devices in one package. Mostly it is a combination of the infrared light-emitting diode (LED) and a phototransistor. There are three main types of optocouplers:

• an optocoupler of a closed pair configuration is enclosed in the dark resin and is used to transfer signals using light. This type of optocoupler is not a sensor itself but is used for ensuring electrical isolation between two circuits;
• a slotted optocoupler has an open space between the light source and the sensor; light can be obstructed by external objects and thus can influence the sensor signal. It can be used to detect the presence of flat objects, measure rotation speed, vibrations or serve as a bounce-free switch;
• a reflective pair configuration, the light signal is perceived as a reflection from the object's surface. This configuration is used for proximity detection, surface colour detection and tachometer.

An example code:

int optoPin = A0; //Initialize an analogue A0 pin for optocoupler
int optoReading; //The analogue value reading from the optocoupler
 
int objecttreshold = 1000; //Object threshold definition
int whitetreshold = 150; //White colour threshold definition
 
void setup () 
{
  //Begin serial communication
  Serial.begin(9600); 
  //Initialize the analogue pin of the optocoupler as an input
  pinMode(optoPin, INPUT); 
}
 
void loop () 
{
  optoReading = analogRead(optoPin); //Read the value of the optocoupler
  Serial.print ("The reading of the optocoupler sensor is: ");
  Serial.println(optoReading);
 
  //When the reading value is lower than the object threshold
  if (optoReading < objecttreshold) { 
    Serial.println ("There is an object in front of the sensor!");
    //When the reading value is lower than the white threshold
    if (optoReading < white threshold) { 
      Serial.println ("Object is in white colour!");
    } else { //When the reading value is higher than the white threshold
      Serial.println ("Object is in dark colour!");
    }
  }
  else { //When the reading value is higher than the object threshold
    Serial.println ("There is no object in front of the sensor!");
  }
  delay(500); //Short delay
}

This type of sensor gives information about the colour of the light illuminating the sensor surface. Because computers often use RGB (red, green, blue) colour scheme sensor returns three values representing the intensity of three components. Colour sensors usually contain white LEDs to illuminate the surface, which colour should be distinguished by them. The colour sensor uses SPI or TWI interface to send readings. Some models of colour sensors include an additional gesture detector which recognises simple gestures (up, down, left, right).

#include <Wire.h>
#include "Adafruit_TCS34725.h"
 
// Example code for the TCS34725 library by Adafruit
 
// Sensor class 
Adafruit_TCS34725 rgb_sensor = Adafruit_TCS34725();
 
void setup(void) {
  Serial.begin(9600);
 
  if (rgb_sensor.begin()) {  //Initialise RGB sensor
    Serial.println("RGB sensor present");
  } else {
    Serial.println("No TCS34725 found");
    while (1);
  }
}
 
void loop(void) {
  uint16_t r, g, b, unfiltered, lux;
 
  rgb_sensor.getRawData(&r, &g, &b, &unfiltered);   //read RGB and unfiltered light intensity
  lux = rgb_sensor.calculateLux(r, g, b);  //calculate illuminance in Lux
 
  Serial.print("Lux: ");     //print calculated Lux value
  Serial.print(lux, DEC);
  Serial.print(" - ");
 
  Serial.print("R: ");       //print red component value
  Serial.print(r, DEC); 
  Serial.print(" ");
 
  Serial.print("G: ");       //print green component value 
  Serial.print(g, DEC); 
  Serial.print(" ");
 
  Serial.print("B: ");       //print blue component value
  Serial.print(b, DEC); 
  Serial.print(" ");
 
  Serial.print("C: ");       //print unfiltered sensor value
  Serial.print(unfiltered, DEC); 
  Serial.println(" ");
 
  delay(1000);
}

Electrical characteristic sensors are used to measure the voltage and amperage of the electric current. When the voltage and current sensors are used concurrently, the consumed power of the device can be determined. Electrical characteristic sensors can determine whether the device's circuit is working properly. Different sensor circuits must be used to measure direct current (DC) and alternating current (AC). If the parameters of the mains are to be measured, it must be done using transformers for safety reasons.

A voltage sensor is a device or circuit for voltage measurement. A simple DC (direct current) voltage sensor consists of a voltage divider circuit with an optional amplifier for a very small voltage measure. For measuring the AC (alternating current), the input is connected to the rectifier diode or bridge to rectify AC to DC and a capacitor to flatten the voltage. The resulting voltage can be measured with an analogue, digital converter of the microcontroller. For safety, while measuring the mains voltage, an optoelectrical isolator should be added at the output, or a transformer to additionally lower the voltage at the input.

A voltage sensor can detect a power failure and measure if the voltage is in the range required. IoT applications include monitoring appliances, power lines, and power supplies.

The example code:

//Define an analogue A1 pin for voltage sensor
int voltagePin = A1; 
//The result of the analogue reading from the voltage sensor
int voltageReading;  
 
float vout = 0.0;
float vin = 0.0;
float R1 = 30000.0; //  30 kΩ resistor 
float R2 = 7500.0; //  7.5 kΩ resistor
 
void setup()
{
    //Begin serial communication
    Serial.begin(9600);  
    //Initialize the analogue pin as an input
    pinMode(voltagePin, INPUT); 
}
 
void loop()
{
    //Read the value of the voltage sensor
    voltageReading = analogRead(voltagePin); 
    vout = (voltageReading * 5.0) / 1024.0;
    vin = vout / (R2/(R1+R2));
 
    Serial.print("Voltage is: ");
    //Print out the value of the voltage to the serial monitor
    Serial.println(vin); 
    delay(10); //Short delay
}

A current sensor is a device or a circuit for current measurement. A simple DC sensor consists of a high-power resistor with low resistance. The current value is obtained by measuring the voltage on the resistor and applying a formula derived from Ohm's law. Other non-invasive measurement methods involve hall effect sensors for DC and AC and inductive coils (current transformer) for AC. Current sensors are used to determine the power consumption and to detect whether the device is turned on or shorted.

Make a photo of the current transformer.

The example code:

//Define an analogue A0 pin for current sensor
const int currentPin = A0; 
//Scale factor of the sensor use 100 for 20 A Module and 66 for 30 A Module
int mVperAmp = 185; 
int currentReading;
int ACSoffset = 2500; 
double Voltage;
double Current;
 
void setup(){ 
 Serial.begin(9600);
}
 
void loop(){
 
 currentReading = analogRead(currentPin);
 Voltage = (currentReading / 1024.0) * 5000; //Gets you mV
 Current = ((Voltage - ACSoffset) / mVperAmp); //Calculating current value
 
 Serial.print("Raw Value = " ); //Shows pre-scaled value 
 Serial.print(currentReading); 
 Serial.print("\t Current = "); //Shows the voltage measured
 //The '3' after current allows to display 3 digits after the decimal point
 Serial.println(Current,3); 
 delay(1000); //Short delay

An infrared (IR) proximity sensor is used to detect objects and to measure the distance to them without any physical contact. IR sensor consists of an infrared emitter, a receiving sensor or array of sensors and a signal processing logic. The output of a sensor differs depending on the type – simple proximity detection sensor outputs HIGH or LOW level when an object is in its sensing range, but sensors which can measure distance output an analogue signal or use some communication protocol, like I2C to send sensor measuring results. IR sensors are used in robotics to detect obstacles located a few millimetres to several meters from the sensor and in mobile phones to help detect accidental screen touching.

An example code:

int irPin = A0;  //Define an analogue A0 pin for IR sensor
int irReading;  //The result of an analogue reading from the IR sensor
 
void setup()
{
    //Begin serial communication
    Serial.begin(9600);  
    //Initialize the analogue pin of an IR sensor as an input
    pinMode(irPin, INPUT); 
}
 
void loop()
{
    //Read the value of the IR sensor
    irReading = analogRead(irPin); 
    //Print out the value of the IR sensor reading to the serial monitor
    Serial.println(irReading); 
    delay(10); //Short delay
}

The ultrasonic sensor measures the distance to objects by emitting short ultrasound sound pulse and measuring its returning time. The sensor consists of an ultrasonic emitter and receiver; sometimes, they are combined into a single device for emitting and receiving. Ultrasonic sensors can measure greater distances and cost less than infrared sensors, but are more imprecise and interfere which each other measurement if more than one is used. Simple sensors have a trigger pin and an echo pin; when the trigger pin is set high for a small amount of time, ultrasound is emitted, and on the echo pin, response time is measured. Ultrasonic sensors are used in car parking sensors and robots for proximity detection.

An example code:

int trigPin = 2;  //Define a trigger pin D2
int echoPin = 4;  //Define an echo pin D4
 
void setup()
{
    Serial.begin(9600); //Begin serial communication
    pinMode(trigPin, OUTPUT); //Set the trigPin as an Output
    pinMode(echoPin, INPUT); //Set the echoPin as an Input
}
 
void loop()
{
    digitalWrite(trigPin, LOW);  //Clear the trigPin
    delayMicroseconds(2);
 
    //Set the trigPin on HIGH state for 10 μs
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
 
    //Read the echoPin, return the sound wave travel time in microseconds
    duration = pulseIn(echoPin, HIGH); 
    //Calculating the distance 
    distance = duration*0.034/2; 
 
    //Printing the distance on the Serial Monitor
    Serial.print("Distance: ");  
    Serial.println(distance);
}

The motion detector is a sensor that detects moving objects, mostly people. Motion detectors use different technologies, like passive infrared sensors, microwaves and the Doppler effect, video cameras, and ultrasonic and IR sensors. Passive IR (PIR) sensors are the simplest motion detectors that sense people by detecting changes in IR radiation that is emitted through the skin. When the motion is detected, the output of a motion sensor is a digital HIGH/LOW signal.

Motion sensors are used in security alarm systems, automated lights and door control. As an example in IoT, the PIR motion sensor can be used to detect motion in security systems in a house or any building.

An example code:

//Passive Infrared (PIR) sensor output is connected to the digital 2 pin
int pirPin = 2; 
//The digital reading from the PIR output
int pirReading;      
 
void setup(void) {
  //Begin serial communication
  Serial.begin(9600);   
  //Initialize the PIR digital pin as an input
  pinMode(pirPin, INPUT); 
}
 
void loop(void) {
  //Read the digital value of the PIR motion sensor
  pirReading = digitalRead(pirPin); 
  //Print out
  Serial.print("Digital reading = "); 
  Serial.println(pirReading);
 
  if(pirReading == HIGH) {  //Motion was detected
    Serial.println("Motion Detected");
  }
 
  delay(10);
}

A level sensor detects the level of fluid or fluidised solid. Level sensors can be divided into two groups:

• continuous level sensors that can detect the exact position of the fluid. For level detection, usually, the proximity sensors, like ultrasonic or infrared, are used. Capacitive sensors can also be used by recording the changing capacitance value depending on the fluid level. The output can be either analogue or digital value;
• point-level sensors can detect whether a fluid is above or below the sensor. A membrane with air pressure or changes in conductivity or capacitance can be used for level detection, also a floating or mechanical switch. The output is usually a digital value that indicates HIGH or LOW value.

Fluid level sensors can be used for smart waste management, for measuring tank levels, diesel fuel gauging, liquid assets inventory, chemical manufacturing, high or low-level alarms, and irrigation control.

An example code:

int levelPin = 6; //Liquid level sensor output is connected to the digital 6 pin
int levelReading; //Stores level sensor detection reading
 
void setup(void) {
  Serial.begin(9600);   //Begin serial communication
  pinMode(levelPin, INPUT); //Initialize the level sensor pin as an input
}
 
void loop(void) {
  levelReading = digitalRead(levelPin); //Read the digital value of the level sensor
  Serial.print("Level sensor value: "); //Print out
  Serial.println(levelReading);
  delay(10); //Short delay
}

A potentiometer is a type of resistor, the resistance of which can be adjusted using a mechanical lever. The device consists of three terminals. The resistor between the first and the third terminal has a fixed value, but the second terminal is connected to the lever. Whenever the lever is turned, a slider of the resistor is moved; it changes the resistance between the second terminal and side terminals. Variable resistance causes the change of the voltage, which can be measured to determine the position of the lever. Thus, the potentiometer output is an analogue value.

Potentiometers are commonly used as a control level, for example, a volume level for the sound and joystick position. They can also be used to determine the angle in feedback loops with motors, such as servo motors.

An example code:

//Potentiometer sensor output is connected to the analogue A0 pin
int potentioPin = A0; 
//The analogue reading from the potentiometer output
int potentioReading;      
 
void setup(void) {
  //Begin serial communication
  Serial.begin(9600);   
  //Initialize the potentiometer analogue pin as an input
  pinMode(potentioPin, INPUT); 
}
 
void loop(void) {
  //Read the analogue value of the potentiometer sensor
  potentioReading = analogRead(potentioPin); 
  Serial.print("Potentiometer reading = "); //Print out
  Serial.println(potentioReading);
  delay(10);
}

An IMU is an electronic device consisting of an accelerometer, gyroscope and sometimes a magnetometer. The combination of these sensors returns the object's orientation in 3D space. IMU sensors can present the object's current position and movement, expressed with at most six values called the DOF (Degrees Of Freedom). Three values express the linear movements that can be measured by the accelerometer:

• moving forward/backwards,
• moving left/right,
• moving up/down.

Another three values present the rotation in three axes that can be measured by gyroscope:

• roll side to side,
• pitch forward and backwards,
• yaw left and right.

A gyroscope is a sensor that measures the angular velocity. The sensor is made with microelectromechanical system (MEMS) technology and is integrated into the chip. The sensor output can be analogue or digital, using I2C or SPI interface. Gyroscope microchips can vary in the number of axes they can measure. The available number of the axis is 1, 2 or 3 axes in the gyroscope. A gyroscope is commonly used with an accelerometer to precisely determine the device's orientation, position and velocity. Gyroscope sensors are used in aviation, navigation and motion control.

An accelerometer measures the acceleration of the object. The sensor uses microelectromechanical system (MEMS) technology, where capacitive plates are attached to springs. When acceleration force is applied to the plates, the capacitance is changed; thus, it can be measured. Accelerometers can have 1 to 3 axis. The 3-axis accelerometer can detect the device's orientation, shake, tap, double tap, fall, tilt, motion, positioning, shock or vibration. Outputs of the sensor are usually digital interfaces like I2C or SPI. The accelerometer is often used with a gyroscope for precise measurement of the object's movement and orientation in space. Accelerometers are used to measure objects' vibrations, including cars, industrial devices, and buildings, and to detect volcanic activity. In IoT applications, it can also be used for accurate motion detection for medical and home appliances, portable navigation devices, augmented reality, smartphones and tablets.

A magnetometer is a sensor that can measure the device's orientation to the Earth's magnetic field. A magnetometer is used as a compass in outdoor navigation for mobile devices, robots, and quadcopters.

There are different elements available that allow measuring linear accelerations, angular accelerations, and magnetic fields, all in three axes. There exist elements that combine two (called 6-axis or 6-DOF) or all (9-axis, 9-DOF) measurement units. Popular integrated circuits are MPU6050 (3-axes gyro + 3-axes accelerometer), MPU9250, and BNO055 (3-axes gyro, 3-axes accelerometer, 3-axes magnetometer). All of them can be programmed in an Arduino environment with the use of dedicated libraries. The latter automatically calculates additional information like gravity vector, and absolute orientation expressed as an Euler vector or as a quaternion.

Take a photo of MPU6050.

Take a photo of MPU9250.

The example code:

//Library for I2C communication
#include <Wire.h>
//Downloaded from https://github.com/adafruit/Adafruit_Sensor
#include <Adafruit_Sensor.h>
//Downloaded from https://github.com/adafruit/Adafruit_BNO055 
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>
Adafruit_BNO055 bno = Adafruit_BNO055(55);
void setup(void)
{
bno.setExtCrystalUse(true);
}
void loop(void)
{
//Read sensor data
sensors_event_t event;
bno.getEvent(&event);
//Print X, Y And Z orientation
Serial.print("X: ");
Serial.print(event.orientation.x, 4);
Serial.print("\tY: ");
Serial.print(event.orientation.y, 4);
Serial.print("\tZ: ");
Serial.print(event.orientation.z, 4);
Serial.println("");
delay(100);
}

A temperature sensor is a device that is used to determine the temperature of the surrounding environment. Most temperature sensors work on the principle that the material's resistance changes depending on its temperature. The most common temperature sensors are:

• thermocouple – consists of two junctions of dissimilar metals,
• thermistor – includes the temperature-dependent resistor,
• resistive temperature detector – is made of a pure metal coil.

The main difference between sensors is the measured temperature range, precision and response time. Temperature sensor usually outputs the analogue value, but some existing sensors have a digital interface ^[50]. The thermistor can have a positive (PTC) or negative (NTC) thermal coefficient. For PTC, resistance rises with rising temperature, while resistance decreases in higher temperatures for NTC. An analogue thermistor must calculate the value read if the result should be presented in known units. Digital temperature sensors usually express the result in Celsius degrees or other units.

Temperature sensors are most commonly used in environmental monitoring devices and thermoelectric switches. In IoT applications, the sensor can be used for greenhouse temperature monitoring, warehouse temperature monitoring to avoid freezing, fire suppression systems and tracking the temperature of the soil, water and plants.

An example code:

//Thermistor sensor output is connected to the analogue A0 pin
int thermoPin = 0; 
//The analogue reading from the thermistor output
int thermoReading;      
 
void setup(void) {
  //Begin serial communication
  Serial.begin(9600);   
  //Initialize the thermistor analogue pin as an input
  pinMode(thermoPin, INPUT); 
}
 
void loop(void) {
  //Read the analogue value of the thermistor sensor
  thermoReading = analogRead(thermoPin); 
  Serial.print("Thermistor reading = "); //Print out
  Serial.println(thermoReading);
  delay(10);
}

Digital temperature sensors automatically convert the temperature reading into some known unit, e.g. Celsius, Fahrenheit or Kelvin Degrees. Digital thermometers use one of the popular communication links. An example of a digital thermometer is DS18B20 by Dallas Semiconductors. It uses a 1-Wire communication protocol.

Take DS18B20 photo DS18B20 photo Draw DS18B20 connection DS18B20 connection

#include <OneWire.h>           // library for 1-Wire protocol
#include <DallasTemperature.h> //library for Dallas DS18B20 digital thermometer
 
const int SENSOR_PIN = 13;     //DS18B20 pin
 
OneWire oneWire(SENSOR_PIN);   //oneWire class
DallasTemperature tempSensor(&oneWire); // connect oneWire to DallasTemperature library
 
float tempCelsius;       // temperature in Celsius degrees
 
void setup()
{
  Serial.begin(9600);    //initialize serial port
  tempSensor.begin();    //initialize DS18B20
}
 
void loop()
{
  tempSensor.requestTemperatures();             //command to read temperatures
  tempCelsius = tempSensor.getTempCByIndex(0);  //read temperature (in Celsius)
 
  Serial.print("Temp: ");
  Serial.print(tempCelsius);    // print the temperature
  Serial.println(" C");
 
  delay(1000);
}

A humidity sensor (hygrometer) is a sensor that detects the amount of water or water vapour in the environment. The most common principle of air humidity sensors is the change of capacitance or resistance of materials that absorb moisture from the environment. Soil humidity sensors measure the resistance between the two electrodes. The resistance between electrodes is influenced by soluble salts and water amounts in the soil. The output of a humidity sensor is an analogue signal value or digital value sent with some popular protocols ^[51].

Examples of IoT applications are monitoring of humidors, greenhouse humidity, agriculture, art gallery and museum environment.

An example code ^[52]:

#include <dht.h>
 
dht DHT;
 
#define DHT_PIN 7
 
void setup(){
  Serial.begin(9600);
}
 
void loop()
{
  int chk = DHT.read11(DHT_PIN);
  Serial.print("Humidity = ");
  Serial.println(DHT.humidity);
  delay(1000);
}

A sound sensor is a sensor that detects vibrations in a gas, liquid or solid environment. At first, the sound wave pressure makes mechanical vibrations, which transfer to changes in capacitance, electromagnetic induction, light modulation or piezoelectric generation to create an electric signal. The electrical signal is then amplified to the required output levels. Sound sensors can be used to record sound and detect noise and its level.

Sound sensors are used in drone detection, gunshot alert, seismic detection and vault safety alarms.

An example code:

//Sound sensor output is connected to the digital 7 pin
int soundPin = 7; 
//Stores sound sensor detection readings
int soundReading = HIGH; 
 
void setup(void) {
  //Begin serial communication
  Serial.begin(9600);   
  //Initialize the sound detector module pin as an input
  pinMode(soundPin, INPUT); 
}
 
void loop(void) {
  //Read the digital value whether the sound has been detected
  soundReading = digitalRead(soundPin); 
  if (soundPin==LOW) { //When sound detector detected the sound
    Serial.println("Sound detected!"); //Print out
  } else { //When the sound is not detected
    Serial.println("Sound not detected!"); //Print out
  }
  delay(10);
}

Gas sensors are a sensor group that can detect and measure the concentration of certain gasses in the air. The working principle of electrochemical sensors is to absorb the gas and create current from an electrochemical reaction. For process acceleration, a heating element can be used. For each type of gas, different kind of sensor needs to be used. Multiple types of gas sensors can also be combined in a single device. The single gas sensor output is an analogue signal, but devices with multiple sensors used have a digital interface. The smoke or air pollution sensors usually use LED or laser that emits light and a detector which is normally shaded from the light. If there are particles of smoke or polluted air inside the sensor, the light is reflected by them, which can be observed by the detector.

Gas sensors are used for safety devices, air quality control, and manufacturing equipment. IoT applications include air quality control management in smart buildings and smart cities or toxic gas detection in sewers and underground mines.

An example code:

int gasPin = A0; //Gas sensor output is connected to the analog A0 pin
int gasReading; //Stores gas sensor detection reading
 
void setup(void) {
  Serial.begin(9600);   //Begin serial communication
  pinMode(gasPin, INPUT); //Initialize the gas detector pin as an input
}
 
void loop(void) {
  gasReading = analogRead(gasPin); //Read the analog value of the gas sensor
  Serial.print("Gas detector value: "); //Print out
  Serial.println(gasReading);
  delay(10); //Short delay
}

The smoke sensors usually emit LED light, and a detector is normally shaded from the light. If there are particles of smoke present inside the sensor, the light is reflected by them, which can be observed by the detector. Smoke detectors are used in fire alarm systems. The air pollution sensors usually use a laser directed onto the detector. Between the laser and detector, the thin stream of air flows and pollution particles create shades on the detector. Thus the detector can distinguish the sizes of particles and count the number of them. Air pollution sensors are used in air purifiers and in air quality measurement stations to monitor current air conditions, mainly in cities. Because the air pollution sensor generates more data, the serial connection is often used for reading measurement results. An example of an air pollution sensor that can count particles of PM1.0, PM2.5, and PM10 is PMS5003.

Draw PMS5003 connection PMS5003 photo Draw PMS5003 connection PMS5003 connection

An example code that uses the PMS5003 sensor:

#define length 31   //Size of the data frame from the sensor 
                    //(does not include the start indicator - 0x42)
unsigned char buffer[length];
 
int PM_1_0=0;    //variale to hold PM1.0 value of the air sensor
int PM_2_5=0;    //variale to hold PM2.5 value of the air sensor
int PM_10=0;     //variale to hold PM10 value of the air sensor
 
void setup()
{
//Initialise the serial port for 9600 b/s (should be compatible with the sensor type)
  Serial.begin(9600);   
}
 
void loop()
{
  if(Serial.find(0x42)) //detecting 0x42 means start of data frame from sensor
  {    
    Serial.readBytes(buffer,length);
    if(buffer[0] == 0x4d)
    {  
      PM_1_0=((buffer[3]<<8) + buffer[4]); //count PM1.0 value of the air detector module
      PM_2_5=((buffer[5]<<8) + buffer[6]);//count PM2.5 value of the air detector module
      PM_10 =((buffer[7]<<8) + buffer[8]); //count PM10 value of the air detector module 
 
      Serial.print("PM1.0: ");  
      Serial.print(PM_1_0);
      Serial.println(" ug/m3");            
 
      Serial.print("PM2.5: ");  
      Serial.print(PM_2_5);
      Serial.println(" ug/m3");     
 
      Serial.print("PM10:  ");  
      Serial.print(PM_10);
      Serial.println(" ug/m3");   
    } 
  }
}