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

ITT Group

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

Riga Technical University

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

Silesian University of Technology

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

Tallinn University of Technology

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

SIA RobotNest

• Karlis Berkolds, M. sc., Eng.

IT Silesia

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

University of Messina

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

ITMO University

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

Graphic Design and Images

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

Technical Correction

• Eryk Czekalski

Reviewers (1st edition)

• 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 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, e.g. 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 who 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!

This content was implemented under the following 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,
• Horizon 2020 Research Innovation and Staff Exchange Programme (RISE) under the Marie Skłodowska-Curie Action, Programme H2020-EU.1.3.3. - Stimulating innovation by means of cross-fertilisation of knowledge, Grant Agreement No 871163: Reactive Too - Reliable Electronics for Tomorrow’s Active Systems.
• International project co-financed by the program of the Minister of Science and Higher Education entitled “PMW” in the years 2021 - 2025; contract no. 5169/H2020/2020/2

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 get in touch with 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 around 3.2 billion.

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

The book composes a comprehensive guide for a variety of education levels. A brief classification of the contents regarding target groups may help in a selective reading of the book and ease in finding the correct chapters for the desired education level. To inform a reader about the proposed target group, icons are assigned to the chapters level 1 (top) and 2nd level chapters. The list of icons and their reflection on the target groups is presented in the table 1.

Table 1: List of icons presenting content classification and corresponding target groups

Icon	Target group
	General Public audience: all those who want to get familiar with basic concepts but do not necessarily step into technical details.
	Bachelor and Engineering level students
	Masters students
	Enterprise, VETS and technical

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 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 has 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 have 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 the 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 make 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 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. Embedded systems do not have to be network-enabled or have a unique identity, while IoT devices do. Moreover, IoT systems are complex and multilayered, often introducing cloud-based parts, while embedded systems are stand-alone devices. Indeed, one can say that an IoT device is a network-enabled embedded system.

While the IoT, as a technical solution paradigm to certain problems, is relatively well understood and applied, it keeps evolving to address a more complex and diverse spectrum of tasks. It follows the trends of AI integration and advancement into hardware systems, providing close-to-problem AI capabilities - edge AI. Therefore, the new AI-enabled IoT systems provide low-latency intelligent solutions capable of online or offline training through applications of machine learning techniques. Regarding model flexibility, the microprocessors with dedicated AI co-processing or GPU (Graphical Processing Unit) have limited memory and processing speed; they significantly extend application possibilities. A good example is modern cell phones, capable of complex AI-drive tasks like photo or video editing, content generation, and other functions. The same techniques might be applied for real-time data analysis, decision-making and other IoT-specific applications.

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 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, e.g. nVidia Jetson Nano or Xavier series. Those devices can be battery or mains-powered. Often, they are green energy powered: e.g. 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 are 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 storage, Business Intelligence tools, and 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, Raspberry Pi can be an end-node (Edge) class device and a Fog class, working as a data aggregator and analytical device.

IoT is 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 AI data processing.

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 for small mobile devices. Therefore, the concepts of future IoT already shifted towards more innovative 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. Fog computing is a new trend in computing that aims to process data near the source. It pushes applications, services, data, computing power, and decision-making away from the centralized 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 has a positive impact on IoT security, e.g., sending preprocessed and depersonalized data to the cloud and providing distributed computing capabilities that are more attack-resistant.

Recent developments in hardware, power efficiency, and a better understanding of IoT data nature, including privacy and security, led to solutions where data is 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 (e.g. biometric data in a raw form). Moreover, distributed data processing can be considered more energy efficient in some scenarios where, e.g. extensive, power-consuming processing can be performed during green energy availability.

While Cloud, Fog, and Edge systems might seem the same to the end user from a functionality perspective, they are very different and provide different performance, scalability, and computing capabilities, which are emphasized in the following comparison.

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 and 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 developments 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. Considering the data traffic generated by each of them through, e.g. 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 through specific standards such as Sensor Web Enablement and Semantic Sensor Networks.
• 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 collected 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 provides for only part of the total population), and administrative byproduct (data collection is a byproduct of an organization’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 local and remote and usually includes preprocessing activities to prepare data for actual 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 organized and formatted, ready for end-users. IoT data visualization is becoming an integral part of the IoT. Data visualization 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, anonymizing 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].

There is a rapid increase in the adoption of IoT in the various sectors (e.g., intelligent transport systems, smart health care, smart manufacturing, smart homes, smart cities, smart agriculture, and smart energy) of the society or economy. IoT technologies are being applied in the various sectors of the economy to increase efficiency, solve technical challenges, and create value to increase companies' earnings and improve user experience. The increasing adoption of IoT technologies in the various sectors of the economy or industry has made IoT technology the pillar of the fourth and fifth industrial revolutions (industry 4.0 and Industry 5.0).

