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:
Raspberry Pi Kernel Development | Writing a Raspberry Pi ARM GPIO Driver in C | Embedded Concepts
https://www.youtube.com/watch?v=lWzFFusYg6g
In this video, we talk about the purpose of drivers and why they are necessary when working on embedded systems. Later, we go over how to install the Raspberry Pi kernel headers and use them to write a kernel driver for the device. Finally, we install the kernel driver and prove that it is running on our device. This is part one in a video series for creating a GPIO driver for the Raspberry Pi!
Tomi Engdahl says:
Who Is Thinking About Open Source Firmware?
https://hackaday.com/2022/05/14/who-is-thinking-about-open-source-firmware/
Yesterday, we ran a post on NVIDIA’s announcement of open-source drivers for some of its most recent video cards. And Hackaday being huge proponents of open-source software and hardware, you’d think we’d be pouring the champagne. But it’s trickier than that.
Part of the reason that they are able to publish a completely new, open-source driver is that the secrets that they’d like to keep have moved into the firmware. So is the system as a whole more or less open? Yeah, maybe both.
Tomi Engdahl says:
Electronics And C++ Education With An ATTiny13
https://hackaday.com/2022/05/14/electronics-and-c-education-with-an-attiny13/
Tomi Engdahl says:
zeptoforth
A Cortex-M native code Forth along with an RTOS
https://hackaday.io/project/170826-zeptoforth
zeptoforth is a bare-metal Cortex-M Forth which includes an preemptively-multitasking, priority-scheduled RTOS. It currently supports the Raspberry Pi Pico (and other RP2040-based boards with Winbond Quad SPI flash), STM32L476, STM32F407, and STM32F746 DISCOVERY boards, but work is planned on porting it to other boards in the near future.
Details
zeptoforth is a portable subroutine-threaded / native code inlining Forth for Cortex-M0+/M4/M7 microcontrollers which includes a preemptively multitasking RTOS designed to be able to compile to and run from both flash and RAM (the kernel of course exists in flash).
The library of code coming with zeptoforth includes support for the following:
Lambda expressions
Double-cell and fixed-point arithmetic, including the usual mathematical functions
SysTick
Interrupt-driven serial IO drivers
A simple GPIO abstraction layer that is maximally uniform across supported platforms
GPIO and, where applicable, EXTI drivers
Preemptive multitasking
Action scheduling including synchronous messaging between actions on single tasks
A disassembler
Moving the exception vector table into RAM so it can be arbitrarily set
Task notifications
Semaphores
Locks
Message-oriented channels
Message-oriented rendezvous channels (aka “fchannels”)
Message-oriented synchronous bidirectional reply channels (aka “rchannels”)
Message-oriented ISR-friendly channels (aka “schannels”)
Byte-oriented streams
Maps, including counted string and integer-keyed maps
Temporary buffers
An allocator
Memory pools
Task pools
Action pools (for the single-task event scheduler)
A line editor
LED drivers
Random number generator drivers
Pseudorandom number generation support (using the TinyMT32 PRNG)
swdcom support for non-UART-based terminal support
On the Raspberry Pi Pico (and other compatible RP2040 boards) it also supports the following:
Programmable input/output (PIO)
Multicore execution; note that this can be combined with multitasking on each core and multitasking constructs can be shared by both cores
On the STM32F746 DISCOVERY board and the Raspberry Pi Pico (and other compatible RP2040 boards) it also supports the following:
Quad SPI Flash memory
A block interface
A block editor
Components
1 × A zeptoforth binary, whether just a kernel or one containing compiled Forth code (the latter is highly recommended)
1 × A compatible board, such as the STM32L476 DISCOVERY, STM32F407 DISCOVERY, STM32F746 DISCOVERY, or Raspberry Pi Pico boards
1 × A means to flash said board (e.g. ST-Link, or in the case of the DISCOVERY boards, a USB to USB Mini cable); in the case of the
1 × A means to communicate with said board over serial or ST-Link (to enable the use of swdcom)
Tomi Engdahl says:
STMicro Teams with AWS, Microsoft on IoT Development
May 12, 2022
STMicroelectronics joins forces with AWS for secure IoT links to its cloud and with Microsoft on quicker development of highly secure IoT devices.
https://www.electronicdesign.com/technologies/embedded-revolution/article/21241681/microwaves-rf-stmicro-teams-with-aws-microsoft-on-iot-development?utm_source=EG+ED+Connected+Solutions&utm_medium=email&utm_campaign=CPS220510036&o_eid=7211D2691390C9R&rdx.ident%5Bpull%5D=omeda%7C7211D2691390C9R&oly_enc_id=7211D2691390C9R
In separate collaborative efforts with Amazon Web Services (AWS) and Microsoft, STMicroelectronics is extending its reach into the IoT realm. On the AWS front, STMicro now offers a reference implementation that makes for easier and secure connection of IoT devices to the AWS cloud. Meanwhile, in a joint effort with Microsoft, STMicro has endeavored to strengthen the security of emerging IoT applications.
Tomi Engdahl says:
PikaScript Crams Python Onto Microcontrollers with Just 4kB of RAM and 32kB of Storage
Designed for devices too compact to accept MicroPython or CircuitPython, PikaScript is an extremely compact Python environment.
https://www.hackster.io/news/pikascript-crams-python-onto-microcontrollers-with-just-4kb-of-ram-and-32kb-of-storage-f23957b215c7
Tomi Engdahl says:
https://hackaday.com/2022/05/17/things-are-getting-rusty-in-kernel-land/
Tomi Engdahl says:
Nordic Semi Launches nRF5340 Audio Development Kit for Bluetooth LE Audio Projects
New dev board is built for Bluetooth LE Audio, but compatible with a range of other 2.4GHz radio protocols including Thread and Zigbee too.
https://www.hackster.io/news/nordic-semi-launches-nrf5340-audio-development-kit-for-bluetooth-le-audio-projects-3cc148e92dad
Tomi Engdahl says:
Linux haluaa eroon C-kielestä
https://etn.fi/index.php/13-news/13612-linux-haluaa-eroon-c-kielestae
Linux-ydin koodataan lähestulkoon kokonaan C-kielellä. C ja C++ tuovat mukanaan haavoittuvuuksia useille saiteille ja verkkosovelluksiin, koska niiden muistinhallinta on puutteellinen. Nyt käynnissä on hanke, jossa halutaan siirtyä avoimen koodin hankkeissa modernimpiin, turvallisempiin kieliin kuten Rust ja Go.
Suuri osa nykyaikaisista Internet-ohjelmistoista on koodattu C:llä, mikä johtaa suureen määrään haavoittuvuuksia vuosittain. Noin 70 prosenttia Microsoftin alustoilla olevista haavoittuvuuksista vuosina 2006–2018 johtui muistin turvallisuusongelmista. Vuonna 2020 Google raportoi, että 70 prosenttia Chromen haavoittuvuuksista johtui muistinhallinnasta.
Rust-koodia on sisällytetty Linux-ytimeen jo pitkään ja viime syksynä tilanne parani entisestään, kun kehittäjille saatiin vakaa Rust-käännin.
Asialla ovat avoimen lähdekoodin tärkeimmät säätiöt, OpenSSF eli Open Source Security Foundation ja Linux Foundation. Ne ovat esittäneet Jos Bidenin hallinnolle ohjelmaa, jossa näistä kyberturvattomista kielistä päästäisiin eroon. Hankkeeseen voi tutustua täällä.
THE OPEN SOURCE SOFTWARE SECURITY MOBILIZATION PLAN1
W H I T E PA P E R
The Open Source
Software Security
Mobilization Plan
https://8112310.fs1.hubspotusercontent-na1.net/hubfs/8112310/OpenSSF/White%20House%20OSS%20Mobilization%20Plan.pdf?hsCtaTracking=3b79d59d-e8d3-4c69-a67b-6b87b325313c%7C7a1a8b01-65ae-4bac-b97c-071dac09a2d8
Tomi Engdahl says:
8-bittinen löytää paikan oheisprosessorina
https://etn.fi/index.php/13-news/13620-8-bittinen-loeytaeae-paikan-oheisprosessorina
Mikro-ohjaimien myynti kasvaa tasaisesti, mutta kasvu painottuu 32-bittisiin. Viime vuonna ohjanpiirejä myytiin 19,6 miljardilla dollarilla. Siitä 8-bittisten osuus oli 2,6 miljardia. Kaikkiaan MCU-piirejä myydään vuonna 2026 noin 27,2 miljardilla dollarilla.
Vaikka 8-bittisten myynti ei seuraavan viiden vuoden aikana kasva, niiden rooli on muuttumassa. Yhä useammin niitä käytetään piirikortilla erilaisten oheistoimintojen ohjaamiseen. Tällaisia ovat esimerkiksi käyttöliittymän ohjaus tai järjestelmän yleistason kunnossapito.
Uusiakin 8-bittisiä markkinoille tuodaan. Microchip esitteli viime kuussa peräti 65 uutta 8-bittist ohjainperhettä suosittuihin PIC- ja AVR-sarjoihinsa. Kannattaa muistaa, että ensimmäisen PIC-ohjaimen kehitti General Instruments jo vuonna 1975. AVR sai alkunsa Trondheimissa Norjan teknillisessä korkeakoulussa vuonna 1990-luvulla.
Microchipin uusia siruja esitellyt tuotemarkkinoinnin päällikkö Öyvind Ström muistutti, että kaikki muut valmistajat ovat luopuneet 8-bittisten kehittämisestä. Microchipillä on hallussaan kolmannes 8-bittisten noin viiden miljardin dollarin markkinoista ja ohjaimien tuotantoon kolmessa tehtaassaan yhtiö panostaa miljardi dollaria seuraavan vuoden aikana.
- Itse asiassa 8-bittisten markkina kasvaa tasaisesti. Siruja valmistetaan 130 nanometrin prosessissa, joka on osoittautunut ihanteelliseksi suorituskyvyn ja kustannusten yhdistelmäksi, Ström kehuu.
Microchipin valikoimassa on 8-bittisissä yli 1500 tuotenumeroa ja osaa siruista on valmistettu yli 20 vuoden ajan. Nyt valikoimaan lisätään neljä uutta PIC-perhettä ja yksi AVR-perhe. – 8-bittisten kysyntä kasvattaa älykkyyden jakaminen. Ohjaimille tulee lisää analogiatoimintoja ja CIP-lohkojen eli ytimestä riippumattomien oheislaitteiden käyttökelpoisuus kasvattaa suosiota, Ström sanoo.
Tomi Engdahl says:
https://www.digikey.com/en/articles/the-role-of-plcs-in-industrial-control-and-test-and-measurement?dclid=CKD4kd33_vcCFYNGHgIdIg4EeQ
Tomi Engdahl says:
How to Select the Right RTOS and Microcontroller Platform for the IoT
https://www.digikey.com/en/articles/how-to-select-the-right-rtos-and-microcontroller-platform-for-the-iot?dclid=CMya3dT3_vcCFQNOGQod9AcD8A
Developing an Internet of Things (IoT) device can be more challenging than many developers or companies realize. The very act of connecting an embedded system to the cloud dramatically increases the timing complexity for the system. An increase in timing complexity means that developers need a better way to manage how their software will decide what code should be running when. The best way to avoid writing custom schedulers or dealing with the timing at the bare metal level is to instead use a real-time operating system (RTOS) to help us manage the timing complexities.
One challenge with using an RTOS today is that many developers are coming from a bare metal environment without an operating system (OS), and selecting the right RTOS for a given application can be challenging. A quick survey of the RTOS market online would find that there are over 100 RTOSs available that developers can use that vary from open source to certified commercial RTOSs. So how does one go about selecting an RTOS and get started?
In this article, we are going to walk through how to evaluate which RTOS is best for your application and then examine development platforms from STMicroelectronics and Renesas that can be used to get started.
Factors to consider when selecting an RTOS
Real-time operating systems form the foundation on which developers build their application code. Selecting the right RTOS is critical to ensuring that the application is being built upon a sturdy and proven foundation. However, it’s often the case that RTOS selection is based on just a single parameter: cost.
While cost is an important factor to consider, it should not be the only one. A development team could easily spend ten times the cost of a commercial RTOS if they struggle to port, implement, or lack support for the RTOS that they select, not to mention the time that could be lost on a project. In general, there are eight different categories that a development team should consider when selecting an RTOS for their application. These include:
Legal liability and exposure
Performance
Features
Cost
Ecosystem
Middleware
RTOS vendor
Engineering preference
Within each category there may be several criteria that should be evaluated for each RTOS. For example, in the legal liability category, teams may want to consider the following:
RTOS infringement liability
Indemnification
Warranty
The need to have the RTOS reviewed from a legal standpoint
In the performance category, developers might consider the following:
Executable memory footprint
RAM footprint
Highest degree of determinism
Run-time efficiency
Platforms upon which to launch RTOS development
One area in which developers might struggle to evaluate an RTOS is determining whether it meets their performance and capabilities needs. In many cases a developer won’t know unless they dig deep in their evaluation and get their hands dirty by using the RTOS. It turns out that an extremely easy and inexpensive way to evaluate and test an RTOS is to leverage an existing development platform that uses it. Let’s look at a few platforms that support the popular open source FreeRTOS and Express Logic’s ThreadX operating systems.
Tips and tricks for using an RTOS
Every RTOS has its own “tips and tricks”, but there are several rules of thumb that can be applied to RTOSs generically:
Statically allocate tasks and RTOS objects. Dynamically allocating tasks and objects requires the use of memory allocation (malloc()) which is non-deterministic and can cause heap fragmentation issues leading to poor performance or even system crashes in the worst case.
Change the default stack size based on your application needs. Many RTOSs provide a default stack value that is oversized for most tasks, which results in wasted RAM. Manually configure the default stack size but also make sure that you tune the stack size for each task based on its function and needs.
Functions that are called from a task should be reentrant. This ensures that if the function is called from multiple tasks there won’t be a risk for corrupting the other task’s data if it was interrupted by a higher priority task.
Use memory block pools if they are available. A memory block pool is a memory pool that has deterministic behavior and can be used during run-time to dynamically allocate memory. This is a better option than using malloc(), but most open source operating systems do not include this memory management capability.
Minimize the number of tasks used in the application. There is a temptation with an RTOS to create lots of tasks, but creating tasks that are not needed can dramatically reduce available memory due to the need for the task control block and the separate stack space associated with it.
Conclusion
As the IoT drives the need for increasing software complexity in embedded systems, the use of an RTOS has become a requirement in order to help developers grapple with this complexity and abstract it out. The trick however is not to select just any RTOS. Since not all RTOSs are created equal, considerable time and effort can be wasted if the RTOS is fighting the developers’ purposes.
Instead, developers need to take a proactive approach to their RTOS selection and carefully evaluate all the different aspects of not just the RTOS, but also peripheral considerations such as the RTOS vendor and the support that is available when issues are encountered. An effective approach is to start with a KT matrix to carefully evaluate RTOSs under consideration, and then run the RTOS of choice on microcontroller platforms that can fully support it to make sure it’s the right one for the application.
Tomi Engdahl says:
SWO: An ARM Printf By Any Other Name
https://hackaday.com/2022/05/25/swo-an-arm-printf-by-any-other-name/
I’ll confess. Although printf-style debugging has a bad rep, I find myself turning to it on occasion. Sure, printf is expensive and brings in a lot of code, but if you have the space and time to use it while debugging you can always remove it before you are finished. However, what if you don’t have an output device or you are using it for something else? If you are using most modern ARM chips, you have another option — a dedicated output channel that is used for several things, including debugging output. I decided I wanted to try that on the Blackpill running mbed, and found out it isn’t as easy as you might think. But it is possible, and when you are done reading, you’ll be able to do it, too.
I’m writing this using the STM32-specific ST-LINK hardware. If you use other JTAG devices like the BlackMagic probe, you probably already have this set up for you.
You can use putc or printf to write to the debugging output. As you can see in the figure, you get a nice window that shows all the output. There are actually 32 channels of output, but channel 0 is reserved for the debugging output. In this case, I picked All because its the only thing coming out of the device, anyway.
What You Need
ST’s STM32CubeProgrammer can display SWO data.
First, you need a compatible ARM chip. Not all ARM chips support ITM — the Integrated Trace Macrocell — but that’s what you need. There will be one pin on the device marked SWO (and probably other things, too). Since I’m using the Blackpill with an STM32F411CE, we know it should work and the output pin will be PB3.
You also need an ST-Link dongle that has an SWO pin. Unfortunately, the cheap ones that look like a USB memory device you typically get don’t have the SWO pin. You can, however, easily hack them. The “full” ST-Link V2 has the pin brought out, but is usually a lot more expensive. However, if you shop the usual Chinese shops, you can usually find one for a reasonable price. I paid less than $10.
Going Further
You can go further, though. First, there’s colorful output. If your debug string contains #RED#, #GRN#, or #ORG# the remaining characters will be in that color (red, green, or orange) for the rest of the line. Assuming, of course, the viewer understands that and you have it turned on. It is handy to be able to show important messages in red, for example.
However, it is a waste that there are so many extra channels we aren’t using. For example, why not have progress messages on channel 0 and detailed debugging info on channel 1? You could have a dump of what’s coming in from an external device on channel 5. Sure, you could write a prefix on the line and pull the data out that way, but this is more fun.
There are very few changes to the code, but I’ll leave the whole project up on GitHub.
https://github.com/wd5gnr/mbed-swo
Tomi Engdahl says:
The Co-Processor Architecture: An Embedded System Architecture for Rapid Prototyping
https://www.digikey.com/en/articles/the-co-processor-architecture-an-embedded-system-architecture-for-rapid-prototyping?dclid=CJTXr4vUhvgCFR5eGQoda1IG1A
Tomi Engdahl says:
Run Machine Learning Code in an Embedded IoT Node to Easily Identify Objects
https://www.digikey.com/en/articles/run-machine-learning-code-in-an-embedded-iot-node?dclid=CLy-84zUhvgCFZdNwgodJbAMmw
Internet of Things (IoT) networks operating in dynamic environments are being expanded beyond object detection to include visual object identification in applications such as security, environmental monitoring, safety, and Industrial IoT (IIoT). As object identification is adaptive and involves using machine learning (ML) models, it is a complex field that can be difficult to learn from scratch and implement efficiently.
The difficulty stems from the fact that an ML model is only as good as its data set, and once the correct data is acquired, the system must be properly trained to act upon it in order to be practical.
This article will show developers how to implement Google’s TensorFlow Lite for Microcontrollers ML model into a Microchip Technology microcontroller. It will then explain how to use the image classification and object detection learning data sets with TensorFlow Lite to easily identify objects with a minimum of custom coding.
It will then introduce a TensorFlow Lite ML starter kit from Adafruit Industries that can familiarize developers with the basics of ML.
Tomi Engdahl says:
Why Won’t the 8-bit Microcontroller Die?
https://www.embedded.com/why-wont-the-8-bit-microcontroller-die/
The microcontroller industry is an interesting beast. Last year, in 2021, over 29 billion microcontrollers were sold with revenues of 18.5 billion USD. Quick math tells you that the average microcontroller sale price was ~$0.64. That seems inexpensive given that nearly every webinar, article, and company is touting the latest 32-bit microcontroller with multiple cores, security, and the ability to run machine learning inferences. So what exactly is going on here?
Notice that while the industry is growing at ~10% CAGR, the industry is not necessarily dominated by the latest and greatest 32-bit microcontrollers! In addition, growth in the sector appears to be dominated by the 8-bit and 16-bit space as well!
One would think that there couldn’t possibly be that many 8-bit microcontrollers still on the market; however, a quick look on Mouser’s website for microcontrollers reveals something exciting. First, there are currently around 50,000 different microcontrollers available worldwide.
There are more 8-bit microcontrollers (13,928) available than Arm 32-bit microcontrollers (12,335)!
Why won’t 8-bit microcontrollers die? More than a decade ago, Jack Ganssle published a rant, 8-bits is dead, where he concluded, “as high-end processors drop in price, those at the bottom get cheaper too, which opens up new markets that could never have afforded semiconductor intelligence.” While many teams focus on the cutting edge of the industry, there are just as many, if not more, opportunities where simple and cheap microcontrollers fit the need!
While many of us who work at the cutting-edge wonder why the 8-bit microcontroller won’t die, the truth is that 8-bit microcontrollers probably dominate our industry. We’re just too busy chasing the latest and greatest flashy, shiny microcontroller or buying into the marketing hype to recognize the capabilities of these industry workhorses.
Tomi Engdahl says:
The Virtual Breadboard EDGEY Solves Components Shortages by Creating “Mixed Reality Circuits”
https://www.hackster.io/news/the-virtual-breadboard-edgey-solves-components-shortages-by-creating-mixed-reality-circuits-b58ca26a9248
Supporting physical and virtual hardware in any combination, the EDGEY connects Virtual Breadboard to real-world microcontrollers.
Tomi Engdahl says:
LEIPÄLAUTA, HYPPYLANKOJA JA MIKRO-OHJAIN – KÄDET SAVESSA ESINEIDEN INTERNETISSÄ
https://blog.netprofile.fi/leipalauta-hyppylankoja-ja-mikro-ohjain-kadet-savessa-esineiden-internetissa
Tomi Engdahl says:
Linux Fu: Easy Widgets
https://hackaday.com/2022/06/02/linux-fu-easy-widgets/
Here’s a scenario. You have a microcontroller that reads a number of items — temperatures, pressures, whatever — and you want to have a display for your Linux desktop that sits on the panel and shows you the status. If you click on it, you get expanded status and can even issue some commands. Most desktops support the notion of widgets, but developing them is a real pain, right? And even if you develop one for KDE, what about the people using Gnome?
Turns out there is an easy answer and it was apparently inspired by, of all things, a tool from the Mac world. That tool was called BitBar (now XBar). That program places a widget on your menu bar that can display anything you want. You can write any kind of program you like — shell script, C, whatever. The output printed from the program controls what appears on the widget using a simple markup-like language.
That’s fine for the Mac, but what about Linux? If you use Gnome, there is a very similar project called Argos. It is largely compatible with XBar, although there are a few things that it adds that are specific to it. If you use KDE (like I do) then you’ll want Kargos, which is more or less a port of Argos and adds a few things of its own.
Good News, Bad News
The good news is that, in theory, you could write a script that would run under all three systems. The bad news is that each has its own differences and quirks. Obviously, too, if you use a complied program that could pose a problem on the Mac unless you recompile.
Tomi Engdahl says:
8-bittisillä edelleen tärkeä rooli
https://etn.fi/index.php/tekniset-artikkelit/13708-8-bittisillae-edelleen-taerkeae-rooli
Tomi Engdahl says:
The Top 11 IDEs for Embedded Applications
June 10, 2022
These integrated development environments, from NetBeans to Visual Studio to jGRASP, offer a wide-ranging array of tools for coding programming languages and software development.
https://www.electronicdesign.com/technologies/embedded-revolution/media-gallery/21243757/electronic-design-the-top-11-ides-for-embedded-applications
What you’ll learn:
What are the top IDEs for embedded development?
Why each one is unique in its own right.
An integrated development environment (IDE) is a software application that provides a set of tools for software development and coding programming languages, all in a single graphical user interface (GUI). IDEs typically pack a source-code editor that assists in programming with features such as syntax highlighting (complete with visual cues), language-specific auto-completion (automate simple, repeatable tasks), and a debugger for testing code and routing-out bugs.
In essence, IDEs enable programmers to maximize productivity without the need for multiple utilities that have to be configured and implemented for each application. Because utilities are housed under a single GUI, developers can execute actions without switching between applications. This is especially helpful for embedded development applications within IoT ecosystems that don’t require reconfiguration to suit multiple devices or projects.
Other standard IDE features are designed to help developers manage workflows and efficient problem-solving. IDEs parse code as it’s written so that bugs can be identified in real-time. Some IDEs may even include class and object browsers and hierarchy diagrams for specific languages.
This gallery highlights some of the widely used IDEs that provide a basic set of tools and additional features for streamlining the coding process. Many of these IDEs are open source and freely available; others have paid versions or paid enhancements.
https://www.electronicdesign.com/technologies/embedded-revolution/media-gallery/21243757/electronic-design-the-top-11-ides-for-embedded-applications?id=21243757&slide=1
Tomi Engdahl says:
https://etn.fi/index.php/13-news/13739-sulautettuihin-pian-ultranopeaa-mram-muistia
Magneettinen RAM eli MRAM on tehnyt tuloaan moniin sulautettuihin sovelluksiin jo vuosia, mutta hyvistä ominaisuuksistaan huolimatta tässä on ollut haasteita. Renesas on nyt esitellyt Havaijilla järjestetyssä piiritekniikan VLSI Symposiumissa uusia piiritekniikoita, jotka lupaavat ratkaista monia ongelmia.
Yhtiön mukaan sen uusi 22 nanometrin prosessissa valmistettu STT-MRAM-piiri (spin-transfer torque) lukee 32 megabitin MRAM-soluissa dataa 5,9 nanosekunnin pääsyajalla (access time). Siru toimii jopa 150 asteen lämpötilassa ja pystyy kirjoittamaan dataa 5,8 megatavun sekuntinopeudella.
Tomi Engdahl says:
Acceleration Robotics Promises Big Performance Gains for ROS 2 Robots via Its ROBOTCORE Framework
Compatible with 12 devices at launch, ROBOTCORE aims to offer a hardware-agnostic framework to accelerate robotic workloads.
https://www.hackster.io/news/acceleration-robotics-promises-big-performance-gains-for-ros-2-robots-via-its-robotcore-framework-cfd634856a2e
Tomi Engdahl says:
Animate Arcane Protocols With Interrupt-Backed Bitbanging
https://hackaday.com/2022/06/19/animate-arcane-protocols-with-interrupt-backed-bitbanging/
We often take our “SoftwareSerial” libraries for granted, and don’t investigate what goes on under the hood — until they fail us, at least. Would you like to learn how to harness the power of interrupt-driven bitbanging? [Jim Mack] teaches us how to make our protocol implementations fly using the LTC protocol as a springboard.
LTC (Linear/[Longitudinal] TimeCode) is a widely-used and beautifully-crafted protocol that tends to fly under our radar, and is one that hackers could learn plenty from. It’s used for synchronization of audio/video devices during media production and playback. LTC’s signal is almost digital but not quite: it doesn’t need a clock, and it has no polarity. Additionally, it mimics an audio signal really well, you can decode it at any playback speed, and many other benefits and quirks that [Jim] outlines. You do need to maintain the timings, though, and [Jim]’s article shows us how to keep them right while not inconveniencing your primary tasks.
Longitudinal Bit-banging
https://escmdxi.wordpress.com/2022/06/02/longitudinal-bit-banging/
Tomi Engdahl says:
https://hackaday.com/2022/06/18/build-your-own-two-factor-authenticator-with-good-usb/
Tomi Engdahl says:
Blinking An Arduino LED, In Julia
https://hackaday.com/2022/06/20/blinking-an-arduino-led-in-julia/
The Julia programming language is a horrible fit for a no-frills microcontroller like the ATMega328p that lies within the classic Arduino, but that didn’t stop [Sukera] from trying, and succeeding.
All of the features that make Julia a cool programming language for your big computer make it an awful choice for the Arduino. It’s designed for interactivity, is dynamically typed, and leans heavily on its garbage collection; each of these features alone would tax the Mega to the breaking point. But in its favor, it is a compiled language that is based on LLVM, and LLVM has an AVR backend for C. Should just be a simple matter of stubbing out some of the overhead, recompiling LLVM to add an AVR target for Julia, and then fixing up all the other loose ends, right?
Well, it turns out it almost was. Leaning heavily on the flexibility of LLVM, [Sukera] manages to turn off all the language features that aren’t needed, and after some small hurdles like the usual problems with volatile and atomic variables, manages to blink an LED slowly. Huzzah.
Running Julia baremetal on an Arduino
https://seelengrab.github.io/articles/Running%20Julia%20baremetal%20on%20an%20Arduino/#running_julia_baremetal_on_an_arduino
Tomi Engdahl says:
https://etn.fi/index.php/13-news/13739-sulautettuihin-pian-ultranopeaa-mram-muistia
Tomi Engdahl says:
Laiteohjelmisto ja data samalle EEPROMille ensimmäistä kertaa
https://etn.fi/index.php/13-news/13743-laiteohjelmisto-ja-data-samalle-eepromille-ensimmaeistae-kertaa
STMicroelectronics on esitellyt markkinoiden ensimmäisen EEPROM-muistin, jolla voidaan yhdistää laiteohjelmiston hallintaan ja joustavaan tiedontallennustilaan samalla sirulla. Tämä ei ole aiemmin ollut mahdollista.
Kyse on M95P32-sirusta, jolle voidaan kirjoittaa sivu kerrallaan SPI-väylän yli. Ensin sirusta tuodaan 32 megabitin versio, mutta ST lupaa laajentaa valikoimaa lähitulevaisuudessa 16 ja 8 megabitin versioilla.
Piirin arkkitehtuuri antaa suunnittelijoille mahdollisuuden yhdistää laiteohjelmiston hallintaan ja joustavaan tiedontallennustilaan samassa laitteessa, mikä yhdistelmä ei ole aiemmin ollut saatavilla. Tämä korkeampi muistin integrointi vähentää materiaalikuluja (BoM) ja lyhentää suunnittelujen markkinoilletuloaikaa. Piiri sopii esimerkiksi teollisiin IoT-moduuleihin, puettaviin laitteisiin, lääketieteen laitteisiin, älymittareihin ja 5G-moduuleihin.
Tomi Engdahl says:
https://www.uusiteknologia.fi/2022/06/21/embedded-world-2022-aukesi-bosch-tuo-qtn-hmi-kayttoliittyman-autosariin/
Tomi Engdahl says:
Uusi irrotettava muistikortti esillä Nürnbergissä
https://etn.fi/index.php/13-news/13744-uusi-irrotettava-muistikortti-esillae-nuernbergissae
Uusia sulautettuja muistikortteja tulee markkinoille varsin harvoin, mutta nyt Nürnbergin Embedded World -näyttelyssä nähdään sellainen. Kioxia esittelee messuilla ensimmäistä PCIe-väyläistä XFMEXPRESS-korttia. XMF tuo laitteisiin erittäin pienikokoisen irrotettavan muistin, jolla on kova suorituskyky.
XFMEXPRESS on yhdistelmä pientä kokoa, nopeutta ja huollettavuutta, ja tarkoitettu erityisesti seuraavan sukupolven mobiili- ja sulautettuja sovelluksia.
Kioxian XT2 on ensimmäinen tuote, joka täyttää JEDEC-standardin vaatimukset. Kortin fyysiset mitat ovat vain 14 x 18 x 1,4 millimetriä
NVMe-ohjain juoksuttaa dataa kahden PCIe 4.0 -linjan läpi. Sulautetuissa XFEXPRESS nousseekin heti SSD:n korvaajaksi useissa sovelluksissa.
Tomi Engdahl says:
Microsoft, KittenBot Launch the First Jacdac-Standard Microcontroller Kits and Software APIs
https://www.hackster.io/news/microsoft-kittenbot-launch-the-first-jacdac-standard-microcontroller-kits-and-software-apis-9faec87abe70
Available for the BBC micro:bit V2 now with RP2040, ESP32, and more in-progress, Jacdac is an interesting twist on solder-free connectivity.
The first commercial devices to adhere to Microsoft’s Jacdac standard, an open source bus-based plug-and-play specification for solderless connectivity between microcontrollers and peripheral devices, have hit the market — including a Jacdac add-on for the BBC micro:bit V2.
“Jacdac is a hardware+software platform for the plug-and-play creation and programming of physical computing systems,” the Jacdac team at Microsoft explains of its creation. “A ‘brain,’ in this case a micro:bit V2, executes the user’s program, while a set of modular accessories — or modules — provide additional capabilities.”
On the hardware side, Microsoft has partnered with educational electronics specialist KittenBot to produce a “Jacdaptor” break-out board. A micro:bit V2 microcontroller development board is inserted into the top using its edge connector, then six three-pin Jacdac connects are provided at the bottom of the board — along with four crocodile-clip and conductive-thread friendly pin loops, mimicking those of the micro:bit itself.
To this, KittenBot has added a range of accessory boards including a switch, a rotary encoder, a potentiometer, light and magnetic field sensors, and an RGB LED ring — along with a “Hub” board, which has four Jacdac connectors on each side plus three ring-pins.
Jacdac isn’t just positioned as an alternative to existing solderless interconnection approaches like Grove, STEMMA QT, and Qwiic — but its use of PCB edge connectors does make it cheaper to add to a board. Rather, Microsoft has developed a full software stack to go along with the hardware — with “services” describing how hardware, both Jacdac-specific and devices designed for the micro:bit alone, allowing easy access to connected hardware through unified code blocks in the MakeCode visual coding environment.
The system isn’t exclusive to MakeCode, however — though that is Microsoft’s focus for the initial launch. The company has released Jacdac application programming interface (APIs) for JavaScript/TypeScript, .NET, and Python
Microsoft has also teased a selection of Jacdac “brains” of its own design, none of which were commercially available at the time of writing
More details on Jacdac itself are available on the project website; the Jacdac specification is available on GitHub under the permissive Creative Commons Attribution license for the hardware and MIT license for the software.
https://microsoft.github.io/jacdac-docs/
Jacdac Specification, Device and Service Catalogs
https://github.com/microsoft/jacdac
Jacdac is a bus-based plug-and-play hardware/software stack for microcontrollers and their peripherals (sensors/actuators), with applications to rapid prototyping, making, and physical computing.
https://microsoft.github.io/jacdac-docs/ddk/
Tomi Engdahl says:
The Top 11 IDEs for Embedded Applications
June 10, 2022
These integrated development environments, from NetBeans to Visual Studio to jGRASP, offer a wide-ranging array of tools for coding programming languages and software development.
https://www.electronicdesign.com/technologies/embedded-revolution/media-gallery/21243757/electronic-design-the-top-11-ides-for-embedded-applications?utm_source=EG+ED+Connected+Solutions&utm_medium=email&utm_campaign=CPS220617018&o_eid=7211D2691390C9R&rdx.ident%5Bpull%5D=omeda%7C7211D2691390C9R&oly_enc_id=7211D2691390C9R
Tomi Engdahl says:
Shape the future of hardware, together.
Join the Beta to help create a better way to build hardware.
https://www.flux.ai/p
Tomi Engdahl says:
Shiny New CircuitPython 8.0.0 Alpha Brings New Board Support, Bug Fixes, and More
Offering support for new boards, including Adafruit’s latest ESP32-S2 Feathers, CircuitPython 8.0.0 is ready for testing.
https://www.hackster.io/news/shiny-new-circuitpython-8-0-0-alpha-brings-new-board-support-bug-fixes-and-more-ce24b2367814
Tomi Engdahl says:
CherryUSB – A lightweight USB device/host stack for embedded systems
https://www.cnx-software.com/2022/05/23/cherryusb-lightweight-usb-device-host-stack-for-embedded-systems/
CherryUSB is a lightweight open-source USB device/host stack for embedded systems with one or more USB interfaces. The stack implements various class drivers such as CDC, HID, MSC, audio, video, and so on.
Tomi Engdahl says:
LinuxBoot Joins The Open-Source Firmware Foundation
https://www.phoronix.com/scan.php?page=news_item&px=Linux-Boot-Joins-OSFF
Tomi Engdahl says:
tio is a serial device I/O tool for Linux targeted at embedded developers
https://www.cnx-software.com/2022/06/30/tio-is-a-serial-device-i-o-tool-for-linux-targeted-at-embedded-developers/
There are already several serial terminal programs such as Putty and minicom, and in recent times, I’ve been using Bootterm myself. But that does not mean there isn’t room for more and Martin Lund has developed tio serial device I/O tool for Linux.
Martin found out many of the existing tools are very modem focused or a bit cumbersome to use, so he developed tio as the simpler alternative which puts less focus on classic terminal/modem features and more focus on the needs of embedded developers and hackers.
Tomi Engdahl says:
Always Know What Your Board Is Doing with This Handheld Serial Monitor
Katie Dumont’s Handheld Serial Monitor allows you to more easily view what’s going on in their code without the need for a PC or debugger.
https://www.hackster.io/news/always-know-what-your-board-is-doing-with-this-handheld-serial-monitor-e61054273477
Tomi Engdahl says:
DevOps käyttöön – turvallisempaa koodia sulautettuihin
https://etn.fi/index.php?option=com_content&view=article&id=13534&via=n&datum=2022-05-06_15:35:22&mottagare=31202
Tomi Engdahl says:
Qt tuo näyttävää grafiikkaa mikro-ohjaimille
https://etn.fi/index.php/13-news/13763-qt-tuo-naeyttaevaeae-grafiikkaa-mikro-ohjaimille
Suomalainen Qt tunnetaan esimerkiksi autojen kojelautojen näyttävistä käyttöliittymistä, mutta sen työkaluilla saadaan myös pienemmillä mikro-ohjaimilla toteutettua grafiikkaa. Nyt Qt for MCU:sta on esitelty ensimmäinen pitkän teknisen tuen LTS-versio.
2.2 LTS -versio tarkoittaa, että esimerkiksi bugikorjauksia luvataan 18 kuukauden ajan. Uusin versio tuo myös joukon parannuksia, joihin kuuluvat esimerkiksi parempi tekstin renderöinti ja uusia rajapintoja GUI-koodin virheiden käsittelyyn
Tomi Engdahl says:
Rust language in embedded systems
https://www.youtube.com/watch?v=Vk0Lw_ZU9C4&t=1s
A webinar about Rust, a modern language that has become increasingly competitive alternative to the C/C++ traditionally used for developing embedded system. We will have a brief overview on its salient language features.
https://nohau.fi/tapahtumat-koulutus/recorded-webinars/
Tomi Engdahl says:
This tutorial shows you how to use the @Lauterbach TRACE32 GDB front-end debugger to debug your Nano 33 BLE application via GDB on a serial interface: https://docs.arduino.cc/tutorials/nano-33-ble/trace-32
Tomi Engdahl says:
https://www.uusiteknologia.fi/2022/05/09/korttipakasta-apua-ohjelmistokehitykseen/
Tomi Engdahl says:
Insightly helps engineering teams increase productivity and reduce burnout
https://techcrunch.com/2022/07/25/insightly-helps-engineering-teams-increase-productivity-and-reduce-burnout/
Insightly Analytics helps engineering teams stop problems before they happen, like slow release cycles, bottlenecks and uneven workload distribution that can lead to employee burnout. The San Francisco and Hyderabad-based startup announced today it has raised $1 million led by Together Fund, which it will use to expand its product, engineering and marketing teams.
Founded in 2022, Insightly’s target users are chief technology officers and engineering vice presidents who want to analyze their DevOps research and assessment to help make decisions and identify the causes of issues that can potentially lead to less revenue, less productivity or employee attrition.
Tomi Engdahl says:
https://www.bytecraft.fi/pohdinnat/kaytannon-tilakoneita?utm_campaign=content&utm_source=facebook&utm_medium=lp-view&fbclid=IwAR03rPA5s7Z6n22BSyyustym7_fF8615qEng5gAHT7MKQ7li_ZpI8vl2rtw
Tomi Engdahl says:
Balancing act: Creating Harmony Between People and Technology
Striking a balance between a human-led, but tech-powered approach, is increasingly the key to business success.
https://www.wired.co.uk/bc/article/balancing-act-creating-harmony-between-people-and-technology
Tomi Engdahl says:
SparkFun’s New Qwiic Micro Family Offers Popular Breakouts in a Significantly Reduced Footprint
Measuring in at less than a quarter the footprint of standard Qwiic breakouts, Qwiic Micro launches with four sensor boards.
https://www.hackster.io/news/sparkfun-s-new-qwiic-micro-family-offers-popular-breakouts-in-a-significantly-reduced-footprint-38efebe12f4c
Tomi Engdahl says:
https://blog.adafruit.com/2022/07/23/8-useful-op-amp-circuits/
Tomi Engdahl says:
https://wearemovement.se/video-2/2022/how_tesla_does_agile_hardware_development/
Tomi Engdahl says:
https://www.seeedstudio.com/blog/2020/06/04/resource-roundup-for-wio-terminal/