The idea for this posting started when I read New approaches to dominate in embedded development article. Then I found some ther related articles and here is the result: long article.
Embedded devices, or embedded systems, are specialized computer systems that constitute components of larger electromechanical systems with which they interface. The advent of low-cost wireless connectivity is altering many things in embedded development: With a connection to the Internet, an embedded device can gain access to essentially unlimited processing power and memory in cloud service – and at the same time you need to worry about communication issues like breaks connections, latency and security issues.
Those issues are espcecially in the center of the development of popular Internet of Things device and adding connectivity to existing embedded systems. All this means that the whole nature of the embedded development effort is going to change. A new generation of programmers are already making more and more embedded systems. Rather than living and breathing C/C++, the new generation prefers more high-level, abstract languages (like Java, Python, JavaScript etc.). Instead of trying to craft each design to optimize for cost, code size, and performance, the new generation wants to create application code that is separate from an underlying platform that handles all the routine details. Memory is cheap, so code size is only a minor issue in many applications.
Historically, a typical embedded system has been designed as a control-dominated system using only a state-oriented model, such as FSMs. However, the trend in embedded systems design in recent years has been towards highly distributed architectures with support for concurrency, data and control flow, and scalable distributed computations. For example computer networks, modern industrial control systems, electronics in modern car,Internet of Things system fall to this category. This implies that a different approach is necessary.
Companies are also marketing to embedded developers in new ways. Ultra-low cost development boards to woo makers, hobbyists, students, and entrepreneurs on a shoestring budget to a processor architecture for prototyping and experimentation have already become common.If you look under the hood of any connected embedded consumer or mobile device, in addition to the OS you will find a variety of middleware applications. As hardware becomes powerful and cheap enough that the inefficiencies of platform-based products become moot. Leaders with Embedded systems development lifecycle management solutions speak out on new approaches available today in developing advanced products and systems.
Traditional approaches
C/C++
Tradionally embedded developers have been living and breathing C/C++. For a variety of reasons, the vast majority of embedded toolchains are designed to support C as the primary language. If you want to write embedded software for more than just a few hobbyist platforms, your going to need to learn C. Very many embedded systems operating systems, including Linux Kernel, are written using C language. C can be translated very easily and literally to assembly, which allows programmers to do low level things without the restrictions of assembly. When you need to optimize for cost, code size, and performance the typical choice of language is C. Still C is today used for maximum efficiency instead of C++.
C++ is very much alike C, with more features, and lots of good stuff, while not having many drawbacks, except fror it complexity. The had been for years suspicion C++ is somehow unsuitable for use in small embedded systems. At some time many 8- and 16-bit processors were lacking a C++ compiler, that may be a concern, but there are now 32-bit microcontrollers available for under a dollar supported by mature C++ compilers.Today C++ is used a lot more in embedded systems. There are many factors that may contribute to this, including more powerful processors, more challenging applications, and more familiarity with object-oriented languages.
And if you use suitable C++ subset for coding, you can make applications that work even on quite tiny processors, let the Arduino system be an example of that: You’re writing in C/C++, using a library of functions with a fairly consistent API. There is no “Arduino language” and your “.ino” files are three lines away from being standard C++.
Today C++ has not displaced C. Both of the languages are widely used, sometimes even within one system – for example in embedded Linux system that runs C++ application. When you write a C or C++ programs for modern Embedded Linux you typically use GCC compiler toolchain to do compilation and make file to manage compilation process.
Most organization put considerable focus on software quality, but software security is different. When the security is very much talked about topic todays embedded systems, the security of the programs written using C/C++ becomes sometimes a debated subject. Embedded development presents the challenge of coding in a language that’s inherently insecure; and quality assurance does little to ensure security. The truth is that majority of today’s Internet connected systems have their networking fuctionality written using C even of the actual application layer is written using some other methods.
Java
Java is a general-purpose computer programming language that is concurrent, class-based and object-oriented.The language derives much of its syntax from C and C++, but it has fewer low-level facilities than either of them. Java is intended to let application developers “write once, run anywhere” (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of computer architecture. Java is one of the most popular programming languages in use, particularly for client-server web applications. In addition to those it is widely used in mobile phones (Java apps in feature phones,) and some embedded applications. Some common examples include SIM cards, VOIP phones, Blu-ray Disc players, televisions, utility meters, healthcare gateways, industrial controls, and countless other devices.
Some experts point out that Java is still a viable option for IoT programming. Think of the industrial Internet as the merger of embedded software development and the enterprise. In that area, Java has a number of key advantages: first is skills – there are lots of Java developers out there, and that is an important factor when selecting technology. Second is maturity and stability – when you have devices which are going to be remotely managed and provisioned for a decade, Java’s stability and care about backwards compatibility become very important. Third is the scale of the Java ecosystem – thousands of companies already base their business on Java, ranging from Gemalto using JavaCard on their SIM cards to the largest of the enterprise software vendors.
Although in the past some differences existed between embedded Java and traditional PC based Java solutions, the only difference now is that embedded Java code in these embedded systems is mainly contained in constrained memory, such as flash memory. A complete convergence has taken place since 2010, and now Java software components running on large systems can run directly with no recompilation at all on design-to-cost mass-production devices (consumers, industrial, white goods, healthcare, metering, smart markets in general,…) Java for embedded devices (Java Embedded) is generally integrated by the device manufacturers. It is NOT available for download or installation by consumers. Originally Java was tightly controlled by Sun (now Oracle), but in 2007 Sun relicensed most of its Java technologies under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java (bytecode compiler), GNU Classpath (standard libraries), and IcedTea-Web (browser plugin for applets).
My feelings with Java is that if your embedded systems platform supports Java and you know hot to code Java, then it could be a good tool. If your platform does not have ready Java support, adding it could be quite a bit of work.
Increasing trends
Databases
Embedded databases are coming more and more to the embedded devices. If you look under the hood of any connected embedded consumer or mobile device, in addition to the OS you will find a variety of middleware applications. One of the most important and most ubiquitous of these is the embedded database. An embedded database system is a database management system (DBMS) which is tightly integrated with an application software that requires access to stored data, such that the database system is “hidden” from the application’s end-user and requires little or no ongoing maintenance.
There are many possible databases. First choice is what kind of database you need. The main choices are SQL databases and simpler key-storage databases (also called NoSQL).
SQLite is the Database chosen by virtually all mobile operating systems. For example Android and iOS ship with SQLite. It is also built into for example Firefox web browser. It is also often used with PHP. So SQLite is probably a pretty safe bet if you need relational database for an embedded system that needs to support SQL commands and does not need to store huge amounts of data (no need to modify database with millions of lines of data).
If you do not need relational database and you need very high performance, you need probably to look somewhere else.Berkeley DB (BDB) is a software library intended to provide a high-performance embedded database for key/value data. Berkeley DB is written in Cwith API bindings for many languages. BDB stores arbitrary key/data pairs as byte arrays. There also many other key/value database systems.
RTA (Run Time Access) gives easy runtime access to your program’s internal structures, arrays, and linked-lists as tables in a database. When using RTA, your UI programs think they are talking to a PostgreSQL database (PostgreSQL bindings for C and PHP work, as does command line tool psql), but instead of normal database file you are actually accessing internals of your software.
Software quality
Building quality into embedded software doesn’t happen by accident. Quality must be built-in from the beginning. Software startup checklist gives quality a head start article is a checklist for embedded software developers to make sure they kick-off their embedded software implementation phase the right way, with quality in mind
Safety
Traditional methods for achieving safety properties mostly originate from hardware-dominated systems. Nowdays more and more functionality is built using software – including safety critical functions. Software-intensive embedded systems require new approaches for safety. Embedded Software Can Kill But Are We Designing Safely?
IEC, FDA, FAA, NHTSA, SAE, IEEE, MISRA, and other professional agencies and societies work to create safety standards for engineering design. But are we following them? A survey of embedded design practices leads to some disturbing inferences about safety.Barr Group’s recent annual Embedded Systems Safety & Security Survey indicate that we all need to be concerned: Only 67 percent are designing to relevant safety standards, while 22 percent stated that they are not—and 11 percent did not even know if they were designing to a standard or not.
If you were the user of a safety-critical embedded device and learned that the designers had not followed best practices and safety standards in the design of the device, how worried would you be? I know I would be anxious, and quite frankly. This is quite disturbing.
Security
The advent of low-cost wireless connectivity is altering many things in embedded development – it has added to your list of worries need to worry about communication issues like breaks connections, latency and security issues. Understanding security is one thing; applying that understanding in a complete and consistent fashion to meet security goals is quite another. Embedded development presents the challenge of coding in a language that’s inherently insecure; and quality assurance does little to ensure security.
Developing Secure Embedded Software white paper explains why some commonly used approaches to security typically fail:
MISCONCEPTION 1: SECURITY BY OBSCURITY IS A VALID STRATEGY
MISCONCEPTION 2: SECURITY FEATURES EQUAL SECURE SOFTWARE
MISCONCEPTION 3: RELIABILITY AND SAFETY EQUAL SECURITY
MISCONCEPTION 4: DEFENSIVE PROGRAMMING GUARANTEES SECURITY
Some techniques for building security to embedded systems:
Use secure communications protocols and use VPN to secure communications
The use of Public Key Infrastructure (PKI) for boot-time and code authentication
Establishing a “chain of trust”
Process separation to partition critical code and memory spaces
Leveraging safety-certified code
Hardware enforced system partitioning with a trusted execution environment
Plan the system so that it can be easily and safely upgraded when needed
Flood of new languages
Rather than living and breathing C/C++, the new generation prefers more high-level, abstract languages (like Java, Python, JavaScript etc.). So there is a huge push to use interpreted and scripting also in embedded systems. Increased hardware performance on embedded devices combined with embedded Linux has made the use of many scripting languages good tools for implementing different parts of embedded applications (for example web user interface). Nowadays it is common to find embedded hardware devices, based on Raspberry Pi for instance, that are accessible via a network, run Linux and come with Apache and PHP installed on the device. There are also many other relevant languages
One workable solution, especially for embedded Linux systems is that part of the activities organized by totetuettu is a C program instead of scripting languages (Scripting). This enables editing operation simply script files by editing without the need to turn the whole system software again. Scripting languages are also tools that can be implemented, for example, a Web user interface more easily than with C / C ++ language. An empirical study found scripting languages (such as Python) more productive than conventional languages (such as C and Java) for a programming problem involving string manipulation and search in a dictionary.
Scripting languages have been around for a couple of decades Linux and Unix server world standard tools. the proliferation of embedded Linux and resources to merge systems (memory, processor power) growth has made them a very viable tool for many embedded systems – for example, industrial systems, telecommunications equipment, IoT gateway, etc . Some of the command language is suitable for up well even in quite small embedded environments.
I have used with embedded systems successfully mm. Bash, AWK, PHP, Python and Lua scripting languages. It works really well and is really easy to make custom code quickly .It doesn’t require a complicated IDE; all you really need is a terminal – but if you want there are many IDEs that can be used. High-level, dynamically typed languages, such as Python, Ruby and JavaScript. They’re easy—and even fun—to use. They lend themselves to code that easily can be reused and maintained.
There are some thing that needs to be considered when using scripting languages. Sometimes lack of static checking vs a regular compiler can cause problems to be thrown at run-time. But it is better off practicing “strong testing” than relying on strong typing. Other ownsides of these languages is that they tend to execute more slowly than static languages like C/C++, but for very many aplications they are more than adequate. Once you know your way around dynamic languages, as well the frameworks built in them, you get a sense of what runs quickly and what doesn’t.
Bash and other shell scipting
Shell commands are the native language of any Linux system. With the thousands of commands available for the command line user, how can you remember them all? The answer is, you don’t. The real power of the computer is its ability to do the work for you – the power of the shell script is the way to easily to automate things by writing scripts. Shell scripts are collections of Linux command line commands that are stored in a file. The shell can read this file and act on the commands as if they were typed at the keyboard.In addition to that shell also provides a variety of useful programming features that you are familar on other programming langauge (if, for, regex, etc..). Your scripts can be truly powerful. Creating a script extremely straight forward: It can be created by opening a separate editor such or you can do it through a terminal editor such as VI (or preferably some else more user friendly terminal editor). Many things on modern Linux systems rely on using scripts (for example starting and stopping different Linux services at right way).
The most common type of shell script is a bash script. Bash is a commonly used scripting language for shell scripts. In BASH scripts (shell scripts written in BASH) users can use more than just BASH to write the script. There are commands that allow users to embed other scripting languages into a BASH script.
There are also other shells. For example many small embedded systems use BusyBox. BusyBox providesis software that provides several stripped-down Unix tools in a single executable file (more than 300 common command). It runs in a variety of POSIX environments such as Linux, Android and FreeeBSD. BusyBox become the de facto standard core user space toolset for embedded Linux devices and Linux distribution installers.
Shell scripting is a very powerful tool that I used a lot in Linux systems, both embedded systems and servers.
Lua
Lua is a lightweight cross-platform multi-paradigm programming language designed primarily for embedded systems and clients. Lua was originally designed in 1993 as a language for extending software applications to meet the increasing demand for customization at the time. It provided the basic facilities of most procedural programming languages. Lua is intended to be embedded into other applications, and provides a C API for this purpose.
Lua has found many uses in many fields. For example in video game development, Lua is widely used as a scripting language by game programmers. Wireshark network packet analyzer allows protocol dissectors and post-dissector taps to be written in Lua – this is a good way to analyze your custom protocols.
There are also many embedded applications. LuCI, the default web interface for OpenWrt, is written primarily in Lua. NodeMCU is an open source hardware platform, which can run Lua directly on the ESP8266 Wi-Fi SoC. I have tested NodeMcu and found it very nice system.
PHP
PHP is a server-side HTML embedded scripting language. It provides web developers with a full suite of tools for building dynamic websites but can also be used as a general-purpose programming language. Nowadays it is common to find embedded hardware devices, based on Raspberry Pi for instance, that are accessible via a network, run Linux and come with Apache and PHP installed on the device. So on such enviroment is a good idea to take advantage of those built-in features for the applications they are good – for building web user interface. PHP is often embedded into HTML code, or it can be used in combination with various web template systems, web content management system and web frameworks. PHP code is usually processed by a PHP interpreter implemented as a module in the web server or as a Common Gateway Interface (CGI) executable.
Python
Python is a widely used high-level, general-purpose, interpreted, dynamic programming language. Its design philosophy emphasizes code readability. Python interpreters are available for installation on many operating systems, allowing Python code execution on a wide variety of systems. Many operating systems include Python as a standard component; the language ships for example with most Linux distributions.
Python is a multi-paradigm programming language: object-oriented programming and structured programming are fully supported, and there are a number of language features which support functional programming and aspect-oriented programming, Many other paradigms are supported using extensions, including design by contract and logic programming.
Python is a remarkably powerful dynamic programming language that is used in a wide variety of application domains. Since 2003, Python has consistently ranked in the top ten most popular programming languages as measured by the TIOBE Programming Community Index. Large organizations that make use of Python include Google, Yahoo!, CERN, NASA. Python is used successfully in thousands of real world business applications around globally, including many large and mission-critical systems such as YouTube.com and Google.com.
Python was designed to be highly extensible. Libraries like NumPy, SciPy and Matplotlib allow the effective use of Python in scientific computing. Python is intended to be a highly readable language. Python can also be embedded in existing applications and hasbeen successfully embedded in a number of software products as a scripting language. Python can serve as a scripting language for web applications, e.g., via mod_wsgi for the Apache web server.
Python can be used in embedded, small or minimal hardware devices. Some modern embedded devices have enough memory and a fast enough CPU to run a typical Linux-based environment, for example, and running CPython on such devices is mostly a matter of compilation (or cross-compilation) and tuning. Various efforts have been made to make CPython more usable for embedded applications.
For more limited embedded devices, a re-engineered or adapted version of CPython, might be appropriate. Examples of such implementations include the following: PyMite, Tiny Python, Viper. Sometimes the embedded environment is just too restrictive to support a Python virtual machine. In such cases, various Python tools can be employed for prototyping, with the eventual application or system code being generated and deployed on the device. Also MicroPython and tinypy have been ported Python to various small microcontrollers and architectures. Real world applications include Telit GSM/GPRS modules that allow writing the controlling application directly in a high-level open-sourced language: Python.
Python on embedded platforms? It is quick to develop apps, quick to debug – really easy to make custom code quickly. Sometimes lack of static checking vs a regular compiler can cause problems to be thrown at run-time. To avoid those try to have 100% test coverage. pychecker is a very useful too also which will catch quite a lot of common errors. The only downsides for embedded work is that sometimes python can be slow and sometimes it uses a lot of memory (relatively speaking). An empirical study found scripting languages (such as Python) more productive than conventional languages (such as C and Java) for a programming problem involving string manipulation and search in a dictionary. Memory consumption was often “better than Java and not much worse than C or C++”.
JavaScript and node.js
JavaScript is a very popular high-level language. Love it or hate it, JavaScript is a popular programming language for many, mainly because it’s so incredibly easy to learn. JavaScript’s reputation for providing users with beautiful, interactive websites isn’t where its usefulness ends. Nowadays, it’s also used to create mobile applications, cross-platform desktop software, and thanks to Node.js, it’s even capable of creating and running servers and databases! There is huge community of developers. JavaScript is a high-level language.
Its event-driven architecture fits perfectly with how the world operates – we live in an event-driven world. This event-driven modality is also efficient when it comes to sensors.
Regardless of the obvious benefits, there is still, understandably, some debate as to whether JavaScript is really up to the task to replace traditional C/C++ software in Internet connected embedded systems.
It doesn’t require a complicated IDE; all you really need is a terminal.
JavaScript is a high-level language. While this usually means that it’s more human-readable and therefore more user-friendly, the downside is that this can also make it somewhat slower. Being slower definitely means that it may not be suitable for situations where timing and speed are critical.
JavaScript is already in embedded boards. You can run JavaScipt on Raspberry Pi and BeagleBone. There are also severa other popular JavaScript-enabled development boards to help get you started: The Espruino is a small microcontroller that runs JavaScript. The Tessel 2 is a development board that comes with integrated wi-fi, an ethernet port, two USB ports, and companion source library downloadable via the Node Package Manager. The Kinoma Create, dubbed the “JavaScript powered Internet of Things construction kit.”The best part is that, depending on the needs of your device, you can even compile your JavaScript code into C!
JavaScript for embedded systems is still in its infancy, but we suspect that some major advancements are on the horizon.We for example see a surprising amount of projects using Node.js.Node.js is an open-source, cross-platform runtime environment for developing server-side Web applications. Node.js has an event-driven architecture capable of asynchronous I/O that allows highly scalable servers without using threading, by using a simplified model of event-driven programming that uses callbacks to signal the completion of a task. The runtime environment interprets JavaScript using Google‘s V8 JavaScript engine.Node.js allows the creation of Web servers and networking tools using JavaScript and a collection of “modules” that handle various core functionality. Node.js’ package ecosystem, npm, is the largest ecosystem of open source libraries in the world. Modern desktop IDEs provide editing and debugging features specifically for Node.js applications
JXcore is a fork of Node.js targeting mobile devices and IoTs. JXcore is a framework for developing applications for mobile and embedded devices using JavaScript and leveraging the Node ecosystem (110,000 modules and counting)!
Why is it worth exploring node.js development in an embedded environment? JavaScript is a widely known language that was designed to deal with user interaction in a browser.The reasons to use Node.js for hardware are simple: it’s standardized, event driven, and has very high productivity: it’s dynamically typed, which makes it faster to write — perfectly suited for getting a hardware prototype out the door. For building a complete end-to-end IoT system, JavaScript is very portable programming system. Typically an IoT projects require “things” to communicate with other “things” or applications. The huge number of modules available in Node.js makes it easier to generate interfaces – For example, the HTTP module allows you to create easily an HTTP server that can easily map the GET method specific URLs to your software function calls. If your embedded platform has ready made Node.js support available, you should definately consider using it.
Future trends
According to New approaches to dominate in embedded development article there will be several camps of embedded development in the future:
One camp will be the traditional embedded developer, working as always to craft designs for specific applications that require the fine tuning. These are most likely to be high-performance, low-volume systems or else fixed-function, high-volume systems where cost is everything.
Another camp might be the embedded developer who is creating a platform on which other developers will build applications. These platforms might be general-purpose designs like the Arduino, or specialty designs such as a virtual PLC system.
This third camp is likely to become huge: Traditional embedded development cannot produce new designs in the quantities and at the rate needed to deliver the 50 billion IoT devices predicted by 2020.
Transition will take time. The enviroment is different than computer and mobile world. There are too many application areas with too widely varying requirements for a one-size-fits-all platform to arise.
Sources
Most important information sources:
New approaches to dominate in embedded development
A New Approach for Distributed Computing in Embedded Systems
New Approaches to Systems Engineering and Embedded Software Development
Embracing Java for the Internet of Things
Embedded Linux – Shell Scripting 101
Embedded Linux – Shell Scripting 102
Embedding Other Languages in BASH Scripts
PHP Integration with Embedded Hardware Device Sensors – PHP Classes blog
JavaScript: The Perfect Language for the Internet of Things (IoT)
Anyone using Python for embedded projects?
JavaScript: The Perfect Language for the Internet of Things (IoT)
MICROCONTROLLERS AND NODE.JS, NATURALLY
Node.JS Appliances on Embedded Linux Devices
The smartest way to program smart things: Node.js
Embedded Software Can Kill But Are We Designing Safely?
DEVELOPING SECURE EMBEDDED SOFTWARE
1,687 Comments
Tomi Engdahl says:
Security In The ARM Ecosystem
A root of trust that provides a solid foundation for the SoC security architecture.
https://semiengineering.com/security-in-the-arm-ecosystem/
Tomi Engdahl says:
10 Things You Ought To Know Before You Benchmark Your Software Security Program
Some quick tips so you get the most out of your benchmarking assessment
https://semiengineering.com/10-things-you-ought-to-know-before-you-benchmark-your-software-security-program/
Tomi Engdahl says:
6 essential activities to help developers build in IoT cybersecurity
https://www.edn.com/6-essential-activities-to-help-developers-build-in-iot-cybersecurity/?utm_source=newsletter&utm_campaign=link&utm_medium=EDNWeekly-20210128&oly_enc_id=2359J2998023G8W
Tomi Engdahl says:
Taming Non-Predictable Systems
https://semiengineering.com/taming-non-predictable-systems/
The non-predictable nature of most systems is not inherently bad, so long as it is understood and bounded — but that’s becoming a bigger challenge.
Tomi Engdahl says:
Roaring ’20s For The Chip Industry
https://semiengineering.com/roaring-20s-for-the-chip-industry/
New markets, different architectures, and continued virtual work environments all point to positive and sustained growth.
Tomi Engdahl says:
2020 Hindsight and 2021 Insight: Edge Computing, 5G, Trade Wars and COVID-19
https://www.3dincites.com/2021/01/2020-hindsight-and-2021-insight-edge-computing-5g-trade-wars-and-covid-19/
Tomi Engdahl says:
How modern simulation software addresses intralogistics challenges
Cover Story: Advanced simulation software provides optimization insight, enabling distribution and fulfillment centers to address issues and optimize efficiency. See video.
https://www.controleng.com/articles/how-modern-simulation-software-addresses-intralogistics-challenges/?oly_enc_id=0462E3054934E2U
Tomi Engdahl says:
The Good, Bad And Unknowns Of Flexible Devices
https://semiengineering.com/the-good-bad-and-unknowns-of-flexible-devices/
They’re starting to show up everywhere, even though not all of the kinks have been worked out.
Tomi Engdahl says:
Designing Low Energy Chips And Systems
https://semiengineering.com/designing-for-low-energy/
Orders of magnitude improvements in performance and efficiency are possible, but getting there isn’t easy.
Tomi Engdahl says:
Designing Low Energy Chips And Systems
https://semiengineering.com/designing-for-low-energy/
Orders of magnitude improvements in performance and efficiency are possible, but getting there isn’t easy.
Tomi Engdahl says:
Firmware Skills Shortage
Adding intelligence into devices requires a different skill set, and finding enough qualified people is becoming a challenge — especially in less glamorous areas.
Firmware Skills Shortage
https://semiengineering.com/ai-ml-skills-shortage/
Adding intelligence into devices requires a different skill set, and finding enough qualified people is becoming a challenge — especially in less glamorous areas.
Good hardware without good software is a waste of silicon, but with so many new processors and accelerator architectures being created, and so many new skills required, companies are finding it hard to hire enough engineers with low-level software expertise to satisfy the demand.
Writing compilers, mappers and optimization software does not have the same level of pizazz as developing new AI algorithms, or a new smart phone app. But without them, the whole industry will suffer.
Universities are struggling to turn out enough graduates with the mix of skills the industry needs. Part of the problem is the skill range is expanding to the point where it is unreasonable to accomplish that without several degrees. For example, new graduates may know how to create an AI algorithm, but few understand the implication of making it run efficiently on an edge device, or how to debug a system that is providing incorrect results.
There is a lack of software people to start with. “You will never have enough programmers,” says Robert Owen, principal consultant for the Worldwide University Programme at Imagination Technologies. “The amount of software you can make could always be more. There’s always extra functions you can add, there’s always more testing, more verification, better tools you can create. The demand for programming in the broadest sense is growing, and will continue to grow for the foreseeable future.”
But with new hardware, additional firmware people are necessary. “How do you make sure you can leverage the hardware in the best possible way? That is a huge issue, and not just a skills gap,”
Tomi Engdahl says:
Data Integrity Critical to Embedded Systems
https://www.designnews.com/design-software/data-integrity-critical-embedded-systems?ADTRK=InformaMarkets&elq_mid=15800&elq_cid=876648
How do you validate sensor and communication data to ensure data integrity in embedded systems?
Software engineers have a bad habit of being very optimistic. This optimism often doesn’t just include their calculation on how long it will take for a specific task to be completed but also on potential failure modes for their system. If it works on the bench, the assumption is that it will also work in the field, no matter whether that field is on a noisy manufacturing floor or orbiting the Earth. Unfortunately, these assumptions are optimistic and one of the biggest ones is that data is always valid. I once worked on a project where data coming from a sensor was being corrupted and there was no way to verify whether the sensor data was correct.
Today’s post will look at several ways that developers can hope for the best and assume the worst when it comes to data integrity.
Tip #1 – At least use a parity check
Tip #2 – Use a checksum
Tip #3 – Use a cyclical redundancy check (CRC)
Conclusions
In a world of ever-growing data collection and analysis, it’s important to realize that our systems can’t trust every bit of data that comes across a bus. Electromagnetic interference, cosmic rays, and other sources can cause bits to flip and become corrupted. Without some mechanism in place to detect those bit flips, it is possible that the data will be acted upon and while in many circumstances this won’t be a big deal, there are times where it could be catastrophic to the system. The three techniques we discussed today are simple and easy to implement and provide a simple sanity check on all the data going into and out of a system.
Tomi Engdahl says:
Embedded Scheme Specialist LambdaChip Launches First In-House STM32 Development Board
Designed to encourage the use of functional programming in the embedded world, the Alonzo is now available for pre-order.
https://www.hackster.io/news/embedded-scheme-specialist-lambdachip-launches-first-in-house-stm32-development-board-51e7c8fdc916
Tomi Engdahl says:
https://etn.fi/index.php/13-news/11835-embedded-world-tuote-tehdaan-ohjelmistolla
Tomi Engdahl says:
Object-Oriented Programming is Embarrassing: 4 Short Examples
https://www.youtube.com/watch?v=IRTfhkiAqPw
Video comments:
Actual title: “Overengineered solutions to simple problems are bad.”
This seems like more of a “don’t put crap into objects when you don’t need to” than a case against OOP.
“Polymorphic dispatch in this example is overkill, therefore all polymorphic dispatch is bad.” This video should just be called “Bad code is bad.”
classes are a tool, not a religion. both making everything a class and making nothing a class are bad programming practices. only using classes just overcomplicates everything and is messy and annoying, never using classes is just kneecapping yourself and dogmatically refusing to use what can be a useful feature.
The “middle ground” is usually the correct answer to most programming debates like this. That title definitely worked for views though
Tomi Engdahl says:
Low Power Embedded Systems Design and Power Management
https://www.nwengineeringllc.com/article/low-power-embedded-systems-design-and-power-management.php
Lower power embedded systems and IoT products might have a range of power management strategies implemented at the design level, or they have some sophisticated on-chip features helping to keep power consumption low. There are also sophisticated algorithms that enable low power consumption and power management in embedded systems, and any low power system might need a combination of strategies to prevent excess battery power from being used.
If you’re designing an embedded system that must be highly power efficient while also providing the required level of computing power, there are multiple approaches you can take. It all depends on the design requirements you need to meet, followed by opting for the right low-power components where possible. After having worked on multiple low power embedded systems, I’ve compiled a few strategies we use to approach a power consumption strategy and ensure a design will have the lifetime it requires.
Tomi Engdahl says:
https://www.eetimes.com/10-best-microcontrollers-on-the-market/
Tomi Engdahl says:
What Goes into IoT Platform Development?
https://www.nwengineeringllc.com/article/what-goes-into-iot-platform-development.php
The internet of things is everywhere, and millions of everyday products are quickly becoming part of full-fledged IoT platforms. Some of the fastest growing areas are in military IoT, industrial IoT, infrastructure, and automotive. If you want to add intelligence and interoperability to your new product, you’ll have to build an ecosystem around your new platform.
Tomi Engdahl says:
Bridging The PC And Embedded Worlds With Pico And Python
https://hackaday.com/2021/04/18/bridging-the-pc-and-embedded-worlds-with-pico-and-python/
Although protocols like I2C and SPI are great for communicating between embedded devices and their peripherals, it can be a pain to interface these low-level digital interfaces to a PC. [Alexandre] typically used an Arduino to bridge between the PC and embedded worlds, but he got tired of defining a custom serial protocol for each project. Inspired by MicroPython’s machine module, [Alexandre] has developed u2if—an implementation of some of MicroPython’s machine module for PC—using a USB-connected Raspberry Pi Pico to bridge between a PC and low-level digital interfaces.
u2if consists of two parts: the PC portion is a Python implementation of a portion of the MicroPython machine module, and the Raspberry Pi Pico receives some custom C++ firmware. Thus far, [Alexandre] has implemented functionality for the onboard ADCs, I2C, SPI, UART, and GPIO lines as well as additional support for I2S sound and the WS2812B addressable LED.
https://github.com/execuc/u2if
u2if project
u2if(USB to interfaces) is an attempt to implement some of the MicroPython “machine” module functionalities on a computer. The goal is to be able to communicate with breakout boards (sensors, lcd…) simply from a python program on x86 machine. It uses a Raspberry PICO microcontroller to make the interface between the computer (USB) and peripherals/protocols.
Tomi Engdahl says:
http://firmata.org/wiki/Main_Page
Firmata is a generic protocol for communicating with microcontrollers from software on a host computer. It is intended to work with any host computer software package. Right now there is a matching object in a number of languages. It is easy to add objects for other software to use this protocol. Basically, this firmware establishes a protocol for talking to the Arduino from the host software. The aim is to allow people to completely control the Arduino from software on the host compute
https://hackaday.com/2019/07/02/hands-on-greatfet-is-an-embedded-tool-that-does-it-all/
Lots of Fast I/O with Direct Access From Your Computer
GreatFET is a jack-knife for embedded projects — it’s meant to stand in for multiple tools and components during development so that you can work on the problem in front of you right now and figure everything else out later on. For instance, consider testing out a new chip. You could hook it up to your favorite microcontroller, write and flash some test code, and see if the chip you’re testing works the first time. But chances are you have the I2C address wrong, or you hooked up TX/RX or MISO/MOSI backwards, or myriad other common gotchas.
At its simplest, GreatFET is designed to give you an interactive Python shell that controls oodles of IO pins on the board. You run commands and get feedback as fast as you can type them. But this is the tip of the iceberg with the GreatFET. On the more advanced side of things, this board can be used to emulate USB devices, as a data acquisition device for building custom instrumentation, for MSP430 flashing and debugging, or as automated testing gear in manufacturing environments.
Tomi Engdahl says:
https://www.edn.com/5-key-considerations-in-iot-asset-tracking-design/
Tomi Engdahl says:
Linus Torvalds weighs in on Rust language in the Linux kernel
“Memory managed languages? In my kernel?” It’s more likely than you think.
https://arstechnica.com/gadgets/2021/03/linus-torvalds-weighs-in-on-rust-language-in-the-linux-kernel/
Tomi Engdahl says:
Wireless MicroPython Programming With Thonny
https://hackaday.com/2021/04/29/wireless-micropython-programming-with-thonny/
I’ve been playing with a few MicroPython projects recently on several different embedded platforms, including a couple of ESP32 WiFi modules. There are various ways to program these modules:
Use a serial terminal and ampy (maintained by [devxpy] since being dropped by Adafruit in 2018).
If you use Pycom boards or WiFy firmware, there are the pymakr plugins for Atom and Visual Studio.
If you prefer the command-line like me, there is rshell by one of the top MicroPython contributors [Dave Hylands].
For over a year, I have been quite happy with rshell until I started working on these wireless nodes. Being lazy, I want to tinker with my ESP32 modules from the sofa, not drag my laptop into the kitchen or balcony to plug up a USB cable. Can’t I work with them wirelessly?
Well, you can use WebREPL. While its functional, it just didn’t strike my fancy for some reason. [Elliot] mentioned in a recent podcast that he’s using telnet to access his wireless nodes, but he’s using esp-link on an ESP8266, which means throwing another chip into the mix.
The Thonny IDE
I had all but given up when by chance I saw this video on the Dronebot Workshop channel about running MicroPython on the new Raspberry Pi Pico boards. Bill was using Thonny, a Python IDE that is popular in the education community.
Installation and Connection
Instructions are clearly given on the project’s website. There is a downloader link at the top of the page for Windows. For Linux and Mac simply doing sudo apt install thonny or brew install thonny was all I needed. If you have a Raspberry Pi, you will find Thonny is pre-installed — version 3.3.3 was found on a recent Pi 4 in my lab.
I had no problems using the REPL manually, but I discovered an issue once you start testing self-starting applications with forever loops. If you are not careful, your application’s main loop can prevent you from regaining REPL control. The solution is to make sure your application sleeps for several milliseconds in the main loop. I tested with 100 ms (see here) and was always able to regain control. This shouldn’t be an issue in most home sensor applications, where the module may sleep for tens of minutes between readings.
https://www.youtube.com/watch?v=Zy64kZEM_bg&t=1395s
Tomi Engdahl says:
Debug ARM Virtually
https://hackaday.com/2021/04/23/debug-arm-virtually/
With the advent of super powerful desktop computers, many developers make use of some sort of virtual or psuedo-virtual machines (VM). We run Windows in a VM and do kernel development in a VM, too. If you are emulating the same kind of computer you are on then the process is simpler, but it is possible to run, say, ARM code on an x86 (or vice versa) but with possibly slower performance than running natively. QEMU is probably the best-known program that allows a CPU to run code targeting a different CPU, but — by default — it targets desktop, laptop, and server-class machines, not tiny embedded boards. That’s where xPack QEMU Arm comes in. It allows you to run and debug embedded Cortex-M devices in an emulated environment on a host computer.
https://xpack.github.io/qemu-arm/
Tomi Engdahl says:
https://hackaday.com/2021/05/04/avr-bare-metal-with-lisp/
There are two kinds of programmers: those who don’t use Lisp, and those who need new parenthesis keycaps every six months. Lisp is one of those languages you either really love or really hate. If you love it, you may have checked out ulisp, which runs on Arduino boards of the AVR and ARM variety, as well as ESP chips, RISC-V, and others. A recent update allows the language to insert assembler into AVR programs.
We’ve seen badges running ulsip. Honestly, though, we’d be just as happy with Forth and it is easier on our parenthesis keys.
http://www.ulisp.com/show?3IUO
Tomi Engdahl says:
https://etn.fi/index.php/13-news/12102-arduino-korttia-voi-nyt-koodata-pilvessa
https://store.arduino.cc/digital/create#
Tomi Engdahl says:
https://hackaday.com/2021/05/09/ello-is-a-tiny-computer-with-a-c-interpreter/
When we talk about a retrocomputer, it’s our normal practice to start with the hardware. But with [KnivD]’s ELLO 1A while the hardware is interesting enough it’s not the stand-out feature. We are all used to microcomputers with a BASIC interpreter, but how many have we seen with a C interpreter? The way C works simply doesn’t lend itself to anything but a compiler and linker, so even with a pared-down version of the language it still represents a significant feat to create a working interpreter.
ello.cc
Tomi Engdahl says:
https://hackaday.com/2021/05/10/embedded-rust-hack-chat/
Tomi Engdahl says:
Blynk Takes Aim at IoT Startups with New Highly-Flexible No-Code Development Platform
Covering a claimed 90-100 percent of an early-stage IoT businesses’ development needs, the new Blynk will “cost less than your TV sub.”
https://www.hackster.io/news/blynk-takes-aim-at-iot-startups-with-new-highly-flexible-no-code-development-platform-f0e33a7f37f7
Internet of Things (IoT) specialist Blynk, known for its no-code development platform, has announced it’s making a push into commercial development — offering a platform that, it says, can scale to over 90-100 percent of use cases for the first few years of a company’s IoT operations.
“We spent the last 3 years turning Blynk into the most user-friendly and well-designed commercial IoT software platform in the world,” founder and chief executive Pavlo Bayborodin explains. “The mission of new Blynk is to further eliminate barriers of entry for new IoT-powered businesses of all sizes. IoT solutions will no longer be a privilege of companies with large engineering teams.”
Building on the company’s existing no-code platform, the relaunched Blynk aims to cover the vast majority of the IoT development workload – from device provisioning and management to cloud hosting, mobile and web app control, over-the-air firmware updates, analytics and more.
Tomi Engdahl says:
SERIAL STUDIO: EASILY VISUALISE AND LOG SERIAL DATA
https://hackaday.com/2021/01/31/serial-studio-easily-visualise-and-log-serial-data/
Outputting data from a microcontroller over a serial port is convenient and easy, but formatting, visualizing, and analyzing the data can be tedious and frustrating. [Alex Spataru] knows this all too well, having spent too many hours building and debugging custom dashboards. To save himself and others the same frustration in the future, he created Serial Studio, a tool for quickly building dashboards for serial data.
https://www.alex-spataru.com/blog/introducing-serial-studio
Tomi Engdahl says:
SLICK WEB OSCILLOSCOPE IS READY IN A FLASH (LITERALLY)
https://hackaday.com/2021/02/22/slick-web-oscilloscope-is-ready-in-a-flash-literally/
Tomi Engdahl says:
How open systems support end users
End users have been vocal about wanting open systems, and automation vendors are responding by delivering systems compliant with international standards.
https://www.controleng.com/articles/how-open-systems-support-end-users/?oly_enc_id=0462E3054934E2U
Japan’s Ministry of Economy, Trade, and Industry recently released a digital transformation (DX) report titled: “Overcoming the IT system ‘2025 Cliff’ and major development on the DX,” which identified legacy information technology (IT) systems as a major obstacle hindering DX. Legacy system obstacles are not limited to IT systems; legacy automation control and monitoring systems also create obstacles.
The report anticipated various problems such as black boxing due to technological obsolescence, the retirement of system designers, and further restrictions with the introduction of new technologies. [Applying a ‘black box’ with proprietary hardware and software inside may temporarily resolve a few issues but can create a tangle of incompatible technologies.] Once automation systems are introduced, they are expected to remain in continuous service for 20 or 30 years, which makes upgrades or replacements difficult.
From closed to partially open automation
DCS vendors have often met end user expectations by integrating proprietary products into complete systems. Vendors stressed differentiating characteristics while developing products for consistent and stable performance. All the while, these systems gradually conformed with de facto and international standards, often by using existing commercial off-the-shelf technology to evolve their systems to meet market demands. Up to now, this evolution progressed not only through proprietary development, but also by incorporating general-purpose products available in the market.
Standards enable open automation systems
Partially-open systems played a role in meeting end user needs, but as time passed, they were replaced by newer systems, which were often updated to stay current. This evolution was necessary to support end users, and to adopt technologies such as general-purpose operating systems, Ethernet communication, virtualization, and other advancements
However, the market has changed and this arrangement has limits. Vendors may need to shift from integrating their systems to developing the end user’s business while cooperating with other vendor companies, some of which may be direct competitors.
To cope with this paradigm shift, a network of companies has emerged to form a business ecosystem. Representative organizations that consider technological standards and industry development include NAMUR (a German process industry automation system user group) and the Open Process Automation Forum (OPAF), the group that develops open process automation (O-PAS) systems.
NAMUR open architecture (NOA) and OPAF devote discussions to systems that are vendor-neutral, meaning they can accommodate devices and functions with the latest technology at any time, with compliant systems continuing to use existing software applications as assets in the future.
In the case of NOA, an independent domain called monitoring and optimization is prepared separately from existing systems to directly acquire data from new sensors (such as vibration, audio, corrosion, odor), robots, drones, and other equipment. Further, the communication standard OPC UA from OPC Foundation is used to acquire data from existing systems for advanced control, analysis, and diagnosis. In terms of security measures, this approach has a high affinity with the zone design recommended by IEC62443 (control system security), easing system design and maintenance. OPAF promotes many of the same ideas by advocating for independence from existing systems.
Practical and value-based Industry 4.0
Industry 4.0 might seem daunting and expensive, but manufacturers can make it practical without getting bogged down in details.
https://www.controleng.com/articles/practical-and-value-based-industry-4-0/?oly_enc_id=0462E3054934E2U
Tomi Engdahl says:
From a system integration standpoint, it is necessary to conform to international standards and to become certified through a third-party certification body. Companies should ensure their system products comply with IEC62443 (control system security) and IEC62541 (OPC UA), and these activities will continue in the future.
https://www.controleng.com/articles/how-open-systems-support-end-users/?oly_enc_id=0462E3054934E2U
Tomi Engdahl says:
Guidelines for Mitigating Timing Side Channels Against Cryptographic Implementations
https://software.intel.com/security-software-guidance/secure-coding/guidelines-mitigating-timing-side-channels-against-cryptographic-implementations
Tomi Engdahl says:
https://etn.fi/index.php/13-news/12125-simulink-ja-matlab-sovelluksia-suoraan-sulautettuihin
Tomi Engdahl says:
New regulations will soon set cybersecurity requirements to almost all electronics, regardless of industry. In particular, the product development process is under the magnifying glass. What does it take to ensure that end products will be compliant? Read our tips!
3 tips towards developing cybersecure products
https://www.etteplan.com/stories/3-tips-towards-developing-cybersecure-products?utm_source=facebook&utm_medium=paid&utm_campaign=SES_3_tips_towards_developing_cybersecure_products_continuous_en_21&utm_content=article&fbclid=IwAR26-I7g_kjfJs4KG-Pqm_JALhYoLx0JnP28SVl5nmYQBOwaINjzPFP8bZw
New regulations will soon set cybersecurity requirements to almost all electronical products. For manufacturers this will mean that security should be integrated into the product development process. What does it take to ensure that end products are going to fulfill the rules?
If a product such as embedded electronics seems more like hardware than software, cybersecurity can easily be missed or belittled. If that happens, and the product is launched in the market, it is prone to be easy prey for cyberattacks. In the worst case, the product can be dangerous to its users.
“A common misconception is to simply develop a product first, and to perform a quick vulnerability test as the very last thing in the development process. Another misconception is to believe that the developers are highly skilled and will take cybersecurity into account automatically without any need to specify or demand anything”, says Mikko Lindström, Etteplan’s Director of Software Testing and Cybersecurity.
Tomi Engdahl says:
Starting in 2023, new regulations will set tight cybersecurity requirements to almost all electronics manufacturers. Is your company ready to comply with the forthcoming legislation and standards? Read more!
https://www.etteplan.com/stories/towards-less-vulnerable-embedded-electronics-new-regulation-cybersecurity?utm_source=facebook&utm_medium=paid&utm_campaign=SES_towards_less_vulnerable_embedded_electronics_new_regulation_cybersecurity_continuous_en_21&utm_content=article&fbclid=IwAR1VcG15x3ixiRp8Lqa8fDxqAFkZQyLNMt-J1_DUSL6otAzr1qwKRzK6FbI
Tomi Engdahl says:
“In 2021, the maker movement is alive and well in schools, homes, and enterprises. And the companies that are enabling the next wave of the IoT still have a developer mindset at their core. Companies like the Raspberry Pi Foundation and Arduino still serve the maker and developer with the product every day, even as they add professional-grade tools to their portfolio.”
(via IoT For All)
https://www.iotforall.com/why-iot-developers-still-matter
Tomi Engdahl says:
What is a debugger? HackSpace magazine takes a look at debugging, what it does, and explains how to add hardware that can be used to tell us what our devices are really thinking
Debugging embedded software with Raspberry Pi Pico
https://www.raspberrypi.org/blog/debugging-embedded-software-with-raspberry-pi-pico/
Tomi Engdahl says:
Put APIs To Work Wth This ArduinoJson Walkthrough
https://hackaday.com/2021/05/28/put-apis-to-work-wth-this-arduinojson-walkthrough/
One of the things this community is famous for is the degree to which people will pitch in to fill an obvious need. Look at the vast array of libraries available for Arduino as an example of how people are willing to devote their time to making difficult tasks easier, often for little more than a virtual pat on the back.
One level up from the library writers are those who go through the trouble of explaining how all these libraries work in real-world applications. [Brian Lough] recently rose to that challenge with a thorough explanation of the use of the ArduinoJSON library, a very useful but often confusing library that makes IoT projects easier.
The need for an ArduinoJSON explainer no knock on its author, [Benoît Blanchon], who has done excellent work documenting the library; it’s more of a realization that the nature of JSON itself means a library that works with it is going to be complex.
Parsing Data From an API using ArduinoJSON (ESP8266/ESP32)
https://www.youtube.com/watch?v=NYP_CxdYzLo
Tomi Engdahl says:
https://embeddeddesignblog.blogspot.com/2021/06/embedded-systems-architecture.html?m=1
Tomi Engdahl says:
https://www.etteplan.com/stories/using-fault-tree-analysis-analyse-software-architecture-automotive-design?utm_source=facebook&utm_medium=paid&utm_campaign=SES_using_fault_tree_analysis_analyse_software_architecture_automotive_design_continuous_en_21&utm_content=article&fbclid=IwAR3Z8dFB8KABkuO1ZDNM0nujbRSPSLmfPcK4QsI3RcvxftwrJglFqJwYBlY
Tomi Engdahl says:
Autosi turvallisuus riippuu ohjelmiston testauksesta
https://etn.fi/index.php/13-news/12274-autosi-turvallisuus-riippuu-ohjelmiston-testauksesta
Hollantilainen Solid Sands on esitellyt SuperGuard-työkalun, joka on keskeisessä roolissa autojen toiminnallisen turvallisuuden varmistamisessa. Työkalu tarkistaa, että autojen ohjelmistojen C-kirjastot täyttävät vaaditut standardit. Tämä on välttämätöntä, sillä nykyisen ajoneuvon järjestelmät koostuvat miljoonista, eri toimittajilta tulevista koodiriveistä.
SuperGuard on C-kirjastojen kvalifioinnin työkalu. Järjestelmän ohjaimilla ladattavien kirjastojen viallisuus johtaa järjestelmän luotettavuuden pettämiseen. Pahimmillaan kyse on yhtä fataalista viasta kuin mekaanisten jarrujen pettämisestä.
Solid Sandsin teknologiajohtaja Marcel Beesterin mukaan testaaminen on periaatteessa helppoa. C-standardi pilkotaan toiminnallisiin vaatimuksiin, jotka tulevat standardista (autoissa ISO 26262, teollisuudessa IEC 61508 ja raideliikenteessä EN 50128). Työkalulla kirjastot testataan, jotta standardin asettamat vaatimukset täyttyvät.
Tomi Engdahl says:
Deploying task-specific #microcontrollers simplifies complex designs Microchip Technology Inc. #MCUs #MPUs #RTOS #oscillator #memory
Deploying task-specific microcontrollers simplifies complex designs
https://www.edn.com/deploying-task-specific-microcontrollers-simplifies-complex-designs/?utm_content=buffer02a94&utm_medium=social&utm_source=edn_facebook&utm_campaign=buffer
In today’s electronics world, large 32-bit microcontrollers (MCUs) and microprocessors (MPUs) running an RTOS are increasingly common. However, a single large microcontroller handling a complex application may run into issues with CPU resources with regards to small housekeeping tasks, which are not complex, but are time-consuming. Smaller devices, like 8- and 16-bit MCUs, can be used to offload these tasks from the 32-bit device.
these tasks are more manageable if the 32-bit device offloads some of these tasks to sub-processors that handle only one or two of these tasks, but require little supervision in doing so. This frees up CPU resources on the main processor, which reduces software complexity while improving performance and execution time.
This solution is analogous to the benefits of peripherals in MCUs.
The biggest benefit of creating an I/O expander using an 8-bit MCU is the flexibility. The feature set of an I/O expander ASIC is baked into the device, whereas the MCU defines its behavior based on the software it executes. This flexibility allows the MCU-based version to be adapted to fit the needs of the end application.
Internally, the advanced I/O expander operates on a lookup-table-based structure. Before reading or writing, a virtual address is sent. This address does not correlate with registers on the MCU—it’s only specific to the lookup table. This means that features not in the hardware registers of the MCU can be added transparently. Entries in the table can be easily rearranged for specific uses as well. Another benefit of this structure is the ability to add permissions to the lookup table (Figure 1). For instance, to create a read-only register, simply omit the write lookup table entry.
Demonstrations of the advanced I/O expander with an Arduino are also available.
Source code, documentation, and demonstrations are available on GitHub.
Voltage-to-frequency (V/F) converter
The V/F converter improves upon the traditional analog solution by reducing the bill of materials (BOM) and thus the design area.
Rather than using analog techniques to digitize, the MCU uses a combination of core-independent peripherals and features. The MCU measures the input signal with the internal analog-to-digital converter with computation (ADCC) and then divides a clock signal to create a variable frequency output.
One challenge with the MCU-based approach is that it does not perform as well as the analog solution does. The resolution of the output is intrinsically limited by the ADCC. Nominally, the ADCC is 12-bits, but with the way the program is configured, the ADCC runs at an oversampled 14-bit resolution. Likewise, the on-board numerically-controlled oscillator (NCO) that synthesizes the output frequency has finite resolution and can have jitter in its output, depending on the value measured by the ADCC.
Takeaways from this solution
This design example demonstrates the use of hardware peripherals to create a core-independent function that ordinarily would have to be created with an external IC. One of the biggest benefits to this configuration is that the peripheral operation is setup in software, making it easy to adjust to the end-application. For implementing the example, the PIC18-Q43 family of MCUs was selected due to the large number of peripherals in use.
Source code and documentation are available on GitHub.
https://github.com/microchip-pic-avr-examples/pic18f57q43-v-to-f-mplab-mcc
Tomi Engdahl says:
Implement secure update in #IoT designs
#security #software
https://buff.ly/3vFbBHI
Tomi Engdahl says:
https://etn.fi/index.php/tekniset-artikkelit/12308-miten-valita-oikea-flash-muisti-koviin-olosuhteisiin
Tomi Engdahl says:
Etteplan Webinar: Standardization of Production Testing
https://www.youtube.com/watch?v=fkewYd_tmPk
In this webinar you can learn about the standardization of testing and its benefits from Etteplan’s and Virinco’s experts. The webinar also includes a real world business case from Planmeca where the benefits are highlighted.
Tomi Engdahl says:
Webinar: Embedded cyber security – regulatory news update
https://www.youtube.com/watch?v=NDTAHRyDdMY
Watch this session to get a concise overview of the most interesting regulatory news over the first half of 2021 and possible next steps, both from Operational Technology and Consumer IoT perspectives. Also highlights from ETSI Security Week 2021 will be summarized.
Tomi Engdahl says:
Adafruit Industries’ Lady Ada has shown off a new feature in CircuitPython: the ability to connect to selected development boards entirely wirelessly using Web Bluetooth.
Adafruit Shows Off Wireless CircuitPython Programming via Web Bluetooth
https://www.hackster.io/news/adafruit-shows-off-wireless-circuitpython-programming-via-web-bluetooth-9ea36e4d5177
Demo requires a tweaked Google Chrome browser and an nRF52840 development board with native Bluetooth.
Tomi Engdahl says:
RT-Thread Smart Offers a Lightweight, Microkernel Operating System for MMU-Equipped Microcontrollers
Just as open source as ever, RT-Thread Smart is designed as a bigger brother to RT-Thread — and uses RT-Thread as its kernel.
https://www.hackster.io/news/rt-thread-smart-offers-a-lightweight-microkernel-operating-system-for-mmu-equipped-microcontrollers-83f7349dea6b