Application domains of the Internet of Things solutions are vast. Some of the applications of IoT include the following^[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 the 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 e.g. 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 abovementioned 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.

Like 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 easily enable personalised, short-volume product manufacturing.

In the healthcare and wellness, IoT applications can monitor and diagnose patients and manage people and medical resources. It allows remote and continuous monitoring of the vital signs of patients to improve medical care and wellness ^[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, a camera attached to the helmet, or a necklace ^[24].

Smart supply chains integrate IoT and other modern information and communication technologies to manage supply chain systems and facilitate the flow of raw materials and finished goods, increasing efficiency and productivity in manufacturing, transportation, retail, distribution, shipping, planning and management. IoT sensors are installed throughout the supply chain infrastructure to collect monitoring data, sent to data analytic platforms for advanced analytics. The analysis results are used for the various stakeholders to make quick decisions and react or respond quickly when necessary. Some tasks are automated using IoT actuators controlled by commands from data analytics platforms that analyse sensor data and then carry out control measures or responses. Some of the IoT use cases in supply chains include:

• Location tracking -the tracking of the location of raw materials and finished goods throughout the supply chain.
• Monitoring the products' physical condition or state during transportation and storage throughout the supply chain.
• Asset monitoring and management (e.g., fleet management) -monitoring the various assets deployed throughout the supply chain to facilitate the smooth functioning of the supply chain.
• Stock management -managing the available warehouse stocks, deliveries and orders.

Integrating IoT into supply chains and other technologies such as AI and blockchains transforms supply chains, increasing efficiency and productivity. The supply chain bottlenecks experienced during and after the COVID-19 period demonstrate the need to increase the efficiency of supply chains even though they are getting more complex. The deployment of IoT and other modern technologies to automate some of the processes to increase efficiency and productivity is very important.

IoT-supported retail stores, used to automate some of the processes in supermarkets and small and medium-sized shops. It is driven by the shortage of workers to work in retail stores, the need to reduce costs, and to reduce waiting lines in retail stores. Using IoT technologies to automate some processes increases efficiency and productivity, especially in inventory management, supply chain management, and customer service. Some of the IoT use cases in retail stores include:

• Automated checkout points where customers can serve themselves without needing customer service agents.
• Surveillance monitoring of the entire supermarket or store.
• Monitoring of the products in the supermarkets and control of the environmental conditions to prolong the shelf life of perishable products.
• Smart shelves for tracking the stock on the shelves.
• Robots to automate some of the tasks that can be executed repeatedly without human intervention.
• IoT-based shopping assistant that monitors the stock of the consumers at home and then reminds them of what they need to buy (and could even order them online).

Supermarkets and shops are becoming smarter with the increased deployment of IoT technologies to automate some of their processes to increase efficiency and productivity and decrease cost. With the gradual decrease in the cost of IoT technologies, supermarkets and small and medium-sized stores will adopt IoT technologies to automate some of their processes.

IoT-based Intelligent Transport Systems (IoT-ITS), that integrate modern Information and Communication Systems and modern technologies into transportation systems to increase productivity and efficiency. It involves using IoT sensors to collect real-time data, which enables real-time monitoring and control to increase the productivity and efficiency of transportation systems and to satisfy some design goals (e.g., reduction of emissions and accidents, improvement of user experiences). Some of the benefits of intelligent transportation systems include:

• Reduction of road traffic, which increases user experience, reduces energy consumption and lowers emissions.
• Enable optimal use of critical resources in transportation systems and increase efficiency and productivity.
• Reduces accidents and facilitates timely emergency response, increasing the safety and security of users.
• Reduces emissions, enabling the transition into cleaner and sustainable transportation systems.
• Increases productivity and efficiency in transportation systems, increasing returns on investments.
• Increase user experience, e.g., reduce the time users spend waiting in traffic (efficient traffic management), reduce the waiting time of users of public transport systems (reduces delays).

In IoT-based Intelligent transport systems (IoT-ITS), IoT sensors are used to gather data sent to computing platforms at a control centre when the data is processed and analysed. The analysis results inform various stakeholders for quick decision-making and timely response. The results of the computations can be sent to manipulate actuators to control some systems within the intelligent transportation system. Some of the use cases of Intelligent Transport Systems are:

• Optimal traffic routing based on real-time traffic monitoring.
• Providing relevant information (weather reports, state of the roads, traffic) to road users to ensure their safety and security and to increase their user experience.
• Assist drivers in searching for available parking places, including cheaper and free parking spaces in their vicinity.
• Timely detection and response to traffic incidents (accidents).
• Real-time traffic rerouting when necessary, especially when the condition of the roads is unsuitable or when there is an emergency.
• Automatic control of speed limits.
• Monitoring of structural properties of the public transport infrastructure to inform users to be aware, ensuring their safety.

Internet of Military Things (IoMT), also known as the Military Internet of Things (M-IoT) or Battlespace IoT (B-IoT), is the integration of IoT sensor and actuator devices into military weapons and battlefield infrastructure for information gathering and automation of some processes, increasing the efficiency of intelligence gathering and combat. Some battlefield assets such as ships, aircraft, battle tanks, weapons, munitions, drones, tucks, soldiers, and operating bases are connected to enable seamless interoperability and efficient cooperation between the various units and systems on the battlefield. The massive amount of data gathered by the sensors embedded within the different military systems provides the relevant stakeholders within the military chain of command a comprehensive situational awareness, improving the efficiency of the command and control and combat operations, especially in complex and diverse conflict zones.

Using sensor networks, actuators and robots on the battlefield to increase situational awareness, risk assessment, response time, and precision is not new. Still, the rapid evolution of IoT technologies and artificial intelligence (AI) will radically transform the future battlefields. The combination of IoT, robotics, and AI will automate some military operations, increasing flexibility and precision during combat and reducing the number of casualties in terms of the number of soldiers killed during combat operations. A significant challenge with M-IoT or B-IoT is cyber security. Incorporating IoT sensors and actuator networks within the military systems and infrastructure exposes them to cyber security risks. A cyber security breach could compromise or disrupt command, control, and combat operations.

Green and sustainable IoT is the application of IoT technologies to reduce pollution and the impact of climate change on the environment and livelihoods. It also involves the application of IoT for resource management and conversations. Sensors are deployed to collect data from the environment. The data collected is analysed for rapid and timely decision-making and control, reducing pollution and conserving critical resources required to sustain ecosystems and human progress. Some of the green and sustainable IoT applications include the following:

• Smart agriculture: One use case example is IoT-based smart irrigation systems designed to reduce water usage in agricultural operations.
• Smart energy: Applying IoT technologies to reduce energy consumption (reducing the carbon footprint) and improve electricity infrastructure efficiency.
• Environmental monitoring: Using IoT to monitor and control the level of pollution in the environment and to detect environmental disasters and prepare for them before they occur.
• Resource management: Application of IoT to conserve critical resources like water and wildlife.
• Supply chains: Increasing the efficiency of supply chains to reduce their carbon emission and other forms of pollution.

The IoT applications discussed above are just a few of the IoT applications that are being developed and adopted in various industries. New IoT application use cases are being designed, and a detailed discussion of almost all IoT applications is out of the scope of this book. However, the IoT applications presented above are a broad category of IoT applications.

At the perception layer of IoT systems usually some kind of computer operates. Depending on the complexity of the device the computational power of it does not need to be very high. Its design is similar to the Embedded System with the difference that the IoT node device should be equipped with some communication module. We can denote the IoT end-device as the constrained computer, built with four modules: a sensing unit, a processing unit, a communication unit, and a power supply unit, as presented in the figure 6. An essential element of the IoT node is the software, capable of performing a set of functionalities.

Every computer consists of at least the central processing unit (processor), memory, and peripheral devices, all connected with address, data and control buses. In modern embedded systems architectures usually, the mentioned elements are integrated into one chip forming the single-chip computer. There exists a variety of different kinds of processors with capabilities adjusted to the target system requirements. The most universal is the general-purpose processor which can be a microprocessor, microcontroller, or embedded processor. The microprocessor as the device that requires connection of external peripherals and memory is not currently used in embedded or IoT systems design. It gave the leading place to microcontrollers, which are representatives of one-chip computers. Embedded processor being the extended version of microcontroller is also the popular choice. If such an integrated circuit also contains expansion modules, eg, a radio module, it is called System on Chip (SoC). IoT nodes can also be built using the Digital Signal Processor (DSP), especially if they implement some audio or video signal processing. For high-volume device production Application Specific Integrated Circuits can be used, designed for specific, specialised use. One type of ASIC can be an Application Specific Processor (ASP). There exist also technologies of programmable hardware design implemented as the matrices of universal logic units called Field Programmable Gate Array. FPGA technology allows for flexible reconfiguration of the hardware enabling implementation of different microprocessors with other elements of the computer in one universal integrated circuit. This can be achieved with the use of ready descriptions of electronic units written in special hardware description language (Verilog, VHDL). Currently, the most popular choice to design the IoT node is some kind of single-chip computer: microcontroller, embedded processor or System on Chip. The element of this type 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, specialised coprocessors for ciphering and deciphering, compression and decompression, video and audio coding and decoding, and other modules. Wireless networking capability makes Microcontrollers even more complex in the IoT world. 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 selected 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 (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 are the most popular models and a brief discussion of 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, e.g. 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, e.g. 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 7 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 hardware development capabilities.

The bare metal programming model is considered the only one that enables 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 (e.g. 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 8 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 configurable firmware (IoT frameworks) are available for various IoT devices. This development model focuses on reconfiguring the ready-to-use 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 recompilation process is usually very complex, and understanding all relations and development toolchains is sometimes more complicated than developing a solution from scratch as a bare metal. Some open-source firmware (like Tasmota, ESPhome, and OpenBeken) offer high flexibility and configureability, making their use the simplest and fastest way to develop IoT devices. In contrast, proprietary firmware does not bring this opportunity at all and is delivered “as is” with a predefined set of features. Software modifications are not allowed, and configuration is limited to changing the state of the elements from simply switching them on and off to setting up access and credentials. This usually does not bring capabilities to modify the algorithm, eventually to choose a behaviour from the predefined list proposed by the firmware 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, firmware operation is dependent on some external resources (e.g. authorisation via a cloud or firmware updates delivered with this channel).

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

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. Configuration in proprietary firmware scenarios can be provided indirectly via a cloud solution that raises serious questions about privacy (e.g. configuring your private WiFi router credentials via a public or 3rd party cloud, not directly to the device). It is worth mentioning that IoT hardware used to be compatible with more than one firmware, and proprietary ones can be replaced with alternative open-source firmware, e.g. Tasmota ^[28], ESPHome ^[29], OpenBeken ^[30], ESPEasy ^[31], ESPurna ^[32]. Unfortunately, the replacement process usually requires specialised skills like soldering because, in most cases, first-time reflashing needs a physical connection with the chip.

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 contains both SDK and 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, e.g. 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 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 expected to include a task scheduling mechanism to run multiple tasks asynchronously. A common is to use the FreeRTOS ^[33] or its modified versions for the specific hardware platform provided by the hardware vendor, e.g. as in the case of the ESP32 ^[34] 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 controls 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 periodic 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 (e.g. 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 and 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 ^[35] 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 STMicroelectronics' STM32CubeIDE (image 10). In contrast, others use already available universal code editing solutions and integrate with them, e.g. in the form of plugins or extensions.

Detailed instructions on the tools necessary to set the development environment, e.g., the STM32 WB chip family, are presented on the STM's YouTube channel ^[37].

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 11). 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 ^[38]), which 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 12: Arduino IDE ^[39]) that is intended to be an entry-level development environment. It can be extended beyond genuine Arduino boards, e.g. with the Espressif toolchain for ESP8266 and ESP32. This software, however, is very limited in features and is suitable only for simple projects.

Several 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 and browsing the web for tools, samples and libraries. Moreover, handling libraries they use for development is time-consuming and involves instant monitoring of changes, manual copy-paste operations on files, etc. Moreover, it has to be done individually for every project.

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 (e.g. 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 also works as a GUI for PlatformIO. In the following figures, we present its look and UI when integrated with Visual Studio Code (figures 13, 14 and 15).

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, e.g. in the figure 13, 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 ^[40]. 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, e.g. 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 ^[41]. 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 it brings some overhead and does not let the developer push the devices to their limits. 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 a chosen type, dependent on the kind of data. Some common data types and how to use variables are shown below.

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 it can be used. Further, 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 program's execution. 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 – the 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

Typedef Specifier
A typedef specifier can give another name for existing types or declare a new one. Renaming types is possible, but software development frameworks already have several aliases. 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;

Enum Declaration
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, e.g., 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 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 instead 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 initialise 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 declare a pointer pointing to the array's first element and pass it to the function. Then, by 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 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 a 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 operator's left and right 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
}

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 specifies the number of execution times of the 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 the loop is repeated.

In the example above, the Arduino function digitalWrite is used. It sets the logical state high or low at the chosen pin. If an 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 isn't easy to navigate through the code that occupies many screens. In such a situation, subprograms can help. Subprograms are named functions in C and C++; while they are associated with an object, they are called 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. Grouping many functions by creating a library stored in a separate file is possible. This is how external libraries are constructed.

Functions are the set of statements that are always executed when the function is called. A function can accept arguments as input data and return the resulting value. Two functions from the Arduino programming model 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 as follows:

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 helpful software. This usually comes as a set of functions designed to handle specific tasks, e.g. interfacing with a family of graphical displays or communicating using the chosen protocol. Functions created for one purpose are grouped, forming the library. The number of libraries and their different version is so significant that software developers use a particular 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 modifying library code. For this reason, the library contains a placeholder variable that can be assigned an executable code (a function body). 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 (e.g., 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 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.

Manipulating Structure's Data
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 = "Lime Street";

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 = {"Gliwice", "44-100", "1 Lime", -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, e.g. 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, e.g. when you do not want to expose some functions but 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, e.g. 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 (e.g. 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 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 definitions (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 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.

Delay
The simplest solution to make functions work for a particular time is to use the delay() ^[42] function. The 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 16. Some tasks, e.g. 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
The millis() ^[43] 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 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, one can check if the desired time has passed. Meanwhile, it is possible to handle other tasks instead of blocking execution, as presented in the algorithm in figure 17.

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: e.g. 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.

Every microcontroller has many pins that can be used to connect external electronic elements. In the examples shown in previous chapters, LED was used. Such LED can be connected to a chosen General Purpose Input Output (GPIO) pin and can be controlled by setting a HIGH or LOW state. Below are some details of the functions that allow the manipulation of GPIOs using the Arduino framework. In the next chapter, analogue signals will be considered.

Microcontrollers' digital inputs and outputs allow for connecting different sensors and actuators to the board. Digital signals can take two values – HIGH(1) or LOW(0). These states correspond to high voltage (usually corresponding to the power supply voltage of the microcontroller) and low voltage (around 0V). These inputs and outputs are used in applications when the signal can have only two states.

pinMode()

The function pinMode() is essential to indicate whether the specified GPIO pin will behave like an input or an output and may also control special features. This function does not return any value. Usually, the mode of a pin is set in the setup() function of a program – only once, during program initialisation.

The syntax of a function is the following:

pinMode(pin, mode);

The parameter pin is the number of the pin.

The parameter mode can have three different values – INPUT, OUTPUT, INPUT_PULLUP, depending on whether the pin will be used as an input or an output. The INPUT_PULLUP mode turns on the internal pull-up resistor between the power supply and the pin itself. It ensures that if the pin remains unconnected, the logic state will be stable and equal to HIGH. More about pull-up resistors can be found on the Arduino homepage ^[44].

digitalWrite()

The function digitalWrite() writes a HIGH or LOW value to the pin. This function is used for digital pins, such as turning on/off LEDs. This function also does not return any value.

The syntax of a function is the following:

digitalWrite(pin, value);

The parameter pin is the number of the pin. The parameter value can take values HIGH or LOW. If the mode of the pin is set to the OUTPUT, the HIGH sets voltage to power supply voltage and LOW to 0 V.

Using this function for pins set to have the INPUT mode is also possible. In this case, HIGH or LOW values enable or disable the internal pull-up resistor.

digitalRead()

The function digitalRead() works in the opposite direction than the function digitalWrite(). It reads the pin's value that can be either HIGH or LOW and returns it.

The syntax of a function is the following:

digitalRead(pin);

The parameter pin is the number of the pin.

On the opposite of the functions viewed before, this one has the return type, and it can take a value of HIGH or LOW.

In the code below, the button connected to pin 3 controls the LED connected to pin 4.

#define BUTTON_pin 3
#define LED_pin 4
 
void setup() {
  pinMode(LED_pin, OUTPUT);
  pinMode(BUTTON_pin, INPUT_PULLUP);
}
 
bool state;
 
void loop() {
  state = digitalRead(BUTTON_pin); //reading digital state of the input
  digitalWrite(LED_pin, state);    //writing state back to the output
}

The analogue inputs and outputs are used when the signal can take a range of values, unlike the digital signal that takes only two values (HIGH or LOW).

For measuring the analogue signal, microcontrollers have built-in analogue-to-digital converter (ADC) that returns the digital value of the voltage level. Usually, the binary number corresponds to the input voltage, not the value in Volts. The number of bits of the output value depends on the accuracy and internal construction of the converter and usually varies between 8 and 12.

analogRead()

The function analogRead() is used for analogue pins (A0, A1, A2, etc.) and reads the value on the analogue pin.

The syntax of a function is the following:

analogRead(pin);

The parameter pin is the pin's name whose value is read.

The return type of the function is the integer value. On the Arduino Uno boards, it ranges between 0 and 1023. The reading of each analogue input takes around 100 ms.

Unlike analogue input, the analogue output does not generate varying voltage directly on the pin. In general, it uses the technique known as (Pulse Width Modulation (PWM)) that generates a high/low square signal of stable frequency but varying duty cycle (ratio of active and passive periods of the signal). Details are described later in the book. Because the PMW signal can provide different average power to the external element, e.g. LED, it can be considered analogue output.

analogWrite()

The function analogWrite() is used to write an analogue value of the integer type as an output of the pin. An example of use is turning on/off the LED with various brightness levels or setting different speeds of the motors. The value written to the pin stays unchanged until the next value is written to the pin.

The syntax of a function is the following:

analogWrite(pin, value);

The parameter pin is the number of the pin.

The parameter value is the PWM signal value that can differ from 0 (off) to 255 (100% on).

This function does not have the return type.

The following example shows reading an analogue value from the A0 input of an Arduino Uno board and writing the analogue value to the output that can control the intensity of the LED.

#define LED_pin 3          //the pin number is chosen to support PWM generation
 
void setup() {
  pinMode(LED_pin, OUTPUT);      
}
 
int value;                 //variable that holds the result of analogue reading
 
void loop() {
  value = analogRead(A0);  //analogRead on Arduino Uno returns the value 0-1023
  value = value >> 2;      //it should be converted to the value 0-255
  analogWrite(LED_pin, value); //writing converted value to PWM output
}

Interrupt is a signal that stops the normal execution of a program in the processor and starts the function assigned to a specific source. This function 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 critical 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() {  
  pinMode(13,OUTPUT);            //Define LED pin
  pinMode(2,INPUT_PULLUP);       //Define button pin
  attachInterrupt(digitalPinToInterrupt(2),ButtonIRS,FALLING); 
                                 //Attach interrupt to button pin
}
 
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 patterns, such as non-blocking algorithms, 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 complex technique requires an external debugger using an interface 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 using 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 several 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 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 one can send a message from the MCU to the terminal and the opposite. This can be used as a simple user interface. All configuration above 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 the MCU every time a character comes to the serial port using 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, e.g. 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 using Serial.read() gets another character from the FIFO queue behind the serial port software buffer. As most 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 usage ^[45].

Hardware buttons tend to vibrate when switching. This physical effect causes bouncing of the state forth and back, generating, in fact, many 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 18.

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 using 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 an excellent 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 19).

• 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), the 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 released 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 button PRESSED callback
      ButtonPressed = Callback;
    }
    void fRegisterBtReleaseCalback(void (*Callback)()) {  
                                   //Function registering 
                                   //a button 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 detecting 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, e.g., 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 (e.g. 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 (e.g. instead of changing the input voltage to reflect the whole measurement range, you can regulate internal amplification and sensitivity.

A special note on analogue inputs in ESP32
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 ^[46].

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).

A special note on ESP32 MCUs
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, e.g. 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: e.g. 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 ^[47].

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, e.g. for external SPI flash) can trigger an interrupt; thus, there is much higher flexibility in, e.g., the use of user interface devices such as buttons.

A special note on ESP8266 and ESP32
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, e.g., 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.

A special note on ESP32 MCUs
The number of hardware timers varies between family members. Most ESP32s have 4, but ESP32-C3 has only two ^[48]. 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 (e.g. 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:

• 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 PCs. It has full access to the GPIO, however.
• Micropython is dedicated to SoCs and is distributed as the firmware that must be flashed into the device. Commonly, Micropython exposes serial communication on dedicated pins, exposing a Python console that looks similar to the command line Python interface in the PCs

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 ^[49]. It is a niche, still fully functional and solid solution. Its newer versions are available only as a commercial product, however.

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 ^[50]. 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

The following chapters present Python coding elements specific to the microcontrollers. A complete 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, standard with Arduino framework, that also 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 ^[51] and requires GUI.
• Simple code can be authored in the terminal using any text editor (e.g. 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.

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.

Programming in Python is quite easy. In case you're using a Raspberry Pi with Python installed, once you access the console, you can run the following code:

print("Hello IoT")

You can store a program in a text file (usually with an extension .py) or interactively type it inline in Python's console.
Assuming your file is stored in the file named helloworld.py that contains the code above, an execution and its result are presented on the screen as in figure 20.

Python has an interactive console that lets one type the code in. To exit back to the command line, it is necessary to execute the quit() function (figure 21).

An IDE makes programming in Python more comfortable than using a command line. There are many solutions, such as Visual Studio Code + plugins, but perhaps the easiest to use is Thonny. A sample video guide on installing and writing the first program is available on YouTube ^[52].

MicroPython implements the Python programming language optimized for microcontrollers and embedded systems that are resource-constrained devices. It is simple and enables rapid prototyping.

Here are some key features and characteristics of MicroPython:

1. MicroPython is designed to run on devices with limited memory and processing power. It has a small storage and RAM footprint.
2. MicroPython is compatible with Python 3 syntax.
3. MicroPython includes a Read-Eval-Print Loop (REPL), which allows developers to run interactively and test code on a microcontroller line by line and evaluate results immediately. This feature is invaluable for debugging and tracing.
4. MicroPython provides a rich set of libraries and modules for interacting with hardware components such as GPIO pins, sensors, motors, displays and networking capabilities that make it suitable for building IoT devices.
5. MicroPython is designed to be cross-platform. including popular ones like the ESP8266, ESP32, Raspberry Pi Pico, and more. Developers should be aware of the hardware limitations that somehow reduce code portability.
6. MicroPython has a growing community, shared libraries and sample projects. A package manager called “upip” also enables the installation of additional MicroPython libraries easily.
7. MicroPython is released under an open-source license (typically the MIT License).
8. MicroPython is designed to be power-efficient, crucial for battery-powered and energy-constrained devices.
9. While Micropython is not a real-time operating system (RTOS) itself, it can be used in conjunction with RTOSes to build real-time systems, if only needed.
10. MicroPython is a popular choice for educational purposes: thanks to REPL, the setup of the SDK is simple and quick.

Installation of Micropython usually involves flashing firmware specific to a microcontroller. This firmware contains a Python interpreter and becomes de facto a middleware between hardware and developer used with scripts. Micropython scripts can be executed inline via terminal (REPL), or a file with source code (usually named main.py) can be uploaded to the drive's root folder exposed via USB connection by the MCU firmware.

A website that is a starting point for Micropython is Micropython.org ^[53].

The installation procedure is specific to the hardware platform and sometimes differs slightly from flashing C++-based solutions or burning an OS, as in the case of the RP2040. The main steps to prepare a working environment are presented below:

• Download a Micropython binary image suitable for your hardware.
• Switch the MCU into the bootloader mode that exposes a flash drive: in the case of the RP2040, the easiest way is to hold down the Bootsel button and power on the device while holding.
• Move the firmware file into the flash drive; the device will flash the file to the memory and reboot.
• Connect to the serial port exposed.

Once Micropython is installed in the device, it exposes a terminal (REPL) via serial port, either on the dedicated GPIOs for serial or via serial over USB. Developing directly inline is possible (samples are presented in the following chapters), but it is not convenient for complex code. Complex and multi-file solutions can benefit from uploading files (even multiple) to the device. A file named main.py is automatically executed when the device restarts.

IDEs use those features to simplify development and enable remote code authoring and execution.

Sample Micropython development toolchain installation with Thonny IDE one can find on the web ^[54]. This guide presents development using RP2040.

As developers use PCs to author software, but it is executed in the microcontroller, using a terminal over a serial connection or secure shell (SSH) may not be convenient for larger projects. For this reason, many IDEs can perform remote development with code authored in the IDE on the PC but executed on the MCU. It requires a stable connection between the development host and the microcontroller and sometimes installation of the remote development host. One of the most flexible IDEs, able to act in virtually any scenario of remote development, is Visual Studio Code^[55].

Programming Raspberry Pi with regular Python can also be executed using development tools installed directly on the RPi, e.g. using Thonny^[56]. It is not the case of programming with Micropython that one needs to connect to it remotely. However, installing an external development environment on a PC or Mac computer is usually more convenient. Visual Studio Code comes with a ready solution for both scenarios.

Python
In the case of the RPi programming, VS Code connects to the RPi via Secure Shell (SSH) and installs development tools remotely. The model is present in the figure 22.

Configuring the remote target requires a few simple steps.
Initiate connection to the remote device: over SSH, the target RPi board runs Linux on ARM, here Rasbian, but is also works with other Linux distributions or even remote Docker containers exposing SSH (figures 23 and 24):

Remote development is straightforward, as in the case of the local one (figure 25):

Micropython
In the case of the Micropython, the connection is usually made via a serial port that is exposed either on the device's GPIOs (RX, TX) or as a Serial over USB. Micropython devices commonly expose a filesystem over the USB, alternatively to the Serial over USB. This is usually inducted with an onboard button press during the boot process. Boot system exposition enables an easy firmware (Micropython) update and source file management, such as uploading and downloading the libraries and application source code. A file named 'main.py' is executed automatically on boot if it only exists in the device's root folder and the device is not in the filesystem mode. Some devices (such as RP2040) also provide file management via Serial over USB and thus do not require enabling the filesystem mode manually but rather enable IDE to manage files along with development. For this reason, files can be stored locally and executed with REPL or stored remotely on the Micropython device. A concept of the code development for Micropython is graphically present in the figure 26.

Remote development requires a VS Code plugin to communicate with the Micropython device. One of them is MicroPico, which is dedicated to Raspberry RP2040 (Pico and Pico W), and it can be installed and updated with VS Code extension manager (figure 27).

Code then can be stored locally or remotely and easily executed via the right-click command (figure 28):

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 the values' types as set for variables.

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

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

Numbers
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 also be 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
The list contains a series of values. To declare list variables, use brackets [].

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

The list indexing is zero-based. 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]

Lists aren't limited to a single dimension.

myTable = [[],[]]

In a two-dimensional array, the first number is always the row number, while the second is the column number.

Tuple
Python Tuples are defined as a group of values like a list and can be processed similarly. 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')

Dictionary
The list of key-value pairs defines a Dictionary in Python. This data type holds related information that can be associated with keys. The Dictionary extracts 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 Statements
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
>>>

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

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

elif Statements
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 expressions 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
>>>

Boolean Logic
Python uses logic operators like AND, OR and NOT.

The AND operator uses two arguments and evaluates to TRUE if, and only if, both 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
Operator Precedence uses the mathematical idea of operation order, e.g. multiplication begins performed before addition.

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

while Loop
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 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. The break statement causes the loop to finish immediately when encountered inside a loop.

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
>>>

for Loop

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. The executing function produces one or more results, dependent on the parameters passed to it and provides a re-usable piece of code, still somehow flexible, depending on the parameters.
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 software's memory usage, development cost and maintenance.

Different naming is used for programming language functions, e.g., subroutines, procedures or methods.

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

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

Function bodies can contain one or more return statements. It can be situated anywhere in the function body. A return statement ends the function execution and returns the result, e.g. to the caller. If the return statement does not contain an 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
>>>

Optional Parameters
Functions can be called with optional parameters, also named default parameters. If the function is called without parameters, the default values are used. The following code greets a person. If no person's 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!
>>>

Docstrings
The string is usually the first statement in the function body, which can be accessed with function_name.doc. This is a 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
>>>

Keyword Parameters
The alternative way to make function calls is to use keyword parameters. The function definition remains 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))

Return Values
In the above examples, the return statement exists in sumsub but not in the Hello function. The return statement is not mandatory. If an explicit 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 an 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
>>>

Multiple Values Returning
Any function can return only one object. An object can be a numerical value – integer, float, list or a dictionary. To return, e.g. three integer values, one can return a list or a tuple with these three integer values. It means that the function can indirectly return multiple values. The 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))

