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,667 Comments
Tomi Engdahl says:
M.2 For Hackers – Cards
https://hackaday.com/2022/11/07/m-2-for-hackers-cards/
Last time, I’ve explained everything you could want to know if you wanted to put an M.2 socket onto your board. Today, let’s build M.2 cards! There’s a myriad of M.2 sockets out there that are just asking for a special card to be inserted into it, and perhaps, it’s going to be your creation that fits.
Why Build Cards?
Laptops and other x86 mainboards often come with M.2 slots. Do you have a free B-key slot? You can put a RP2040 and bunch of sensors on a B-key PCB as an experimental platform carried safely inside your laptop. Would you like to do some more advanced FPGA experiments? Here’s a miniscule FPGA board that fits inside your laptop and lets you play with PCIe on this same laptop – the entire setup having a super low footprint. Are you looking for an extra PCIe link because you’re reusing your laptop as a home server? Again, your WiFi slot will provide you with that. Want to get some PCIe out of a SteamDeck? Building a M-key 2230 card seems to be your only hope!
Tomi Engdahl says:
Arm aims to accelerate embedded and IoT software development by integrating its tools into GitHub and cloud-based design workflows….
Arm Virtual Hardware available on GitHub, AutoML platforms
https://www.edn.com/arm-virtual-hardware-available-on-github-automl-platforms/
Arm is joining hands with GitHub and cloud-based artificial intelligence (AI) and Internet of Things (IoT) toolchain suppliers in a bid to expand the availability of its tools like cross-compiler and Arm Virtual Hardware. Arm, for instance, is integrating its development tools into GitHub Actions, a CI/CD platform that allows developers to automate their build, test, and deployment pipeline.
Developers can now use the Arm compiler and cross-compiler natively within GitHub Actions. Next, they can access Arm Virtual Hardware models of Corstone-based compute systems and Arm Cortex-M processors via self-hosted and GitHub-hosted runners.
Tomi Engdahl says:
MORE OPTIONS WITH 8 AND 16-BIT MICROCONTROLLERS
https://etn.fi/index.php/tekniset-artikkelit/14220-more-options-with-8-and-16-bit-microcontrollers
8 and 16-bit MCUs are an invaluable tool for performing small, specialized tasks. The tasks aren’t necessarily complex, but they can be time consuming or time critical. By offloading the tasks, the 32-bit devices can have simpler implementations that improve reliability, reduce memory usage, and lower power consumption.
In today’s world, large 32-bit microcontrollers and microprocessors running a real time operation system (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.
Tomi Engdahl says:
https://etn.fi/index.php/13-news/14221-lisaeae-vaihtoehtoja-8-ja-16-bittisillae-mikro-ohjaimilla
Tomi Engdahl says:
ROS: Robot Operating System
These articles examine the open-source Robot Operating System also known as ROS.
https://www.electronicdesign.com/magazine/51051
Tomi Engdahl says:
Elektronisen laitteen tulisi suorittaa käynnistymisen yhteydessä itsediagnostiikka.
Sen pitäisi esimerkiksi testata antureiden olemassa olevuus ja niiden toiminta, kuten muistilaitteiden-, virtalähteen-, sekä kommunikaatiokanavan toiminta.
Mitä muuta itsediagnostiikasta tulisi ottaa huomioon? Lue lisää täältä: https://www.techat.fi/tietoturvallinen-elektroniikka-osa-2/
Tomi Engdahl says:
MicroPython officially becomes part of the Arduino ecosystem
https://blog.arduino.cc/2022/11/10/micropython-officially-becomes-part-of-the-arduino-ecosystem/
Tomi Engdahl says:
https://blog.arduino.cc/2022/11/09/computer-vision-and-project-mapping-enable-ar-pcb-debugging-bliss/
Tomi Engdahl says:
https://www.edn.com/arm-virtual-hardware-available-on-github-automl-platforms/
Tomi Engdahl says:
How to reduce your IoT costs with Ubuntu Core
https://ubuntu.com/engage/iot-project-costs-how-to-reduce?utm_source=facebook&utm_medium=cpc&utm_campaign=3%29CY22_IOT_Core_T1_WBN_ReduceIoTProjectCost_Form_Facebook_ad&utm_content=3%29CY22_IOT_Core_T1_WBN_ReduceIoTProjectCost_Form_Facebook_ad&utm_term=3%29CY22_IOT_Core_T1_WBN_ReduceIoTProjectCost_Form_Facebook_ad&fbclid=IwAR2DBX08GjTLZMZq5H9FGYKGcbFnIoMmA_vXzJrYfeVwbq24g7pmlUD1bJE
Understand cost drivers, diagnose your cost issues, and discover new solutions
Do your IoT projects always seem to run over budget? Are operating costs eating into your bottom line? This end-to-end dissection of IoT costs will help you recognize what your costs are, identify where the problems lie, and find a solution that fits your product and organisation.
Businesses across industries are recognising the value to be gained from IoT deployments, but there’s no playbook for this fast-growing field. Companies are left to make their own way through an ever-changing landscape of platforms, solution providers, and GSIs.
Tomi Engdahl says:
https://blog.arduino.cc/2022/11/10/micropython-officially-becomes-part-of-the-arduino-ecosystem/
Tomi Engdahl says:
Pretty Petite Picolibc Powers Processors
https://hackaday.com/2022/11/14/pretty-petite-picolibc-powers-processors/
Many times when someone tells you that language X is “better” at something they really mean that it has better built-in libraries for that task. Java is a great example. The language isn’t all that different from C++ outside of garbage collection and multiple inheritance, but the standard libraries are super powerful, especially for networking. Even C relies on a library to provide a lot of functions people think of as part of the language — printf, for example. That’s not really part of the C language, but just part of the standard library. When you are writing for a tiny processor, the choice of library is critical and [Keith Packard] offers you one choice: picolibc.
The library has its genesis from two other diminutive libraries: Newlib and the AVR version of libc. It provides support for ARC, ARM, i386, m68k, MIPS, MSP430, Nios II, PPC, RISC-V, Sparc64, x86_64, and the ESP8266/ESP32.
https://github.com/picolibc/picolibc
Tomi Engdahl says:
https://hackaday.com/2022/11/14/on-getting-a-computers-attention-and-striking-up-a-conversation/
Tomi Engdahl says:
Arduino Brings A MicroPython IDE
https://hackaday.com/2022/11/14/arduino-brings-a-micropython-ide/
Both Arduino and MicroPython are giants when it comes to the electronics education area, and each one of them represents something you can’t pass up on as an educator. Arduino offers you a broad ecosystem of cheap hardware with a beginner-friendly IDE, helped by forum posts explaining every single problem that you could and will stumble upon. MicroPython, on the other hand, offers a powerful programming environment ripe for experimentation, and doesn’t unleash a machine gun fire of triangle brackets if you try to parse JSON slightly incorrectly. They look like a match made in heaven, and today, from heaven descends the Arduino Lab for MicroPython.
This is not an Arduino IDE extension – it’s a separate Arduino IDE-shaped app that does MicroPython editing and uploads code to your board from a friendly environment. It works over a serial port,
https://labs.arduino.cc/en/labs/micropython
Arduino Lab for MicroPython is a lightweight editor for MicroPython programs, supporting connection with a board, code upload, file transfer, interactive REPL shell.
High-level languages let you build projects faster – perfect fit for someone getting into microcontrollers.
This project is sponsored by Arduino, based on original work by Murilo Polese. This is an experimental pre-release software, please direct any questions only to Github issues.
Tomi Engdahl says:
Raudalta toiselle ilman yhtään koodiriviä
https://etn.fi/index.php/13-news/14267-raudalta-toiselle-ilman-yhtaeaen-koodiriviae
Electronica – Perinteisesti sulautettu ohjelmistokehitys on suunnattu hyvin tarkasti jollekin tietylle kohdelaitteistolle. Olisi erinomaista, jos sovelluksensa voisi siirtää joustavasti raudalta toiselle ilman, että ajureita ja firmwarea pitää koodata ainakin osin uusiksi. Avnet Embedded /SimpleSwitch tekee tämän mahdolliseksi.
Nimessä ei muuten ole kirjoitusvirhettä, vaan siihen kuuluu tuo kenoviiva. Itse asiassa Avnetin sulautettu divisioona esitteli tekniikan jo kesäkuun lipulla Nürnbergin Embedded Worldissa, mutta tuolloin siitä ei pidetty isoa meteliä. Electronicassa konsepti on edennyt pidemmälle ja messuilla on jo esillä ensimmäinen demokin.
Idea on sinänsä yksinkertainen: yksinkertaistaa sulautettujen ohjelmistojen kehitystä SMARC 2.1.1 -moduuliperheissä. SimpleSwitchin avulla kehittäjä voi vaihtaa x86- ja Arm-pohjaisten moduulien välillä koodia vaihtamatta.
SimpleSwitch yhdistää SMARC-liittimen, kontit -onhan koodi Linux-natiivia – ja laitteiston abstraktiokerrokset ja säilyttää täyden toiminnallisuuden samalla kun vaihdetaan eri SMARC-moduulien välillä. Jos siis tarvitsee sovellukselleen enemmän suorituskykyä vaikkapa suuremman näytön takia, koodinsa voi SimpleSwitchin avulla viedä tehokkaammalle moduulille.
Tomi Engdahl says:
Sanna Marin: EU:n pitää katkaista teknologinen riippuvuus Kiinasta
https://etn.fi/index.php/13-news/14268-sanna-marin-eu-n-pitaeae-katkaista-teknologinen-riippuvuus-kiinasta
Pääministeri Sanna Marin täytti tänään alkaneen Slushin päälavan katsomot. Slushin toimitusjohtaja Eerika Savolaisen haastattelussa Marin vaati Eurooppaa katkaisemaan teknologisen riippuvuutensa Kiinasta.
- Emme voi olla riippuvaisia Kiinasta. Taloudellisia suhteita ei pidä katkaista, mutta emme voi olla asemassa, jossa erilaisella logiikalla toimiva autoritaarinen maa pystyy kiristämään meitä, Marin sanoi.
Marinin mukaan Eurooppa on oppinut läksynsä kantapään kautta, kun Venäjä hyökkäsi Ukrainaan. Venäjälle Marinilla ei juuri sympatiaa heru. – Taloudelliset suhteet pitää katkaista, Venäjä pitää saada häviämään sota ja viedä joukkonsa pois Ukrainasta.
- Pelkään, että teemme teknologian ja digitaalisuuden kanssa saman virheen kuin energian kanssa. Luulimme, että tiivis taloudellinen suhde estäisi sodan, mutta olimme väärässä.
Tomi Engdahl says:
VMs, Unikernels, and Containers
Developers have a variety of ways to partition their system for modularity and security
https://www.electronicdesign.com/magazine/51323
Tomi Engdahl says:
What’s the Difference in Security Between Virtual Machines and Containers?
Oct. 20, 2022
Virtual machines and containers are widely used in embedded systems to consolidate workloads and enable DevSecOps, but which type of virtualization is more secure and is there a way to make DevSecOps secure?
https://www.electronicdesign.com/technologies/embedded-revolution/article/21253089/green-hills-software-whats-the-difference-in-security-between-virtual-machines-and-containers
Tomi Engdahl says:
Numbers Tell the Story: Addressing Skills Shortages in Engineering
A conversation with Dr. Ashley Huderson on why the future of engineering is interdisciplinary.
https://www.electronicdesign.com/resources/webinars/webinar/21254863/numbers-tell-the-story-addressing-skills-shortages-in-engineering
A crucial challenge in this exploration is the reality that the skills gap will only widen as manufacturers accelerate their digital transformation to Industry 4.0. In conversation with Dr. Ashley Huderson, director of Engineering Education and Outreach at the American Society of Mechanical Engineers (ASME), Machine Design examines the jobs of the future and the skills needed for those roles. Dr. Huderson draws on a recent ASME research study that investigates the future workflows and skills needed for mechanical engineering, manufacturing engineering and machinist roles over the next decade.
Tomi Engdahl says:
What’s Trending in the Global Voice-Recognition Market?
Nov. 11, 2022
From smart TVs to voice-recognition tech for children, the industry for real-time speech analytics and voice biometrics is rapidly expanding.
https://www.electronicdesign.com/technologies/embedded-revolution/article/21254585/global-market-insights-whats-trending-in-the-global-voicerecognition-market
Tomi Engdahl says:
M.2 Data Card Supports LTE Cat 13
Nov. 15, 2022
Equipped for cellular bands between 600 MHz and 3.7 GHz, Telit’s latest LN920 data card handles Cat 13.
https://www.electronicdesign.com/technologies/communications/article/21254738/electronic-design-m2-data-card-handles-lte-cat-13
Tomi Engdahl says:
Challenges Remain in Taking IoT/IIoT
to the Next Level
Addressing the challenges that remain for IoT in the realms of security, design, and deployment.
https://designengineeracademy.com/challenges-remain-in-taking-iot-iiot-to-the-next-level/?pk=PreRegDec2-11162022-MWRF-B&oly_enc_id=7211D2691390C9R
Tomi Engdahl says:
NTSW = not tested should work
Tomi Engdahl says:
NSA Recommends Safe Memory Management
https://www.electronicdesign.com/blogs/altembedded/article/21254694/electronic-design-nsa-recommends-safe-memory-management
Nov. 14, 2022
The U.S. National Security Agency recently published the “Software Memory Safety” Cybersecurity Information Sheet.
What you’ll learn
What is memory safety?
Why is it important?
What does the NSA recommend?
Poor memory-management practices have been the cause of over 70% of the vulnerabilities found in today’s software. This can lead to a host of problems from programs that fail or degrade to providing attackers with a hook into the systems.
“Memory-management issues have been exploited for decades and are still entirely too common today,” said Neal Ziring, Cybersecurity Technical Director. “We have to consistently use memory safe languages and other protections when developing software to eliminate these weaknesses from malicious cyber actors.”
The challenge with embedded programs these days is a vast majority are written in C and C++. C++ can more easily mitigate some memory-management problems but not all. C on the other hand, depends on the watchful eye of the programmer to prevent these kinds of problems. Unfortunately, it’s too easy to include bugs in an application and difficult to identify them especially when looking at someone else’s code.
NSA’s Software Memory Safety Info Sheet
To address these issues, the U.S. National Security Agency (NSA) just released the “Software Memory Safety” Cybersecurity Information Sheet, which you can download. The NSA recommends using compiler options that would harden code, but the challenge is what can be done with a particular compiler. This is normally based on the programming language.
C compilers can check a few things like uninitialized variables. However, it takes a language like Rust or Ada to provide more robust checks. It’s preferable to have the compiler do the checking, since it’s more consistent, will not overlook something that’s programmed to check, and it can force programmers to specify what requirements they have that should be applied regardless of the application.
According to the NSA, “Examples of memory safe language include C#, Go, Java, Ruby, Rust, and Swift.” I find interesting that Ada and SPARK, a provable version of Ada, were not included in the list, especially given Ada’s government heritage.
From an embedded perspective, C++, Rust, and Ada tend to be languages that can address embedded application needs because they don’t use garbage collection. Garbage collection can address a number of memory safety issues. That’s why languages like Java and Ruby are often mentioned as improvements over C because of their garbage-collection support, which prevents dangling pointers.
The paper notes that “Memory safety can be costly in performance and flexibility. Most memory-safe languages require some sort of garbage collection to reclaim memory that has been allocated but is no longer needed by the program. There is also considerable performance overhead associated with checking the bounds on every array access that could potentially be outside of the array.”
This is an interesting statement and applies to languages like Java that require garbage collection. It’s also not true that memory-safe languages require garbage collection, as Rust and Ada/SPARK don’t have this “feature.”
Static and Dynamic
The paper also says that “Several mechanisms can be used to harden non-memory-safe languages to make them more memory safe. Analyzing the software using static and dynamic application security testing (SAST and DAST) can identify memory use issues in software.”
What’s intriguing is that they’re talking about security, because security and safety are two different although related programming topics. Static- and dynamic-analysis tools are useful in address safe memory use, too. They’ve been the backbone for supporting much of the safety-related standards like ISO 26262, where companies need to “prove” the safety and reliability of the application.
Such applications have typically been written in C and C++, but they also require significant checking by humans, which isn’t as reliable as software when repeatedly doing many of these checks. Of course, we tend to be better at finding more complex logic errors versus the more straightforward memory manipulation problems being addressed by languages like Rust and Ada/SPARK.
Carving a Path to High-Quality Software
We’ve been covering development of high-quality software for some time as well as Ada/SPARK and Rust.
Part of the challenge with any solution involving more than one programming language is interfacing, as well as finding or developing qualified programmers. Interfacing is the more challenging of the two—the differences are forced by the languages themselves, which change slowly and look at interfacing between systems as a secondary issue.
The differences in language support also can be significant. For example, Rust uses traits to provide object-oriented-style support. Direct use of C++ objects with Rust can be a challenge for this reason. Even mixing C++ and Ada may be a challenge in this area because of differences in their similar but not identical class/object hierarchy.
Adding more compilers and tools as well as training programmers in a new language will incur further costs; however, one must look at the cost as well as the payback. Remember, the reason for even discussing memory-safe languages is to reduce errors, prevent attacks due to errors, and deliver software.
One interesting aspect is that software often can be delivered faster because fewer errors are in the code. That’s because the language and compilers prevent programmers from overlooking these problems.
If you haven’t considered any of the safer programming alternatives but want to check them out, I have two online recommendations. One is the Rust Playground. This provides a web-based development system to try out simple Rust applications.
The other is learn.adacore.com, which is a tutorial-based introduction to Ada and SPARK.
https://media.defense.gov/2022/Nov/10/2003112742/-1/-1/0/CSI_SOFTWARE_MEMORY_SAFETY.PDF
Tomi Engdahl says:
Quick Poll: What’s Your Most Commonly Used Diagnostic Development Tool?
Nov. 11, 2022
Take a quick poll and see what other engineers and programmers are up to.
https://www.electronicdesign.com/technologies/test-measurement/article/21254588/quick-poll-whats-your-most-commonly-used-diagnostic-development-tool?utm_source=EG+ED+Auto+Electronics&utm_medium=email&utm_campaign=CPS221103036&o_eid=7211D2691390C9R&rdx.identpull=omeda|7211D2691390C9R&oly_enc_id=7211D2691390C9R
Tomi Engdahl says:
Innovative guides and grips enhance card-cage/chassis cooling capabilities
https://www.edn.com/innovative-guides-and-grips-enhance-card-cage-chassis-cooling-capabilities/
Transferring component and circuit heat from its various sources to that mystical, magical, cooler place called “away” in order to keep a board or assembly cool is an ongoing battle. Just when you think there’s no more thermal headroom, demands increase and somehow new cooling needs must be met with innovative approaches.
How much so? Numbers vary, but a study by Uptime Institute, LLC (an “IT service management company”) maintains that per-rack density in 2020 was about 8.4 kilowatts (kW), up from just 2.4 kW in 2011 (Figure 1), with 46% of the racks dissipating between 5 and 9 kW (Figure 2); those numbers are reasonably in line with others I have seen.
There’s some irony in these numbers. When vacuum tubes were displaced by solid-state devices (first transistors, then ICs) it seemed like power problems and dissipation issues would be greatly reduced—and they were, as long as you were replacing an existing function, such as a radio receiver. However, as ICs got smaller and lower power, the sophisticated systems they went into were expected to dissipate power at an even higher rate.
In effect, the demands placed on systems and the components which implement them grew faster than the rate of power decrease. You might call it yet another manifestation of the law of unintended or unforeseen consequences. As a result of this increased dissipation, basic assembles such as embedded-system card cages are now being severely stressed thermally.
How much heat can a system handle? There are many guidelines out there, as the answer depends on multiple factors. One metric which popped up several times during my research as a starting reference point was 1 W/in2 or about 0.15 W/cm2 for maximum board dissipation, which is far higher than it was just a few years ago.
Tomi Engdahl says:
https://www.engineeringclicks.com/halt-testing/
Tomi Engdahl says:
https://hackaday.com/2022/11/14/arduino-brings-a-micropython-ide/
Tomi Engdahl says:
Sulautettu koodi ja asennusaika kutistuvat puoleen
https://etn.fi/index.php?option=com_content&view=article&id=14304&via=n&datum=2022-11-25_15:59:48&mottagare=31202
Saksalaisen SEGGERin uusin Embedded Studion versio sisältää mukana tulevan ajonaikaisen C-kirjaston eli emRunin ja C++-kirjasto emRun++:n lähdekoodin ja on-demand -koontiversion. Kun kirjastojen lähdekoodit ovat mukana, pienenee sulautetun sovelluksen koodi noin puoleen ja sen asennusaika lyhenee 50 prosenttia.
Tyypillisesti sulautettujen sovellusten työkalut sisältävät esikäännetyt kirjastot kaikille tuetuille arkkitehtuureille ja kokoonpanoille, ja asennus vie paljon tilaa kehittäjän koneelta. Embedded Studio rakentaa (ja asentaa) kirjastot automaattisesti, kun niitä käytetään ensimmäisen kerran.
Tyypillinen latauskoko vaihtelee alustasta riippuen 400 megatavusta alle 250 megatavuun, joten levytilaa säästyy melkoisesti.
Tomi Engdahl says:
EdgePro’s Eponymous EdgePro1 Is a LuaJIT-Based Dev Board and DIY Portable Computer
Designed to be programmed in Lua with the speed of native C, the EdgePro1 can be converted into a portable PC via carrier board.
https://www.hackster.io/news/edgepro-s-eponymous-edgepro1-is-a-luajit-based-dev-board-and-diy-portable-computer-8b21285fa16f
Tomi Engdahl says:
PyTCP is a fully functional TCP/IP stack written in Python. It supports TCP stream-based transport with reliable packet delivery based on a sliding window mechanism and basic congestion control. It also supports IPv6/ICMPv6 protocols with SLAAC address configuration. It operates as a user space program attached to the Linux TAP interface.
https://github.com/ccie18643/PyTCP
Tomi Engdahl says:
https://canonical.foleon.com/whitepapers/yocto-vs-ubuntu-core/?utm_source=fb&utm_campaign=3%29CY22_IOT_Core_T1_WP_YoctoUbuntuCoreFoleon_Facebook_ad&fbclid=IwAR2wK7lcd2XkYJOqXSMIpaK5ObJ2roy6D6Wi33KOZbYr2anfgCXd4p6LB8Y
Tomi Engdahl says:
http://linux.blogaaja.fi/2022/08/22/ubuntu/
Tomi Engdahl says:
Built around the Nordic Semiconductor nRF52832, the BlueIO832-Mini promises breadboard-friendly code-free development via a smartphone app.
I-SYST Targets Code-Free Bluetooth Education and the Internet of Things with the BlueIO832-Mini
https://www.hackster.io/news/i-syst-targets-code-free-bluetooth-education-and-the-internet-of-things-with-the-blueio832-mini-46539d9a3b9c
Built around the Nordic nRF52832, the BlueIO832-Mini promises breadboard-friendly code-free development via a smartphone app.
It’s the BlueIOWizard companion app, which is designed to make the board stand out from the competition, however. “This versatile Internet-of-Thing (IoT) framework enables users, from their mobile device (such as a smartphone), to remotely communicate with an electronics device through an easy plug-and-play interface,” I-SYST claims. “Simply connect a sensor to BlueIO, select the sensor on the app and let them talk. After connecting to the target device via a desired serial interface, BlueIO832-Mini streams the data on that physical interface to the BlueIO mobile app over Bluetooth 5.”
Tomi Engdahl says:
HeliOS Embedded Operating System
The free embedded operating system.
https://hackaday.io/project/188418-helios-embedded-operating-system
Tomi Engdahl says:
How Realtime Is Your Kernel? Scope A GPIO To Find Out
https://hackaday.com/2022/12/05/how-realtime-is-your-kernel-scope-a-gpio-to-find-out/
When debugging something as involved as kernel scheduler timings, you would typically use one of the software-based debugging mechanisms available. However, in cases when software is close to bare metal, you don’t always need to do that. Instead, you can output a signal to a GPIO, and then use a logic analyzer or a scope to measure signal change timing – which is what [Albert David] did when evaluating Linux kernel’s PREEMPT_RT realtime operation patches.
Linux-PREEMPT_RT Scheduler latency measurement with Oscilloscope
http://albert-david.blogspot.com/2022/10/linux-preemptrt-scheduler-latency.html
Tomi Engdahl says:
Better Coding Through Sketching
https://hackaday.com/2022/12/03/better-coding-through-sketching/
Back in the late 1970s and early 1980s, engineering students would take a few semesters of drafting and there would usually be a week or two of “computer-aided drafting.” In those days, that meant punching cards that said RECTANGLE 20,30 or something like that and getting the results on a plotter. Then we moved on to graphical CAD packages, but lately, some have gone back to describing rather than drawing complex designs. Cornell University researchers are trying to provide the same options for coding. They’ve built a Juypter notebook extension called Notate that allows you to sketch and handwrite parts of programs that interact with traditional computer code. You can see a video about the work below.
https://techxplore.com/news/2022-11-tool-code.html
New programming tool turns sketches, handwriting into code
https://www.youtube.com/watch?v=Eynks13Gsfg
Tomi Engdahl says:
Hackerboards: Making Finding The Right Single-Board Computer Easy
https://hackaday.com/2022/12/02/hackerboards-making-finding-the-right-single-board-computer-easy/
The great thing about the wide availability of single-board computers (SBCs) is that it offers such a large selection of options, in terms of CPU performance, GPU features, RAM size, I/O options and much more. This is however also the largest issue, especially with the annual surge of new boards with new feature sets. Trying to make sense of all these offerings is the recently overhauled Board-DB, also known as Hackerboards.
https://hackerboards.com/
Board-DB, now also known as HackerBoards, is an established comparison website for any single-board computer (SBC), module (SoM) and Linux-supported development board.
Tomi Engdahl says:
Ohjaa sulautettua sovellusta näytöllä USB:n kautta
https://etn.fi/index.php/13-news/14359-ohjaa-sulautettua-sovellusta-naeytoellae-usb-n-kautta
Saksalainen SEGGER tunnetaan sulautettujen sovellusten työkalujen kehittäjän. Nyt yhtiö on esitellyt tekniikan, jolla näytötöntä (headless) sulautettua sovellusta voidaan ohjata toisen laitteen näytöllä. Tähän tarvitaan vain USB-liitäntä ja emVNC Server -palvelinratkaisu.
Tekniikalla on monia käyttötapoja. Sulautetussa järjestelmässä, jossa on näyttö, tämä näyttö voidaan peilata etätietokoneessa. Sulautetussa järjestelmässä ilman näyttöä virtuaalisen näytön sisältö voidaan näyttää.
Yksi esimerkki käyttötavasta on tulostin. VNC-over-ISB -tekniikalla voitaisiin kehittää edullinen tulostin, jossa ei tarvita LCD-näyttöä. Useimmissa tapauksissa näyttöä tarvitaan yhden kerran, yhdistämään tulostin Wi-Fi-verkkoon. EmVNC-tekniikka korvaisi tämän näytön edullisella USB-liitännällä.
Tomi Engdahl says:
https://www.segger.com/user-interface/emvnc/
Tomi Engdahl says:
Discover how RIoT Secure AB developed a secure device lifecycle management platform based on Arduino’s range of MKR boards for communications and over-the-air updates, specifically targeting resource-constrained microcontrollers: https://www.arduino.cc/pro/case-studies-riot-secure
Tomi Engdahl says:
https://www.uusiteknologia.fi/2022/12/09/arduino-kortit-teollisuuden-ammattisovelluksiin/
Tomi Engdahl says:
https://hackaday.com/2022/12/10/lisp-runs-this-microcontroller-pendant/
Tomi Engdahl says:
https://hackaday.com/2022/12/13/push-esp32-over-the-air-updates-from-github/
Tomi Engdahl says:
Uusi näyttöliitäntästandardi sulautettuihin laitteisiin
https://etn.fi/index.php/13-news/14390-uusi-naeyttoeliitaentaestandardi-sulautettuihin-laitteisiin
DISCON on nimeltään Mikroen kehittämä uusi avoin sulautettujen laitteiden näyttöliitännän standardi. Neljä vuotta työn alla ollut standardi määrittää liitännät sekä näyttökortin kannalle (socket) että liittimelle. Liitäntään voidaan liittää TFT-, OLED-, eInk- tai mikä tahansa näyttö.
DISCON on fyysisesti 2 x 20 -nastainen liitin, jossa on kaksi I2C-linjaa, 8 nastaa GPIO-linjoille, datanastoja aina 24-bittistä liitäntää varten sekä kaksi nastaa tehon syöttämiselle näyttökortille (Display Card). Nastat ovat normaalit jännite ja maa.
https://cdn.mikroe.com/cms/discon/discon-standard-guidelines-2022-final.pdf
Tomi Engdahl says:
Simplify debugging to reduce the complexity of embedded system development
Simplify debugging to reduce the complexity of embedded system development
https://techcrunch.com/2022/12/20/simplify-debugging-to-reduce-the-complexity-of-embedded-system-development/?tpcc=tcplusfacebook
The complexity associated with the development of embedded systems is increasing rapidly. For instance, it is estimated that the average complexity of software projects in the automotive industry has increased by 300% over the past decade.
Today, every piece of hardware is driven by software and most hardware is composed of multiple electronic boards running synchronized applications. Devices have more and more features, but adding features means increasing development and debugging complexity. A University of Cambridge report found that developers spend up to 50% of their programming time debugging.
Thankfully, there are practical ways to reduce the complexity of debugging embedded systems. Let’s take a look.
Earlier is better
Debugging will only be efficient if you have the right information.
Bugs will pop up during the entirety of a product’s lifetime: in development, testing and in the field. Resolving a bug later down the road can increase costs by as much as 15 times and lead to user frustration, in addition to creating challenges associated with updating embedded devices that are in production.
However, identifying bugs at the early stages of your product’s development will allow you to track them while prioritizing them by severity. This will allow you to debug before other dependencies and variables are introduced later in the lifecyle, which makes bugs easier and cheaper to resolve.
Manage versioning
To properly replicate a bug, you must be able to have a device in the exact same state it was when the bug first appeared.
Tomi Engdahl says:
11 Myths About Using Formal Verification
Nov. 23, 2022
Axiomise’s Dr. Ashish Darbari dispels a host of myths to highlight the advantages of formal verification for IC design.
https://www.electronicdesign.com/technologies/eda/article/21254774/axiomise-11-myths-about-using-formal-verification?code=UM2DE&utm_source=EG+ED++Digital+Edition&utm_medium=email&utm_campaign=CPS221207127&o_eid=7211D2691390C9R&rdx.identpull=omeda|7211D2691390C9R&oly_enc_id=7211D2691390C9R
Tomi Engdahl says:
https://www.st.com/content/st_com/en/campaigns/azure-rtos-stm32cube-mcu-free-software-development.html
Tomi Engdahl says:
GitHub ESP32 OTA Updates, Now In MicroPython Flavor
https://hackaday.com/2022/12/23/github-esp32-ota-updates-now-in-micropython-flavor/
Wouldn’t it be great if you could keep all of your small Internet-connected hacks up to date with a single codebase? A couple of weeks ago, we wrote up a project that automagically pulls down OTA updates to an ESP32 from GitHub, using the ESP32 C SDK. [Pascal] asked in the comments, “but what about MicroPython?” Gauntlet thrown, [TURFPTAx] wrote ugit.py – a simple library that mirrors all of the code from a public GitHub Python repo straight to your gizmo running Micropython.
https://github.com/turfptax/ugit
Tomi Engdahl says:
https://www.electronicdesign.com/blogs/altembedded/article/21254694/electronic-design-nsa-recommends-safe-memory-management