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,686 Comments
Tomi says:
https://www.arduino.cc/reference/en/libraries/ucos-ii/
Tomi Engdahl says:
https://en.wikipedia.org/wiki/Micro-Controller_Operating_Systems
https://www.arduino.cc/reference/en/libraries/ucos-iii_due/
https://github.com/weston-embedded/uC-OS3
https://www.analog.com/media/en/dsp-documentation/software-manuals/Micrium-uCOS-III-UsersManual.pdf
Tomi Engdahl says:
Microchip Offers a Lower-Cost Entry Point for PolarFire SoC Experimentation with the Discovery Kit
Priced at $132 for general use or $99 under academic discount, the Discovery Kit offers impressive bang for your buck.
https://www.hackster.io/news/microchip-offers-a-lower-cost-entry-point-for-polarfire-soc-experimentation-with-the-discovery-kit-222ea5a5e89e
Tomi Engdahl says:
https://hackaday.com/2024/02/12/hands-on-bus-pirate-5/
Tomi Engdahl says:
https://www.researchgate.net/publication/290920563_Application_of_VxWorks_of_RTOS_in_microprocessor_based_relay_protection
Tomi Engdahl says:
Wi-Fi 6 paristokäyttöiseen laitteeseen? Miksipä ei
https://etn.fi/index.php/13-news/15901-wi-fi-6-paristokaeyttoeiseen-laitteeseen-miksipae-ei
Tomi Engdahl says:
https://www.uusiteknologia.fi/2024/02/28/64-bitin-risc-v-ohjaimella-varustettu-fpga-kehityskortti/
Microchipin uusi PolarFire SoC Discovery -kehityssarja lupaa tehdä RISC-V- ja FPGA-suunnittelusta aiempaa helpompaa. Vastaavia kaupallisia kehityssarjoja ja piirejäkin on vasta varsin rajoitetusti tarjolla.
Discovery Kit rakentuu Microchipin PolarFire MPFS095T SoC FPGA -järjestelmäpiirin ympärille, joka sisältää kaikkiaan neljä 64-bittistä RISC-V Instruction Set Architecture (ISA) -arkkitehtuuriin perustuvaa prosessoriydintä sekä 95 000 ohjelmoitavaa FPGA-logiikkaelementtiä.
Tomi Engdahl says:
https://www.uusiteknologia.fi/2024/03/05/avoimeen-fpga-alustaan-kateva-laajennuskortti/
Tomi Engdahl says:
https://etn.fi/index.php/13-news/15945-uusi-spartan-ratkaisee-liitaentaeongelmat
Tomi Engdahl says:
https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/memory-access-ordering-part-2—barriers-and-the-linux-kernel
Tomi Engdahl says:
https://hackaday.com/2024/03/13/review-the-new-essential-guide-to-electronics-in-shenzhen/
Tomi Engdahl says:
https://www.uusiteknologia.fi/2024/03/15/avoimen-lahdekoodin-iiot-alusta-tuotantoymparistoihin/
Tomi Engdahl says:
https://etn.fi/index.php/new-products/15992-nopeasti-kiinni-tekoaelykehitykseen
Arrow Electronics helpottaa tekoälyn kehitystä ammattilaisille ja rakentelijoille CYC5000 FPGA -kortilla, jonka koko on 25,0 x 70,7 millimetriä. Plug and play -tyyppinen kortti on Arduino-yhteensopiva.
Kortti yksinkertaistaa IoT-reunalaitteiden rakentamista hyödyntäen ohjelmoitavaa logiikkaa, RISC-V:tä Alteran Nios V -softaprosessorin kanssa, DSP-kiihdyttimiä ja kovakoodattuja IP-lohkoja.
Tomi Engdahl says:
DigiKey liittää etänä rautaan ja koodiin
https://etn.fi/index.php/13-news/16007-digikey-liittaeae-etaenae-rautaan-ja-koodiin
LabsLand tunnetaan erityisesti koulumaailmaan kehitetyistä etälaboratorioratkaisuista. Nyt komponenttien jakelija DigiKey on yhdessä yrityksen kanssa kehittänyt ratkaisun laitteisto- ja ohjelmistosuunnittelun etäarviointiin ja -oppimiseen. Ratkaisu on nimeltään Prism4.
Prism4 tulee DigiKeyn valikoimaan yksinoikeudella. Ratkaisun avulla voidaan liittyä kameroita, modulaarisia valoja ja evaluointikortteja käyttäviin laitteistoihin verkon yli. Alusta sisältää myös sarjan Phase Dock -työpenkkejä, joihin laitteita voidaan kiinnittää.
Jokainen Prism4 isännöi toimitusvalmiita Prism4-laitteistojärjestelmiä, jotka ovat saatavilla eri tekniikoille. Valikoima kattaa esimerkiksi FPGA-pohjaisia laitteistoja, mikroprosessoreita ja mikro-ohjaimia. Lisäksi Prism4 tukee etälaboratorioiden luomista muille aloille, mikä mahdollistaa monenlaisia käyttötarkoituksia, kuten etäopetuksen ja -koulutuksen oikeilla laitteilla.
Tomi Engdahl says:
2024 Home Sweet Home Automation: A DIY SCADA Smart Home
https://hackaday.com/2024/03/20/2024-home-sweet-home-automation-a-diy-scada-smart-home/
Tomi Engdahl says:
Extracting Firmware from Embedded Devices (SPI NOR Flash)
https://www.youtube.com/watch?v=nruUuDalNR0
One of the first things you have to do when hacking and breaking embedded device security is to obtain the firmware. If you’re lucky, you can download it from the manufacturer’s website or, if you have a shell, you can just copy it over to your computer.
But what if none of these options are available?
In this video, we will show you how you can connect directly to a NOR flash chip with the SPI protocol to dump the firmware and find your vulns, even if off the shelf tools don’t work!
00:00 Intro
00:40 Technical Introduction
01:55 Flash Memory Types
03:51 NOR Flash
06:25 SPI Protocol
07:55 Our Training
09:27 Logic Analyzer
12:04 How SPI Works
13:53 Firmware Extraction
Tomi Engdahl says:
Hacker’s Guide to UART Root Shells
https://www.youtube.com/watch?v=01mw0oTHwxg
The UART Protocol and Interface is crucial for hacking IoT devices. We explain how to quickly identify a UART interface and connect to it to get a root shell, as well as a trick on how to re-enable a UART connector that has been disabled by the manufacturer.
00:00 Intro
01:00 What is UART?
04:05 Identifying UART
07:56 Connecting to UART
08:52 The UART Protocol
14:42 Re-enabling broken UART
Tomi Engdahl says:
LTE-M vs. NB-IoT: Determine the Differences Between Low Bandwidth Protocols
https://www.youtube.com/watch?v=RlZ9rXbrJqM
Tomi Engdahl says:
DigiKey liittää etänä rautaan ja koodiin
https://etn.fi/index.php/13-news/16007-digikey-liittaeae-etaenae-rautaan-ja-koodiin
LabsLand tunnetaan erityisesti koulumaailmaan kehitetyistä etälaboratorioratkaisuista. Nyt komponenttien jakelija DigiKey on yhdessä yrityksen kanssa kehittänyt ratkaisun laitteisto- ja ohjelmistosuunnittelun etäarviointiin ja -oppimiseen. Ratkaisu on nimeltään Prism4.
Prism4 tulee DigiKeyn valikoimaan yksinoikeudella. Ratkaisun avulla voidaan liittyä kameroita, modulaarisia valoja ja evaluointikortteja käyttäviin laitteistoihin verkon yli. Alusta sisältää myös sarjan Phase Dock -työpenkkejä, joihin laitteita voidaan kiinnittää.
Tomi Engdahl says:
Älymittarin toiminnot uusiksi? Nyt se onnistuu
https://etn.fi/index.php/new-products/16009-aelymittarin-toiminnot-uusiksi-nyt-se-onnistuu
Moni sulautettu laite perustuu mikro-ohjaimeen, jonka ”firmis” eli laiteohjelmistolle tulee joskus tarve päivitykseen. Sen tekeminen radioteitse on kuitenkin usein haaste, jopa mahdotonta. Renesas on esitellyt uuden ohjainpiirin, jossa temppu onnistuu.
Renesas uusi Arm Cortex-M23-prosessoriin perustuvan RA2A2-mikro-ohjain on vähän virtaa kuluttava piiri, jolle on integroitu 24-bittinen Sigma-Delta -AD-muunnin. Lisäksi sirulla on kaksi muistiryhmää koodille ja näiden ryhmien (bank) innovatiivinen vaihto- eli swap-toiminto.
Tämä swappaaminen helpottaa laiteohjelmiston OTA-päivittämistä. Ratkaisua voidaan käyttää monissa sovelluksissa esimerkiksi energiamittareissa, rakennusautomaatiossa, lääketieteellisissä laitteissa, kulutuselektroniikassa ja tietenkin IoT-laitteissa.
Tomi Engdahl says:
https://www.microchip.com/en-us/product/pic10f2001#
Tomi Engdahl says:
M5Stack’s Programmable Power Supply Module 13.2 Offers 100W at Up to 30V for Core Boards and More
Delivering from 0.5V to 30V, this high-accuracy programmable power supply includes full isolation and handy banana sockets.
https://www.hackster.io/news/m5stack-s-programmable-power-supply-module-13-2-offers-100w-at-up-to-30v-for-core-boards-and-more-5745f519b656
Tomi Engdahl says:
Stefan Antoszko’s Pink Noise Generator Packs a TI MSP430 and “a Handful of Resistors and Capacitors”
Mimicking the pink noises found in nature, this soothing project was an experiment in simulation and calculation.
https://www.hackster.io/news/stefan-antoszko-s-pink-noise-generator-packs-a-ti-msp430-and-a-handful-of-resistors-and-capacitors-e8b4454cb2d0
Tomi Engdahl says:
http://dangerousprototypes.com/blog/2024/01/22/bus-pirate-5-is-here/
Tomi Engdahl says:
Embedded Platforms and Cross-compilers
https://docs.parasoft.com/display/CPPDESKE1033/Embedded+Platforms+and+Cross-compilers
The platforms and compilers discussed in this section apply specifically to embedded testing, which implies generation (and possibly validation) of tests on host, and execution of tests on a target board. If users perform only host-based testing of embedded code, platform/compiler support is determined by the main support table at the beginning of this document.
In most cases, using a cross-compiler requires preparing specific project configurations based on the built-in configurations for host-based compilers (GCC or Green Hills). If not specified otherwise, full code analysis is supported.
Tomi Engdahl says:
Practical comparison of ARM compilers
https://m0agx.eu/practical-comparison-of-ARM-compilers.html
Conclusion (and why you should support multiple toolchains)
In my opinion the three Cortex-M compilers perform almost identically in 95% of portable C use cases. There are some small advantages and disadvantages that may be relevant depending on the exact project requirements. Binaries may have better or worse performance depending on your exact code so you should always profile your firmware if performance is important. To deliver really high quality firmware I simply recommend using a mix of tools:
GCC builds for “general use”
GCC builds with gcov
GCC -fanalyzer for static analysis
GNU complexity
Clang builds for testing portability and more warnings
clang-tidy for static analysis
IAR builds for testing portability and more warnings
IAR C-STAT for static analysis and MISRA checking
Does it look like overkill? With a proper CI setup the cost of supporting all the tools is next to nothing. Every developer can pick their favourite toolchain for daily work and CI takes care of the rest. Of course it is best to “test as you fly, fly as you test” so ideally you would have hardware-in-the-loop tests for all builds.
Tomi Engdahl says:
Power Electronics and Embedded Systems Webinar | CU Boulder MS-EE
https://www.youtube.com/watch?v=KalAhIj4ODA
Tomi Engdahl says:
https://www.embeddedrelated.com/blogs-1/nf/all/Power_Electronics.php
Tomi Engdahl says:
As a relatively young language, Rust has grown quickly in popularity. It provides developers of embedded systems and a range of other applications with a new choice beyond C and C++ that can support concurrency, memory safety, and high performance.
https://www.microcontrollertips.com/what-is-rust-used-for-in-an-embedded-system/
Rust is an emerging systems programming language that’s mostly used for memory management, safety, and performance. It’s a statically typed programming language like Java, C, and C++, where variable types are known at compile time, and it’s designed for performance and safety, especially safe concurrency and memory management. Rust’s low-level control and memory safety make it a good choice for embedded systems development, but it’s being used in a much wider array of applications.
Rust is an open-source project developed originally at Mozilla Research and uses a syntax like C++. Beginning in 2021, the Rust Foundation took on responsibility for Rust and is managing the development of the language.
Rust application examples
Device drivers — Low-level control and memory safety make Rust suitable for developing device drivers. The development of safe and efficient drivers that can work consistently with the associated hardware is simplified by Rust’s type system and borrow checker.
Web development — Rust’s scalability and safety, plus its async/await support, simplifies the development of backend web services with high levels of concurrency. Its efficient memory management and safety enable developers to write memory-safe web applications.
Machine learning (ML) — Rust is not a mainline environment for ML projects, but that may change since the language includes libraries like rusty-machine and tch-rs that can support the development of ML models and tools.
Operating systems (OS) — Rust provides low-level control, efficiency, and memory safety that make it attractive for OS developers. Rust simplifies the development of secure OSs. Examples of OSs built using Rust include Mozilla, intermezzOS, QuiltOS, Rux, and Redox.
What’s a borrow checker?
In most other languages, programmers aren’t concerned with where variables are stored; the garbage collector takes care of variable storage and memory. In Rust, the borrow checker replaces the function of the garbage collector.
The borrow checker is Rust’s way of enforcing its borrowing and ownership rules, which are designed to prevent data races at compile time. It’s a safety feature that ensures references to data don’t outlive the data they refer to. In addition to preventing data races, the borrow checker prevents null or dangling pointer dereferences and double-free errors.
Rust features
Concurrency — Rust supports zero-cost abstractions that don’t incur additional runtime overhead compared to writing the code out manually and safe concurrency and multi-threading. The built-in async/await syntax and the types of systems help prevent common concurrency bugs.
Memory safety — Rust’s ownership and borrowing system helps prevent common memory-related bugs like buffer overflow. The ownership and borrowing system guarantee memory safety at compile time.
Performance — Rust delivers the same high-performance level measures as C and C++, plus strong concurrency and memory safety support.
Readable syntax — Rust’s syntax is designed to be more readable compared with C and C++. It includes features like functional programming constructs, pattern matching, and type inference that can simplify writing and maintaining code.
Cargo — Cargo is Rust’s package manager and builds the system. It’s included in the Rust distribution and automates building, testing, and publishing new projects.
Rust has room to grow
Compared with C and C++, Rust is an emerging language with an evolving development ecosystem. That presents challenges and opportunities for growth. Rust is new and has a relatively steep learning curve. Rust has a smaller developer community and few libraries, resources, and tools available. The language’s type system and borrow checker can mean longer compilation times compared to C and C++. Rust’s safety features can be a minus as well as a plus for developers. The safety features can limit low-level control and make it difficult to implement some low-level optimizations and directly interact with hardware. Despite its many challenges, Rust is still well-suited to embedded development projects, especially those that benefit from high levels of safety, reliability, and security.
As a relatively young language, Rust has grown quickly in popularity. It provides developers of embedded systems and a range of other applications with a new choice beyond C and C++ that can support concurrency, memory safety, and high performance.
Tomi Engdahl says:
Rust + Embedded: A Development Power Duo
https://blog.espressif.com/rust-embedded-a-development-power-duo-db43dae21206
Programming languages in Embedded development
Embedded development is not as popular as web development or desktop development and these are a few examples of why this might be the case:
Hardware constraints: The embedded systems will most likely have limited hardware resources, such as performance and memory. This can make it more challenging to develop software for these systems.
Limited and niche market: The embedded market is more limited than web and desktop applications and it can make it less financially rewarding for developers specializing in embedded programming.
Specialized low-level knowledge: Specialized knowledge of concrete hardware and low-level programming languages is a must-to-have in embedded development
Longer development cycles: Developing software for embedded systems can take longer than developing software for web or desktop applications, due to the need for testing and optimization of the code for the specific hardware requirements.
Low-level programming languages: These languages, such as assembly or C do not provide much of an abstraction to the developer and provide direct access to hardware resources and memory which will lead to memory bugs.
Tomi Engdahl says:
Why is Rust programming language so popular?
https://codilime.com/blog/why-is-rust-programming-language-so-popular/
Rust was created to ensure high performance similar to that offered by C and C++, but with emphasis on code safety, the lack of which is the Achilles heel of these two languages. However, Rust has more than just memory safety on its side. High performance while processing large amounts of data, support for concurrent programming, and this together with an effective compiler are other reasons why well-known software heavyweights now use this programming language. Firefox, Dropbox, Cloudflare, and many other companies from startups to large corporations use Rust in production.
In this article, you can find more about Rust’s main characteristics, what it is used for, and why you should consider adopting it for your software projects.
What is Rust Programming Language? A Guide to This Evolving Language
https://litslink.com/blog/what-is-rust-programming-language
Tomi Engdahl says:
https://en.wikipedia.org/wiki/Comparison_of_real-time_operating_systems
Tomi Engdahl says:
What is New Product Introduction (NPI)?
https://www.arenasolutions.com/resources/glossary/new-product-introduction/
New product introduction is the process of taking a product idea from concept to being available for use or production. The NPI process involves various steps that include making sure all teams are communicating throughout the NPI process and that all rules and regulations are followed. In simple terms, it’s bringing the initial idea of the product to market. NPI is often associated with NPD (new product development) and takes place after the NPD.
Tomi Engdahl says:
7 Challenges of Embedded Software Security Testing in 2024
https://www.code-intelligence.com/blog/7-challenges-of-embedded-software-security-testing
7 Challenges of Embedded Software Security Testing
For the reasons described above, identifying potential vulnerabilities in embedded systems is essential. However, testing them can be quite challenging due to the unique interaction of hardware and software within embedded systems. Here are 7 of the main challenges of embedded software security testing.
1. Remote Hardware Access
2. The Variety of Potential Attack Vectors
3. Time and Resource Constraints
4. Lack of Standardization in Embedded Software Systems
5. The Need for Real-Time Testing
6. Lack of Test Automation
7. The “Security vs Safety” Tradeoff
Many embedded systems need to be designed with both security and safety in mind. However, these two goals can often be at odds with each other. Safety mainly refers to fail-safe behavior and reliability, while security mainly refers to preventing unauthorized access to sensitive data. For example, adding security features to a system can make it more complex and difficult to test, impacting its safety. As such, embedded software teams require adequate tooling to uncover security and safety issues all the same.
Our Recommendation: Mocking Embedded Systems With Fuzz Data
A particularly effective approach to deal with the complexity of embedded software testing is mocking with fuzz data. During mocking, an embedded software module is tested in isolation and hardware dependencies are simulated. By enhancing a mocking setup with fuzz data, it can dynamically generate return values for mocked functions. This allows the tester to realistically simulate the behavior of external dependencies while covering positive and negative test criteria.
By implementing continuous fuzz testing in the early stages of software development, bugs can be found and fixed before they become an issue. This not only makes embedded systems more secure but also speeds up the development process.
Tomi Engdahl says:
https://sesamo-project.eu/sites/default/files/downloads/publications/safecomp2014-edf-safety-and-security-interactions-modeling-using-bdmp-formalism.pdf
Tomi Engdahl says:
https://www.curtisswrightds.com/media-center/articles/trusted-boot-a-key-strategy-for-ensuring-the-trustworthiness-of-an-embedded-computing-system
Tomi Engdahl says:
Python vs C/C++ vs Assembly side-by-side comparison
https://www.youtube.com/watch?v=3PcIJKd1PKU
Tomi Engdahl says:
https://ubuntu.com/blog/real-time-linux-vs-rtos-2
https://www.reddit.com/r/embedded/comments/qus40i/when_to_choose_linux_over_an_rtos/
Tomi Engdahl says:
Here’s how I look at it. Despite its many virtues, Linux carries a lot of baggage. Here are three of the big ones:
The bootloader, kernel, and root filesystem for a Linux-based system are at least a couple of orders of magnitude more complex than an RTOS-based design.
Properly securing a Linux system is generally far more challenging than doing the same for an RTOS-based system
The resource requirements for Linux are generally far greater than for an RTOS-based design, which generally means higher BOM costs and greater performance challenges on single-core processors, and greater power-consumption challenges in general.
So my general rule of thumb is to avoid using Linux unless there’s at least one compelling reason to do so, but that’s the case on a lot of projects. For instance:
Software stacks. You’re going to have a better selection of software stacks — network, graphics, filesystem, etc — that are generally going to be more feature-complete and robust than on a lot of RTOSes. For instance, if your MCU has WiFi, its vendor probably offers a WiFi stack, but it’s not going to support all of the latest security options. If you can’t find a good option for your requirements for these that works with an RTOS, Linux is the obvious choice.
Hardware drivers. Linux is the reigning champ of off-the-shelf drivers for hardware, and a lot silicon vendors only supply drivers for Linux these days. If the hardware you are working with is even remotely complex, using a off-the-shelf Linux driver can speed things up a lot (YMMV, obviously).
Projects tolerant of high BOM cost but not high NRE. A lot of embedded projects aimed at niche markets with small volumes will tolerate high per-unit costs but want to minimize NRE. For such projects, a custom carrier board built around a SOM — or even a daughtercard plus an SBC — with Linux distro supplied by a silicon vendor is often the fastest way to market (although frequently at the expense of security).
https://www.reddit.com/r/embedded/comments/qus40i/when_to_choose_linux_over_an_rtos/
Tomi Engdahl says:
https://ubuntu.com/blog/real-time-linux-vs-rtos
https://ubuntu.com/blog/real-time-linux-vs-rtos-2
In the realm of real-time computing, the choice between Real-time Linux and RTOS depends on the specific requirements of an application. While Real-time Linux, especially with the PREEMPT_RT patch, offers a robust solution for many scenarios, dedicated RTOS may still be preferable in certain critical, embedded systems. Understanding the intricacies of both options is key to making an informed decision that aligns with an enterprise’s demands and constraints.
Tomi Engdahl says:
https://stackoverflow.com/questions/25871579/what-is-the-difference-between-rtos-and-embedded-linux
Linux is a general-purpose OS (GPOS); its application to embedded systems is usually motivated by the availability of device support, file-systems, network connectivity, and UI support. All these things can be available in an RTOS, but often with less broad support, or at additional cost or integration effort.
Many RTOS are not full OS in the sense that Linux is, in that they comprise of a static link library providing only task scheduling, IPC, synchronisation timing and interrupt services and little more – essentially the scheduling kernel only. Such a library is linked with your application code to produce a single executable that your system boots directly (or via a bootloader). Most RTOS do not directly support the loading and unloading of code dynamically from a file system as you would with Linux – it is all there at start-up and runs until power down.
Critically Linux is not real-time capable. An RTOS provides scheduling guarantees to ensure deterministic behaviour and timely response to events and interrupts. In most cases this is through a priority based pre-emptive scheduling algorithm, where the highest priority task ready to run always runs – immediately – pre-empting any lower priority task without a specific yield or relinquishing of the CPU, or completion of a time-slice.
Linux has a number of scheduling options, including a real-time scheduler, but this is at best “soft” real-time – a term I dislike since it is ill-defined, and essentially means real-time, most of the time, but sometimes not. If your application has no need of “hard” real-time, that’s fine, but typical latencies in real-time Linux will be in the order of tens or hundreds of microseconds, whereas a typical RTOS real-time kernel can achieve latencies from zero to a few microseconds – even at much lower CPU clock rates.
Tomi Engdahl says:
https://etn.fi/index.php/13-news/16042-rust-koodaaminen-on-kaksi-kertaa-c-kehitystae-tehokkaampaa
Tomi Engdahl says:
Learn Embedded Rust WITHOUT Any Expensive Hardware | Rust ARM QEMU Cargo Tutorial
https://www.youtube.com/watch?v=_sYnzFe9A6E
Getting started with Rust on Embedded Systems – Elektor Engineering Insights #25
https://www.youtube.com/watch?v=l3ScKU23POA
How to Do Embedded Development with Rust • Steve Klabnik • GOTO 2023
https://www.youtube.com/watch?v=7lHtXkYnip8
Tomi Engdahl says:
Embedded Rust documentation
https://docs.rust-embedded.org/
https://docs.rust-embedded.org/discovery/index.html
This book is an introductory course on microcontroller-based embedded systems that uses Rust as the teaching language rather than the usual C/C++.
https://docs.rust-embedded.org/discovery/microbit/
https://github.com/rust-embedded/discovery
Rust on Embedded Devices Working Group
https://github.com/rust-embedded
Embedded devices
https://www.rust-lang.org/what/embedded
The Embedded Rust Book
https://docs.rust-embedded.org/book/
Welcome to The Embedded Rust Book: An introductory book about using the Rust Programming Language on “Bare Metal” embedded systems, such as Microcontrollers.
Embedded Rust is for everyone who wants to do embedded programming while taking advantage of the higher-level concepts and safety guarantees the Rust language provides.
Scope
The goals of this book are:
Get developers up to speed with embedded Rust development. i.e. How to set up a development environment.
Share current best practices about using Rust for embedded development. i.e. How to best use Rust language features to write more correct embedded software.
Serve as a cookbook in some cases. e.g. How do I mix C and Rust in a single project?
This book tries to be as general as possible but to make things easier for both the readers and the writers it uses the ARM Cortex-M architecture in all its examples. However, the book doesn’t assume that the reader is familiar with this particular architecture and explains details particular to this architecture where required.
Tomi Engdahl says:
Nyt Rust korvaa C-koodin auton mikrosiruilla
https://etn.fi/index.php/13-news/16061-nyt-rust-korvaa-c-koodin-auton-mikrosiruilla
Rust-ohjelmointikieli näyttää turvallisuutensa ansiosta nousevan C/C++:n varteenotettavaksi täydennykseksi tai jopa korvaajaksi autojen ohjelmistokehityksessä. Infineon Technologies ottaa tässä ison askeleen ensimmäisellä ISO 26262 ASIL D -hyväksytyn Rust-kääntäjällään AURIX-sarjan TC3x- ja TC4x-piireille.
C- ja C++-kieliin verrattuna Rustilla on monia ominaisuuksia, jotka tekevät siitä turvallisemman. Esimerkiksi jokaisella muuttujalla on yksi “omistaja” ja muistialue vapautetaan automaattisesti, kun omistaja poistuu näkyvistä. Lisäksi Rustissa ei voi vahingossa jakaa muutettavissa olevaa tietoa useiden säikeiden välillä ilman asianmukaista synkronointia.
Edelleen Rust pakottaa tarkat tyyppitarkistukset käännösaikana, mikä auttaa välttämään tyypinmuunnosvirheitä ja muita tyyppiin liittyviä ongelmia, jotka voivat johtaa muistin turvattomaan käyttöön. Rustin kääntäjä estää useimmat muistivuodot ja pääsynhallintavirheet tiukan muistinhallintamallinsa ansiosta. Nämä virheet ovat tyypillisiä C- ja C++ -kielille, kiitos sen tiukan muistinhallintamallin.
https://www.infineon.com/cms/en/product/promopages/rust/
Tomi Engdahl says:
Rust-koodaaminen on kaksi kertaa C++-kehitystä tehokkaampaa
https://etn.fi/index.php/13-news/16042-rust-koodaaminen-on-kaksi-kertaa-c-kehitystae-tehokkaampaa
Jopa Valkoinen talo on Yhdysvalloissa ilmoittanut, että ohjelmistonkehityksessä pitäisi päästä eroon ”muistivaarallisista” C- ja C++-kielistä. Mitä sitten tilalle? Ainakin Googlen vastaus on selvä: Rust on turvallisempi ja myös tehokkaampi kieli koodaustiimien käsissä.
Googlen suunnittelujohtaja Lars Bergstrom kertoi viime viikolla Rust Nation UK -tapahtumassa Lontoossa, mitä kokemuksia hakukonejätillä on projektien siirtämisestä Go- ja C++-koodista Rustiin. Tulokset ovat kiistattomia.
Rust on suorituskykyinen ja tehokkaasti muistia käyttävä kieli. Se on myös hyvin luotettava: muistin käyttöön liittyviä tietoturvaongelmia on hyvin vähän, usein ei ollenkaan. Hyvä dokumentointi ja kääntäjä tekevät siitä myös tehokkaan työkalun.
Rust Nation UK – Track 1
https://www.youtube.com/watch?v=6mZRWFQRvmw&t=26575s
Tomi Engdahl says:
Maailman vähävirtaisin yleiskäyttöinen 32-bittine
https://etn.fi/index.php/13-news/16069-maailman-vaehaevirtaisin-yleiskaeyttoeinen-32-bittinen
Tänään alkavilla Nürnbergin Embedded World -messuilla nähdään tuttuun tapaan iso joukko uusia sulautettujen sovellusten moottoreita eli mikro-ohjaimia. Renesas esittelee messuilla Arm Cortex-M23 -ytimeen perustuvan RA0-ohjainperheen. Se on yhtiön mukaan markkinoiden vähävirtaisin yleiskäyttöinen 32-bittinen ohjainpiiri.
Luvut ovatkin vakuuttavia. RA0-piirit kuluttavat vain 84,3 μA/MHz virtaa aktiivisessa tilassa ja lepotilassa vain 0,82 milliampeeria. Lisäksi Renesas tarjoaa siruilla Software Standby -tilan, joka vähentää virrankulutusta vielä 99 prosenttia. Tämä tarkoittaa vain 0,2 mikroampeerin kulutusta.
Ensimmäisenä uudesta perheestä tulee markkinoille RA0E1-ryhmä. Piirit on optimoitu ”kustannusherkkiin sovelluksiin” eli edulliseen hintaluokkaan. Ne tarjoavat laajan käyttöjännitealueen 1,6 V – 5,5 V, joten suunnittelijat eivät tarvitse erillisiä säätimiä 5 voltin järjestelmissä. Siruilta löytyvät myös ajastimet, sarjaliitännät, analogiset toiminnot, turvatoiminnot ja käyttöliittymätoiminnot. Saatavilla on laaja valikoima kotelovaihtoehtoja, mukaan lukien pieni 3 x 3 millimetrin 16-nastainen QFN.
RA0E1
32MHz Arm® Cortex®-M23 Entry Level Ultra-Low Power General-Purpose Microcontroller
https://www.renesas.com/us/en/products/microcontrollers-microprocessors/ra-cortex-m-mcus/ra0e1-32mhz-arm-cortex-m23-entry-level-ultra-low-power-general-purpose-microcontroller?utm_campaign=f-up-mcu_ra0e1-epsg-iotbd-ipm2-null&utm_source=null&utm_medium=pr&utm_content=pp
Tomi Engdahl says:
https://www.uusiteknologia.fi/2024/04/09/qt-ja-qualcomm-iot-yhteistyohon/
Tomi Engdahl says:
Vedä ja pudota protoja ilman koodia
https://etn.fi/index.php/13-news/16078-vedae-ja-pudota-protoja-ilman-koodia
Japanilainen Renesas lanseerasi viime vuonna pilvipohjaisen Quick Connect Studio -työkalut, joilla sulautettujen järjestelmien suunnittelu onnistuu vedä ja pudota -periaatteella. Nürnbergin Embedded Worldissa työkaluun tuotiin uusia ominaisuuksia. Käyttäjiä paketille on tähän asti tullut parisataatuhatta.
Quick Connect Studion avulla käyttäjät voivat graafisesti yhdessä optimoida laitteistoja ja ohjelmistoja prototyyppien nopeaksi validoimiseksi ja tuotekehityksen nopeuttamiseksi. Kun jokin lohko on sijoitettu suunnitteluun, kehittäjä voi luoda, kääntää ja rakentaa perusohjelmiston automaattisesti, mikä on merkittävä muutos kohti kooditonta kehitystä.
Tämä tekee tuotantotason ohjelmistojen rakentamisesta yhtä helppoa kuin rakennuspalikoiden kokoamisen yhteen. Koodausosaamista tarvitaan hyvin vähän. Pilvilaskentateho tarjoaa nopean kääntämisen, ja intuitiivinen graafinen käyttöliittymä lyhentää työkalun oppimiseen kuluvaa aikaa. Quick Connect Studio luo automaattisesti järjestelmäohjelmiston, joka voidaan testata oikealla raudalla.
Tomi Engdahl says:
https://etn.fi/index.php/13-news/16083-tekoaely-ensimmaeistae-kertaa-bluetooth-piirille