Using hardware interfaces with Python requires specific binary libraries. Thus, it is not as easily exchangeable among platforms as the hardware-aware part of the code. Below are some hardware-related samples for Python and Micropython.

The following code presents a sample Python application that flashes an LED connected to Raspberry Pi's GPIO pin 16. 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. For example, Micropython uses a Machine library instead—it covers all the microcontroller's hardware.

import RPi.GPIO as GPIO  
import time
 
def blink(pin):  
    GPIO.output(pin,GPIO.HIGH)  
    time.sleep(1)  
    GPIO.output(pin,GPIO.LOW)  
    time.sleep(1)  
    return  
 
GPIO.setmode(GPIO.BCM)  
GPIO.setup(16, GPIO.OUT)  
 
for i in range(0,5):  
    blink(16)  
GPIO.cleanup()

A code equivalent for the above algorithm to run in Micropython (here for RP2040) looks quite similar:

import machine
import time
 
led=machine.Pin(16, machine.Pin.OUT)
 
def blink():
    led.toggle()
    time.sleep(1)
    led.toggle()
    time.sleep(1)
 
led.value(0)
 
for i in range(5):
    blink()

Similarly to the GPIO, interrupts are hardware-specific; thus, libraries may differ among platforms, hence Python syntax. The sample present below is for Raspberry Pi (regular Python), and the following code is for RPi Pico (RP2040, Micropython).

import RPi.GPIO as GPIO
import time
 
led_last = time.time_ns()
led_state = GPIO.LOW
 
GPIO.setmode(GPIO.BCM)
GPIO.setup(16, GPIO.OUT, initial=led_state)
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 
def btnHandler(pin):
    global led_test, led_state
    if (led_state==GPIO.LOW):
        led_state=GPIO.HIGH
    else:
        led_state=GPIO.LOW
    GPIO.output(16, led_state)
 
GPIO.add_event_detect(17, GPIO.FALLING, callback=btnHandler, bouncetime=200)
 
while(True):
    time.sleep(0)

The sample code for RP2040 Micropython is present below, and its implementation live, via serial port, directly on the MCU is present in the figure 29:

import machine
import time
import utime
led=machine.Pin(16, machine.Pin.OUT)
btn=machine.Pin(15, machine.Pin.IN, machine.Pin.PULL_UP)
led_last = time.ticks_ms()
 
def btnHandler(pin):
    global led, led_last, btn
    if (time.ticks_diff(time.ticks_ms(), led_last)) > 500:
        led.toggle()
        led_last=time.ticks_ms()
 
led.value(0)
btn.irq(trigger=machine.Pin.IRQ_RISING, handler=btnHandler)

Microsoft Windows 10 IoT OS system is available for download from Windows 10 IoT Core Developers tools ^[57].

Step 1
Download the Windows 10 IoT Core Dashboard Setup. Run the Setup.exe file and choose the Setup a new device tab as present in figure 30.

Step 2
On the IoT Dashboard window, the User must choose the device type to install the OS system and the OS version to install (latest developer version 17763 or custom). The device's name and Administrator password can be set during SD card with OS preparation. The default password for the Windows 10 IoT Core is passw0rd If the Wi-Fi network Connection is available on the computer running the Setup, it is possible to configure the generated OS image to set this connection on the selected device board automatically.
Accepting the software license terms enables the Download and Install button to format the SD Card and prepare the OS image for the selected device board.
Choosing the Connect to Azure tab and following the Azure User registration opens the ability of the OS image to automatically connect to the Azure IoT hub after the device powers on.

Step 3
Start formatting the SD card and install the FFU image on it.

Step 4
Gently remove an SD card from the reader and push it into the Raspberry Pi SD card slot.

Step 5
Power on the Raspberry Pi board and follow the Windows 10 Core setup commands configuring the Windows 10 Core features.
After the board reboot, the Main Windows 10 Core screen displays (figure 31):

This chapter describes the typical programming technics used in Raspberry Pi board development projects.

To create and develop control applications on the Raspberry Pi boards, one needs the following development components:

• PC with Windows 10 System installed,
• Visual Studio 2015 or higher,
• Raspberry PI 2 or 3 board with Windows 10 IoT Core installed,
• configured TCP/IP network for Raspberry Pi and Windows 10 Desktop computer (Local LAN or WiFi subnet),

A list of programming skills necessary to seamlessly develop for Windows IoT is listed below:

• C# language knowledge,
• XML/XAML language knowledge,
• Windows API understanding.

The Windows IoT Remote Client is welcome for a better development experience of Raspberry applications. This application is available for download from the Microsoft Store. This application captures the keyboard, mouse and screen from the Raspberry Pi board running the Windows 10 IoT Core system on the desktop PC. It allows developers to use a standalone Raspberry board without a connected mouse, keyboard or monitor (figure 32).

To write and develop applications under Windows 10 IoT Core, developers must know how the Windows operating system interacts with User applications. The advantage of using Windows 10 IoT Core is that Microsoft's concept uses the same Kernel API available on different hardware platforms – desktop PCs, IoT boards suitable to run Windows Core, tablets, etc. It reduces development costs due to the unifying system environment, and the only difference is in the display view of the same application code written in C#/C++. Windows 10 Core is specially designed to handle applications working as standalone on the IoT platforms in a 24/7 time model.

After installing the Windows 10 IoT Core, the developer must configure the IoT platform using Windows Device Portal (WDP, figure 33).

IoT board can be managed using Chrome, Microsoft Edge, Firefox, and any Internet browser. To open the WDB portal on the IoT board, the user must enter the board IP address – IPaddress:8080/default.htm. The site is protected with a username/password. Default account credentials are: administrator/p@ssw0rd. Following tabs in the WDP, it is possible to configure all necessary IoT platform settings, check the current board status, download development crash/debug information, configure network/Bluetooth settings, download drivers, and configure security TPM modules. If all tasks are ready, the developer can start to write his own IoT application under Windows 10 IoT Core.
The following steps are recommended before the IoT board will be used for application:

Step 1
In the Device Settings, the user is recommended to Change your device name. The default name is minwinpc. The aim to change it is that if a user uses many IoT devices connected to the same network segment, it is challenging to recognise which role each device is set for. Enumerating IoT devices will show boards with the same name but different IP addresses. Proper naming will make it easy to know what role each device plays.

Step 2
Because RPI boards don't have their own RTC clock modules, Windows 10 IoT Core sets the time using the NTP services during its work. So, very important in industrial implementations, and a case when time is essential in developed applications, is to set the proper time zone for the board. In the Device settings, the user is recommended to select the appropriate Time zone

Step 3
Security reasons – the default password for the newly flashed device is p@ssw0rd. It is strongly recommended right after the first board boot to change it to make it unique! It will prevent the IoT device from remote hacking. The password can be changed in the Device Settings tab.

Step 4
The Windows 10 IoT Core comes with Cortana service ready. If the board has a microphone and speakers, it is always possible to turn the Cortana service on for voice commands communication with the board.

Step 5
If the IoT board needs special hardware connected, then in the Devices/Device Manager, the user can upload and install an appropriate driver for it in case it is not preinstalled in the IoT Core (figure 34).

Step 6
Raspberry Pi boards 1/2/3 are equipped with network connection modules. If the board under Windows 10 IoT Core is connected to a LAN RJ45 connector, the IP number can be set via the DHCP server. If the user wants to use a WiFi connection or activate Bluetooth, he can do it directly on the board main display or manage it via the Windows Device Portal as present in figures 35 and 36.

Step 7
Security. In a case when an IoT device must be protected from remote hacking, one of the solutions is to use a Trusted Platform Modules (TPM) module following ISO/IEC 11889 standards for a secure cryptoprocessor, a dedicated microcontroller designed to secure hardware through integrated cryptographic keys. The chip contains physical security mechanisms to protect it from tampering, and malicious software cannot hack the TPM security functions. Some of the TPM key advantages are:

• generate and store the cryptographic keys,
• use the TPM unique RSA key technology for platform device authentication, which is burned into the chip,
• help ensure platform integrity.

The most common TPM functions are used for system integrity measurements, key creation and use. The boot code (including firmware and OS components) is loaded during the system boot process and can be measured and recorded in the TPM module. The integrity measurements are used to show how the OS started and to be sure when the correct boot software was used with the TPM-based key. Windows 10 IoT Core supports a few TPM module standards, which can be connected to the 40-pin GPIO connector (figure 37).

Under the TPM Configuration tab in the Windows Device, the Portal user can select the proper communication protocol for the TPM module installed in the Raspberry Pi board. Then, the appropriate driver for the TPM module can be installed in the Device Manager tab (figure 38).

To create a simple Hello Word application under Windows 10 IoT Core, Visual Studio 2022 or newer version is needed. Visual Studio must be installed with the Universal Windows Platform development extension (figure 39).

Step 1
Create a new UWP project by choosing the Windows Universal/Blank App Project (figure 40).

Step 2
Configure your new project (according to Raspberry Pi Windows 10 IoT Core build version) is presented in figure 41.

Step 3
Choose the Target version of your device platform which Windows IoT Core will support, as in figure 42.

Step 4
Create App1 solution (figure 43).

Step 5
Design the application screen by modifying the MainPage.xaml file. To add different screen features, use the Toolbox/All XAML controls (figure 44).

Step 6
Modify the MainPage.cs file content if you need control events programming (figure 45).

Step 7
Compile and run Hello solution. Choosing the Solution Platform for the x86 user will be able to debug and run the Hello application on the computer's desktop emulator. This step is useful for program touchscreen design but cannot test the sensors and controls programming due to software emulator restrictions (figure 46).

Software emulators aren't capable of simulating their behaviour. Instead, the Solution Platform must be changed to the ARM platform in the VC Solution Configuration property to use sensors and controls. The application package must be transferred to the real IoT device to debug. Correct configuration is present in the figure 47.

Step 8
The user must configure the debug application settings to deploy and debug the application package on the real IoT device. In the Debug property page, the user must enter the proper Remote IoT device IP number (figure 48).

Step 9
Start debugging the application, and after deploying the application package to the board SD card, it will be displayed on the monitor: Hello application is present in figure 49 and debugging view in figure 50.

The C# ^[58] variables are categorized into the following types:

• value types,
• reference types,
• pointer types.

Value-type variables can assign a value directly. The class System.ValueType defines them.

The value types directly contain data. Value types may be: int, char and float, storing numbers, strings or floating point values. When an int type is declared, the system allocates memory to store its value.

The available value types listed in C# are presented as follows (table 5):

Object Type
The Object Type is an alias for the System.Object class. It is the ultimate base class for all data types in the C# Common Type System (CTS). The object types can be assigned with values of any other types, value types, reference types, predefined or user-defined types. Before assigning values, the type conversion is needed.

When a value type is converted to an object type, it is called boxing; when it is converted to a value type, it is called unboxing.

object obj;
obj = 100; //This is boxing

Dynamic Type
The data type variable can store any value. But this type of checking takes place at run-time.

The syntax for declaring a dynamic type is:

dynamic <variable_name> = value;

For example,

dynamic d = 20;

Dynamic types are similar to object types. That type checking for object type variables takes place at compile time. For the dynamic type variables, checking takes place at run time.

String Type
The string type allows assigning any string values to a variable. The string type is an alias for the System.String class derived from the object type. The string type value can be assigned using string literals in two forms: quoted and @quoted.

For example,

string str = "Tutorials Point";

A @quoted string literal looks as follows:

@"Tutorials Point";

The user-defined reference types are class, interface, or delegate.

Reference Type
The reference types don't contain the actual data stored in a variable. They contain a reference to the variables.

Using multiple variables, the reference types can refer to a memory location. If the variable changes the data in the memory location, the other variable automatically reflects this change in value. Built-in reference example types are object, dynamic, and string.

Pointer Type
Pointer-type variables store the memory address, which is another type. Pointers in C# are similar to pointers in C or C++.

The syntax for declaring a pointer type is:

type* identifier;

For example,

char* cptr;
int* iptr;

Each variable in C# has a specific type, which determines the size and layout of the variable's memory.

The basic value types in C# can be categorised as follows:

Variable Definitions
Variable syntax definition in C# is:

<data_type> <variable_list>;

data_type must be a valid C# data type like char, int, float, double, or any user-defined data type. variable_list may consist of one or more identifier names separated by commas.

Examples of valid variable definitions are shown below:

int i, j, k;
char c, ch;
float f, salary;
double d;

The variable can be initialized immediately during definition time:

int i = 100;

Variables Initialization
Variables are initialized with an equal sign followed by a constant expression. The general initialization form looks:

variable_name = value;

Variables can be initialized during their declaration. The initializer consists of an equal sign followed by a constant expression as:

<data_type> <variable_name> = value;

Some examples are:

int d = 3, f = 5;    /* Initializing d and f */
byte z = 22;         /* Initializes z */
double pi = 3.14159; /* Declares an approximation of PI */
char x = 'x';        /* The variable x has the value 'x' */

It is essential to initialize variables properly; otherwise, sometimes, it may produce unexpected results.

The following example uses various types of variables:

using System;
 
namespace VariableDefinition {
 class Program {
   static void Main(string[] args) {
     short a;
     int b ;
     double c;
     /* Actual initialization */
     a = 10;
     b = 20;
     c = a + b;
     Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
     Console.ReadLine();
   }
 }
}

Output:

a = 10, b = 20, c = 30

C# ^[59] Specifying one or more conditions to be evaluated or tested by the program requires decision-making structures. The proper statements must be performed if the condition is true or false.

C# provides the following types of decision-making statements (table 7):

if Statement
An if statement consists of a boolean expression followed by one or more statements. The syntax of an if statement in C# is:

if(boolean_expression) {
 /* Statement(s) will execute if the boolean expression is true */
}

If the boolean expression evaluates to true, the code block inside the if statement is executed. If the boolean expression evaluates to false, the first code set after the end of the if statement (after the closing curly brace) is executed.

Example:

using System;
 
namespace DecisionMaking {
  class Program {
    static void Main(string[] args) {
      /* Local variable definition */
      int a = 10;
 
      /* Check the boolean condition using if statement */
      if (a < 20) {
        /* If condition is true then print the following */
        Console.WriteLine("a is less than 20");
      }
      Console.WriteLine("value of a is : {0}", a);
      Console.ReadLine();
    }
  }
}

Output:

a is less than 20;
value of a is : 10

if…else Statement
An if statement can be followed by an optional else statement, which executes when the boolean expression is false. The syntax of an if…else statement in C# is:

if(boolean_expression) {
  /* Statement(s) will execute if the boolean expression is true */
} else {
  /* Statement(s) will execute if the boolean expression is false */
}

If the boolean expression evaluates to true, then the if block of code is executed; otherwise, else block of code is executed.

Example:

using System;
 
namespace DecisionMaking {
  class Program {
    static void Main(string[] args) {
      /* Local variable definition */
      int a = 100;
 
      /* Check the boolean condition */
      if (a < 20) {
        /* If condition is true then print the following */
        Console.WriteLine("a is less than 20");
      } else {
        /* If condition is false then print the following */
        Console.WriteLine("a is not less than 20");
      }
      Console.WriteLine("value of a is : {0}", a);
      Console.ReadLine();
    }
  }
}

Output:

a is not less than 20;
value of a is : 100

Nested if Statement
It is always legal in C# to nest if…else statements, which means you can use one if or else if statement inside another if or else if statement(s). The syntax for a nested if statement is as follows:

if( boolean_expression 1) {
  /* Executes when the boolean expression 1 is true */
  if(boolean_expression 2) {
    /* Executes when the boolean expression 2 is true */
  }
}

Example:

using System;
 
namespace DecisionMaking {
  class Program {
    static void Main(string[] args) {
      //* Local variable definition */
      int a = 100;
      int b = 200;
 
      /* Check the boolean condition */
      if (a == 100) {
 
        /* If condition is true then check the following */
        if (b == 200) {
          /* If condition is true then print the following */
          Console.WriteLine("Value of a is 100 and b is 200");
        }
      }
      Console.WriteLine("Exact value of a is : {0}", a);
      Console.WriteLine("Exact value of b is : {0}", b);
      Console.ReadLine();
    }
  }
}

Output:

Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200

switch Statement
A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable switched on is checked for each switch case.

The syntax for a switch statement in C# is as follows:

switch(expression) {
  case constant-expression  :
    statement(s);
    break; /* Optional */
  case constant-expression  :
    statement(s);
    break; /* Optional */
  
  /* You can have any number of case statements */
  default : /* Optional */
  statement(s);
}

The following rules apply to a switch statement.

1. The expression in a switch statement must have an integral or enumerated type or a class type in which the class has a single conversion function to an integral or enumerated type.
2. You can have any number of case statements within a switch. Each case is followed by the value to be compared to and a colon.
3. The constant expression for a case must be the same data type as the variable in the switch, and it must be a constant or a literal.
4. When the variable switched on is equal to a case, the statements following that case will execute until a break statement is reached.
5. When a break statement is reached, the switch terminates, and the control flow jumps to the next line following the switch statement.
6. Not every case needs to contain a break. If no break appears, the control flow will fall through to subsequent cases until a break is reached.
7. A switch statement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case.

Example:

using System;
 
namespace DecisionMaking {
  class Program {
    static void Main(string[] args) {
      /* Local variable definition */
      char grade = 'B';
 
      switch (grade) {
        case 'A':
          Console.WriteLine("Excellent!");
          break;
        case 'B':
        case 'C':
          Console.WriteLine("Well done");
          break;
        case 'D':
          Console.WriteLine("You passed");
          break;
        case 'F':
          Console.WriteLine("Better try again");
          break;
        default:
          Console.WriteLine("Invalid grade");
          break;
      }
      Console.WriteLine("Your grade is  {0}", grade);
      Console.ReadLine();
    }
  }
}

Output:

Well done
Your grade is B

Nested switch Statement
It is possible to have a switch as part of an outer switchstatement sequence. No conflicts will arise even if the case constants of the inner and outer switch contain common values.

The syntax for a nested switch statement is as follows:

switch(ch1) {
  case 'A':
    Console.WriteLine("This A is part of outer switch" );
   
  switch(ch2) {
    case 'A':
      Console.WriteLine("This A is part of inner switch" );
      break;
    case 'B': /* Inner B case code */
  }
  break;
  case 'B': /* Outer B case code */
}

Example:
<code C>
using System;

namespace DecisionMaking {
  class Program {
    static void Main(string[] args) {
      int a = 100;
      int b = 200;
         
      switch (a) {
        case 100: 
          Console.WriteLine("This is part of outer switch ");
            
          switch (b) {
            case 200:
              Console.WriteLine("This is part of inner switch ");
              break;
          }
        break;
      }
      Console.WriteLine("Exact value of a is : {0}", a);
      Console.WriteLine("Exact value of b is : {0}", b);
      Console.ReadLine();
    }
  }
} 

Output:

This is part of outer switch
This is part of inner switch
Exact value of a is : 100
Exact value of b is : 200

C# ^[60] provides the following types of loops to handle looping requirements, listed in table 8.

while Loop
A while loop statement in C# repeatedly executes a target statement if a given condition is true.

while(condition) {
   statement(s);
}

Example:

using System;
 
namespace Loops {
  class Program {
    static void Main(string[] args) {
      /* Local variable definition */
      int a = 10;
 
      /* while loop execution */
      while (a < 20) {
        Console.WriteLine("value of a: {0}", a);
        a++;
      }
      Console.ReadLine();
    }
  }
} 

Output:

value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19

for Loop
A for loop is a repetition control structure that allows you to efficiently write a loop that needs to be executed a specific number of times. The syntax of a for loop in C# is:

for ( init; condition; increment ) {
  statement(s);
}

Here is the flow of control in a for loop:

1. The init step is executed first, and only once. This step allows you to declare and initialise any loop control variables. You are not required to put a statement here as long as a semicolon appears.
2. Next, the condition is evaluated. If it is true, the body of the loop is executed. If false, the loop's body does not run, and the control flow jumps to the next statement just after the for loop.
3. After the body of the for loop executes, the control flow returns to the increment statement. This statement allows you to update any loop control variables. This statement can be left blank if a semicolon appears after the condition.
4. The condition is now re-evaluated. If it is true, the loop executes, and the process repeats itself (body of the loop, then increment step, and then again testing for a condition). After the condition becomes false, the for loop terminates.

Example:

using System;
namespace Loops {
  class Program {
    static void Main(string[] args) {
 
      /* for loop execution */
      for (int a = 10; a < 20; a = a + 1) {
        Console.WriteLine("value of a: {0}", a);
      }
      Console.ReadLine();
    }
  }
} 

Output:

value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19

do…while Loop
The syntax of a do…while loop in C# is:

do {
  statement(s);
} while( condition );

Notice that the conditional expression appears at the end of the loop, so the statement(s) execute once before the condition is tested.

If the condition is true, the control flow returns to do, and the statement(s) in the loop execute again. This process repeats until the given condition becomes false. Example:

using System;
 
namespace Loops {
  class Program {
    static void Main(string[] args) {
      /* Local variable definition */
      int a = 10;
 
      /* do loop execution */
      do {
        Console.WriteLine("value of a: {0}", a);
        a = a + 1;
      } 
      while (a < 20);
      Console.ReadLine();
    }
  }
} 

Output:

value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19

Nested for Loop
C# allows using one loop inside another loop (loop nesting). The following section shows a few examples to illustrate the concept. The syntax for a nested for loop statement in C# is as follows:

for ( init; condition; increment ) {
  for ( init; condition; increment ) {
    statement(s);
  }
  statement(s);
}

The syntax for a nested while loop statement in C# is as follows:

while(condition) {
  while(condition) {
    statement(s);
  }
  statement(s);
}

The syntax for a nested do…while loop statement in C# is as follows:

do {
  statement(s);
  do {
    statement(s);
  }
  while( condition );
}
while( condition );

A final note on loop nesting is that you can put any loop inside any other type. For example, a for loop can be inside a while loop or vice versa. Example:

using System;
 
namespace Loops {
  class Program {
    static void Main(string[] args) {
    /* local variable definition */
    int i, j;
 
    for (i = 2; i < 100; i++) {
      for (j = 2; j <= (i / j); j++)
        if ((i % j) ** 0) break; // if factor found, not prime
          if (j > (i / j)) Console.WriteLine("{0} is prime", i);
      }
      Console.ReadLine();
    }
  }
} 

Output:

2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime
17 is prime
19 is prime
23 is prime
29 is prime
31 is prime
37 is prime
41 is prime
43 is prime
47 is prime
53 is prime
59 is prime
61 is prime
67 is prime
71 is prime
73 is prime
79 is prime
83 is prime
89 is prime
97 is prime

Infinite Loop
A loop becomes an infinite loop if a condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop is required, you can make an endless loop by leaving the conditional expression empty.

Example:

using System;
 
namespace Loops {
  class Program {
    static void Main(string[] args) {
      for (; ; ) {
        Console.WriteLine("Hey! I am Trapped");
      }
    }
  }
} 

When the conditional expression is absent, it is assumed to be true.

C# object-oriented programming does not differ much from the C++ model. Below there are major C# class components along with samples.

Defining a Class
A C# ^[61] class definition starts with the keyword class followed by the class name and the class body enclosed by a pair of curly braces. Following is the general form of a class definition:

<access specifier> class  class_name {
  //Member variables
  <access specifier> <data type> variable1;
  <access specifier> <data type> variable2;
  ...
  <access specifier> <data type> variableN;
  //Member methods
  <access specifier> <return type> method1(parameter_list) {
    //Method body
  }
  <access specifier> <return type> method2(parameter_list) {
    //Method body
  }
  ...
  <access specifier> <return type> methodN(parameter_list) {
    //Method body
  }
}

Note:

• access specifiers specify the access rules for the members and the class itself. If not mentioned, then the default access specifier for a class type is internal. Default access for the members is private;
• data type specifies the type of variable, and return type specifies the data type of the data the method returns, if any;
• to access the class members, you use the dot (.) operator;
• the dot operator links an object's name with a member's name.

Example:

using System;
 
namespace BoxApplication {
 
  class Box {
    public double length;   //Length of a box
    public double breadth;  //Breadth of a box
    public double height;   //Height of a box
  }
  class Boxtester {
    static void Main(string[] args) {
      Box Box1 = new Box();   //Declare Box1 of type Box
      Box Box2 = new Box();   //Declare Box2 of type Box
      double volume = 0.0;    //Store the volume of a box here
 
      //Box1 specification
      Box1.height = 5.0;
      Box1.length = 6.0;
      Box1.breadth = 7.0;
 
      //Box2 specification
      Box2.height = 10.0;
      Box2.length = 12.0;
      Box2.breadth = 13.0;
 
      //Volume of Box1
      volume = Box1.height * Box1.length * Box1.breadth;
      Console.WriteLine("Volume of Box1 : {0}",  volume);
 
      //Volume of Box2
      volume = Box2.height * Box2.length * Box2.breadth;
      Console.WriteLine("Volume of Box2 : {0}", volume);
      Console.ReadKey();
    }
  }
}