The idea for this posting started when I read New approaches to dominate in embedded development article. Then I found some ther related articles and here is the result: long article.
Embedded devices, or embedded systems, are specialized computer systems that constitute components of larger electromechanical systems with which they interface. The advent of low-cost wireless connectivity is altering many things in embedded development: With a connection to the Internet, an embedded device can gain access to essentially unlimited processing power and memory in cloud service – and at the same time you need to worry about communication issues like breaks connections, latency and security issues.
Those issues are espcecially in the center of the development of popular Internet of Things device and adding connectivity to existing embedded systems. All this means that the whole nature of the embedded development effort is going to change. A new generation of programmers are already making more and more embedded systems. Rather than living and breathing C/C++, the new generation prefers more high-level, abstract languages (like Java, Python, JavaScript etc.). Instead of trying to craft each design to optimize for cost, code size, and performance, the new generation wants to create application code that is separate from an underlying platform that handles all the routine details. Memory is cheap, so code size is only a minor issue in many applications.
Historically, a typical embedded system has been designed as a control-dominated system using only a state-oriented model, such as FSMs. However, the trend in embedded systems design in recent years has been towards highly distributed architectures with support for concurrency, data and control flow, and scalable distributed computations. For example computer networks, modern industrial control systems, electronics in modern car,Internet of Things system fall to this category. This implies that a different approach is necessary.
Companies are also marketing to embedded developers in new ways. Ultra-low cost development boards to woo makers, hobbyists, students, and entrepreneurs on a shoestring budget to a processor architecture for prototyping and experimentation have already become common.If you look under the hood of any connected embedded consumer or mobile device, in addition to the OS you will find a variety of middleware applications. As hardware becomes powerful and cheap enough that the inefficiencies of platform-based products become moot. Leaders with Embedded systems development lifecycle management solutions speak out on new approaches available today in developing advanced products and systems.
Traditional approaches
C/C++
Tradionally embedded developers have been living and breathing C/C++. For a variety of reasons, the vast majority of embedded toolchains are designed to support C as the primary language. If you want to write embedded software for more than just a few hobbyist platforms, your going to need to learn C. Very many embedded systems operating systems, including Linux Kernel, are written using C language. C can be translated very easily and literally to assembly, which allows programmers to do low level things without the restrictions of assembly. When you need to optimize for cost, code size, and performance the typical choice of language is C. Still C is today used for maximum efficiency instead of C++.
C++ is very much alike C, with more features, and lots of good stuff, while not having many drawbacks, except fror it complexity. The had been for years suspicion C++ is somehow unsuitable for use in small embedded systems. At some time many 8- and 16-bit processors were lacking a C++ compiler, that may be a concern, but there are now 32-bit microcontrollers available for under a dollar supported by mature C++ compilers.Today C++ is used a lot more in embedded systems. There are many factors that may contribute to this, including more powerful processors, more challenging applications, and more familiarity with object-oriented languages.
And if you use suitable C++ subset for coding, you can make applications that work even on quite tiny processors, let the Arduino system be an example of that: You’re writing in C/C++, using a library of functions with a fairly consistent API. There is no “Arduino language” and your “.ino” files are three lines away from being standard C++.
Today C++ has not displaced C. Both of the languages are widely used, sometimes even within one system – for example in embedded Linux system that runs C++ application. When you write a C or C++ programs for modern Embedded Linux you typically use GCC compiler toolchain to do compilation and make file to manage compilation process.
Most organization put considerable focus on software quality, but software security is different. When the security is very much talked about topic todays embedded systems, the security of the programs written using C/C++ becomes sometimes a debated subject. Embedded development presents the challenge of coding in a language that’s inherently insecure; and quality assurance does little to ensure security. The truth is that majority of today’s Internet connected systems have their networking fuctionality written using C even of the actual application layer is written using some other methods.
Java
Java is a general-purpose computer programming language that is concurrent, class-based and object-oriented.The language derives much of its syntax from C and C++, but it has fewer low-level facilities than either of them. Java is intended to let application developers “write once, run anywhere” (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of computer architecture. Java is one of the most popular programming languages in use, particularly for client-server web applications. In addition to those it is widely used in mobile phones (Java apps in feature phones,) and some embedded applications. Some common examples include SIM cards, VOIP phones, Blu-ray Disc players, televisions, utility meters, healthcare gateways, industrial controls, and countless other devices.
Some experts point out that Java is still a viable option for IoT programming. Think of the industrial Internet as the merger of embedded software development and the enterprise. In that area, Java has a number of key advantages: first is skills – there are lots of Java developers out there, and that is an important factor when selecting technology. Second is maturity and stability – when you have devices which are going to be remotely managed and provisioned for a decade, Java’s stability and care about backwards compatibility become very important. Third is the scale of the Java ecosystem – thousands of companies already base their business on Java, ranging from Gemalto using JavaCard on their SIM cards to the largest of the enterprise software vendors.
Although in the past some differences existed between embedded Java and traditional PC based Java solutions, the only difference now is that embedded Java code in these embedded systems is mainly contained in constrained memory, such as flash memory. A complete convergence has taken place since 2010, and now Java software components running on large systems can run directly with no recompilation at all on design-to-cost mass-production devices (consumers, industrial, white goods, healthcare, metering, smart markets in general,…) Java for embedded devices (Java Embedded) is generally integrated by the device manufacturers. It is NOT available for download or installation by consumers. Originally Java was tightly controlled by Sun (now Oracle), but in 2007 Sun relicensed most of its Java technologies under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java (bytecode compiler), GNU Classpath (standard libraries), and IcedTea-Web (browser plugin for applets).
My feelings with Java is that if your embedded systems platform supports Java and you know hot to code Java, then it could be a good tool. If your platform does not have ready Java support, adding it could be quite a bit of work.
Increasing trends
Databases
Embedded databases are coming more and more to the embedded devices. If you look under the hood of any connected embedded consumer or mobile device, in addition to the OS you will find a variety of middleware applications. One of the most important and most ubiquitous of these is the embedded database. An embedded database system is a database management system (DBMS) which is tightly integrated with an application software that requires access to stored data, such that the database system is “hidden” from the application’s end-user and requires little or no ongoing maintenance.
There are many possible databases. First choice is what kind of database you need. The main choices are SQL databases and simpler key-storage databases (also called NoSQL).
SQLite is the Database chosen by virtually all mobile operating systems. For example Android and iOS ship with SQLite. It is also built into for example Firefox web browser. It is also often used with PHP. So SQLite is probably a pretty safe bet if you need relational database for an embedded system that needs to support SQL commands and does not need to store huge amounts of data (no need to modify database with millions of lines of data).
If you do not need relational database and you need very high performance, you need probably to look somewhere else.Berkeley DB (BDB) is a software library intended to provide a high-performance embedded database for key/value data. Berkeley DB is written in Cwith API bindings for many languages. BDB stores arbitrary key/data pairs as byte arrays. There also many other key/value database systems.
RTA (Run Time Access) gives easy runtime access to your program’s internal structures, arrays, and linked-lists as tables in a database. When using RTA, your UI programs think they are talking to a PostgreSQL database (PostgreSQL bindings for C and PHP work, as does command line tool psql), but instead of normal database file you are actually accessing internals of your software.
Software quality
Building quality into embedded software doesn’t happen by accident. Quality must be built-in from the beginning. Software startup checklist gives quality a head start article is a checklist for embedded software developers to make sure they kick-off their embedded software implementation phase the right way, with quality in mind
Safety
Traditional methods for achieving safety properties mostly originate from hardware-dominated systems. Nowdays more and more functionality is built using software – including safety critical functions. Software-intensive embedded systems require new approaches for safety. Embedded Software Can Kill But Are We Designing Safely?
IEC, FDA, FAA, NHTSA, SAE, IEEE, MISRA, and other professional agencies and societies work to create safety standards for engineering design. But are we following them? A survey of embedded design practices leads to some disturbing inferences about safety.Barr Group’s recent annual Embedded Systems Safety & Security Survey indicate that we all need to be concerned: Only 67 percent are designing to relevant safety standards, while 22 percent stated that they are not—and 11 percent did not even know if they were designing to a standard or not.
If you were the user of a safety-critical embedded device and learned that the designers had not followed best practices and safety standards in the design of the device, how worried would you be? I know I would be anxious, and quite frankly. This is quite disturbing.
Security
The advent of low-cost wireless connectivity is altering many things in embedded development – it has added to your list of worries need to worry about communication issues like breaks connections, latency and security issues. Understanding security is one thing; applying that understanding in a complete and consistent fashion to meet security goals is quite another. Embedded development presents the challenge of coding in a language that’s inherently insecure; and quality assurance does little to ensure security.
Developing Secure Embedded Software white paper explains why some commonly used approaches to security typically fail:
MISCONCEPTION 1: SECURITY BY OBSCURITY IS A VALID STRATEGY
MISCONCEPTION 2: SECURITY FEATURES EQUAL SECURE SOFTWARE
MISCONCEPTION 3: RELIABILITY AND SAFETY EQUAL SECURITY
MISCONCEPTION 4: DEFENSIVE PROGRAMMING GUARANTEES SECURITY
Some techniques for building security to embedded systems:
Use secure communications protocols and use VPN to secure communications
The use of Public Key Infrastructure (PKI) for boot-time and code authentication
Establishing a “chain of trust”
Process separation to partition critical code and memory spaces
Leveraging safety-certified code
Hardware enforced system partitioning with a trusted execution environment
Plan the system so that it can be easily and safely upgraded when needed
Flood of new languages
Rather than living and breathing C/C++, the new generation prefers more high-level, abstract languages (like Java, Python, JavaScript etc.). So there is a huge push to use interpreted and scripting also in embedded systems. Increased hardware performance on embedded devices combined with embedded Linux has made the use of many scripting languages good tools for implementing different parts of embedded applications (for example web user interface). Nowadays it is common to find embedded hardware devices, based on Raspberry Pi for instance, that are accessible via a network, run Linux and come with Apache and PHP installed on the device. There are also many other relevant languages
One workable solution, especially for embedded Linux systems is that part of the activities organized by totetuettu is a C program instead of scripting languages (Scripting). This enables editing operation simply script files by editing without the need to turn the whole system software again. Scripting languages are also tools that can be implemented, for example, a Web user interface more easily than with C / C ++ language. An empirical study found scripting languages (such as Python) more productive than conventional languages (such as C and Java) for a programming problem involving string manipulation and search in a dictionary.
Scripting languages have been around for a couple of decades Linux and Unix server world standard tools. the proliferation of embedded Linux and resources to merge systems (memory, processor power) growth has made them a very viable tool for many embedded systems – for example, industrial systems, telecommunications equipment, IoT gateway, etc . Some of the command language is suitable for up well even in quite small embedded environments.
I have used with embedded systems successfully mm. Bash, AWK, PHP, Python and Lua scripting languages. It works really well and is really easy to make custom code quickly .It doesn’t require a complicated IDE; all you really need is a terminal – but if you want there are many IDEs that can be used. High-level, dynamically typed languages, such as Python, Ruby and JavaScript. They’re easy—and even fun—to use. They lend themselves to code that easily can be reused and maintained.
There are some thing that needs to be considered when using scripting languages. Sometimes lack of static checking vs a regular compiler can cause problems to be thrown at run-time. But it is better off practicing “strong testing” than relying on strong typing. Other ownsides of these languages is that they tend to execute more slowly than static languages like C/C++, but for very many aplications they are more than adequate. Once you know your way around dynamic languages, as well the frameworks built in them, you get a sense of what runs quickly and what doesn’t.
Bash and other shell scipting
Shell commands are the native language of any Linux system. With the thousands of commands available for the command line user, how can you remember them all? The answer is, you don’t. The real power of the computer is its ability to do the work for you – the power of the shell script is the way to easily to automate things by writing scripts. Shell scripts are collections of Linux command line commands that are stored in a file. The shell can read this file and act on the commands as if they were typed at the keyboard.In addition to that shell also provides a variety of useful programming features that you are familar on other programming langauge (if, for, regex, etc..). Your scripts can be truly powerful. Creating a script extremely straight forward: It can be created by opening a separate editor such or you can do it through a terminal editor such as VI (or preferably some else more user friendly terminal editor). Many things on modern Linux systems rely on using scripts (for example starting and stopping different Linux services at right way).
The most common type of shell script is a bash script. Bash is a commonly used scripting language for shell scripts. In BASH scripts (shell scripts written in BASH) users can use more than just BASH to write the script. There are commands that allow users to embed other scripting languages into a BASH script.
There are also other shells. For example many small embedded systems use BusyBox. BusyBox providesis software that provides several stripped-down Unix tools in a single executable file (more than 300 common command). It runs in a variety of POSIX environments such as Linux, Android and FreeeBSD. BusyBox become the de facto standard core user space toolset for embedded Linux devices and Linux distribution installers.
Shell scripting is a very powerful tool that I used a lot in Linux systems, both embedded systems and servers.
Lua
Lua is a lightweight cross-platform multi-paradigm programming language designed primarily for embedded systems and clients. Lua was originally designed in 1993 as a language for extending software applications to meet the increasing demand for customization at the time. It provided the basic facilities of most procedural programming languages. Lua is intended to be embedded into other applications, and provides a C API for this purpose.
Lua has found many uses in many fields. For example in video game development, Lua is widely used as a scripting language by game programmers. Wireshark network packet analyzer allows protocol dissectors and post-dissector taps to be written in Lua – this is a good way to analyze your custom protocols.
There are also many embedded applications. LuCI, the default web interface for OpenWrt, is written primarily in Lua. NodeMCU is an open source hardware platform, which can run Lua directly on the ESP8266 Wi-Fi SoC. I have tested NodeMcu and found it very nice system.
PHP
PHP is a server-side HTML embedded scripting language. It provides web developers with a full suite of tools for building dynamic websites but can also be used as a general-purpose programming language. Nowadays it is common to find embedded hardware devices, based on Raspberry Pi for instance, that are accessible via a network, run Linux and come with Apache and PHP installed on the device. So on such enviroment is a good idea to take advantage of those built-in features for the applications they are good – for building web user interface. PHP is often embedded into HTML code, or it can be used in combination with various web template systems, web content management system and web frameworks. PHP code is usually processed by a PHP interpreter implemented as a module in the web server or as a Common Gateway Interface (CGI) executable.
Python
Python is a widely used high-level, general-purpose, interpreted, dynamic programming language. Its design philosophy emphasizes code readability. Python interpreters are available for installation on many operating systems, allowing Python code execution on a wide variety of systems. Many operating systems include Python as a standard component; the language ships for example with most Linux distributions.
Python is a multi-paradigm programming language: object-oriented programming and structured programming are fully supported, and there are a number of language features which support functional programming and aspect-oriented programming, Many other paradigms are supported using extensions, including design by contract and logic programming.
Python is a remarkably powerful dynamic programming language that is used in a wide variety of application domains. Since 2003, Python has consistently ranked in the top ten most popular programming languages as measured by the TIOBE Programming Community Index. Large organizations that make use of Python include Google, Yahoo!, CERN, NASA. Python is used successfully in thousands of real world business applications around globally, including many large and mission-critical systems such as YouTube.com and Google.com.
Python was designed to be highly extensible. Libraries like NumPy, SciPy and Matplotlib allow the effective use of Python in scientific computing. Python is intended to be a highly readable language. Python can also be embedded in existing applications and hasbeen successfully embedded in a number of software products as a scripting language. Python can serve as a scripting language for web applications, e.g., via mod_wsgi for the Apache web server.
Python can be used in embedded, small or minimal hardware devices. Some modern embedded devices have enough memory and a fast enough CPU to run a typical Linux-based environment, for example, and running CPython on such devices is mostly a matter of compilation (or cross-compilation) and tuning. Various efforts have been made to make CPython more usable for embedded applications.
For more limited embedded devices, a re-engineered or adapted version of CPython, might be appropriate. Examples of such implementations include the following: PyMite, Tiny Python, Viper. Sometimes the embedded environment is just too restrictive to support a Python virtual machine. In such cases, various Python tools can be employed for prototyping, with the eventual application or system code being generated and deployed on the device. Also MicroPython and tinypy have been ported Python to various small microcontrollers and architectures. Real world applications include Telit GSM/GPRS modules that allow writing the controlling application directly in a high-level open-sourced language: Python.
Python on embedded platforms? It is quick to develop apps, quick to debug – really easy to make custom code quickly. Sometimes lack of static checking vs a regular compiler can cause problems to be thrown at run-time. To avoid those try to have 100% test coverage. pychecker is a very useful too also which will catch quite a lot of common errors. The only downsides for embedded work is that sometimes python can be slow and sometimes it uses a lot of memory (relatively speaking). An empirical study found scripting languages (such as Python) more productive than conventional languages (such as C and Java) for a programming problem involving string manipulation and search in a dictionary. Memory consumption was often “better than Java and not much worse than C or C++”.
JavaScript and node.js
JavaScript is a very popular high-level language. Love it or hate it, JavaScript is a popular programming language for many, mainly because it’s so incredibly easy to learn. JavaScript’s reputation for providing users with beautiful, interactive websites isn’t where its usefulness ends. Nowadays, it’s also used to create mobile applications, cross-platform desktop software, and thanks to Node.js, it’s even capable of creating and running servers and databases! There is huge community of developers. JavaScript is a high-level language.
Its event-driven architecture fits perfectly with how the world operates – we live in an event-driven world. This event-driven modality is also efficient when it comes to sensors.
Regardless of the obvious benefits, there is still, understandably, some debate as to whether JavaScript is really up to the task to replace traditional C/C++ software in Internet connected embedded systems.
It doesn’t require a complicated IDE; all you really need is a terminal.
JavaScript is a high-level language. While this usually means that it’s more human-readable and therefore more user-friendly, the downside is that this can also make it somewhat slower. Being slower definitely means that it may not be suitable for situations where timing and speed are critical.
JavaScript is already in embedded boards. You can run JavaScipt on Raspberry Pi and BeagleBone. There are also severa other popular JavaScript-enabled development boards to help get you started: The Espruino is a small microcontroller that runs JavaScript. The Tessel 2 is a development board that comes with integrated wi-fi, an ethernet port, two USB ports, and companion source library downloadable via the Node Package Manager. The Kinoma Create, dubbed the “JavaScript powered Internet of Things construction kit.”The best part is that, depending on the needs of your device, you can even compile your JavaScript code into C!
JavaScript for embedded systems is still in its infancy, but we suspect that some major advancements are on the horizon.We for example see a surprising amount of projects using Node.js.Node.js is an open-source, cross-platform runtime environment for developing server-side Web applications. Node.js has an event-driven architecture capable of asynchronous I/O that allows highly scalable servers without using threading, by using a simplified model of event-driven programming that uses callbacks to signal the completion of a task. The runtime environment interprets JavaScript using Google‘s V8 JavaScript engine.Node.js allows the creation of Web servers and networking tools using JavaScript and a collection of “modules” that handle various core functionality. Node.js’ package ecosystem, npm, is the largest ecosystem of open source libraries in the world. Modern desktop IDEs provide editing and debugging features specifically for Node.js applications
JXcore is a fork of Node.js targeting mobile devices and IoTs. JXcore is a framework for developing applications for mobile and embedded devices using JavaScript and leveraging the Node ecosystem (110,000 modules and counting)!
Why is it worth exploring node.js development in an embedded environment? JavaScript is a widely known language that was designed to deal with user interaction in a browser.The reasons to use Node.js for hardware are simple: it’s standardized, event driven, and has very high productivity: it’s dynamically typed, which makes it faster to write — perfectly suited for getting a hardware prototype out the door. For building a complete end-to-end IoT system, JavaScript is very portable programming system. Typically an IoT projects require “things” to communicate with other “things” or applications. The huge number of modules available in Node.js makes it easier to generate interfaces – For example, the HTTP module allows you to create easily an HTTP server that can easily map the GET method specific URLs to your software function calls. If your embedded platform has ready made Node.js support available, you should definately consider using it.
Future trends
According to New approaches to dominate in embedded development article there will be several camps of embedded development in the future:
One camp will be the traditional embedded developer, working as always to craft designs for specific applications that require the fine tuning. These are most likely to be high-performance, low-volume systems or else fixed-function, high-volume systems where cost is everything.
Another camp might be the embedded developer who is creating a platform on which other developers will build applications. These platforms might be general-purpose designs like the Arduino, or specialty designs such as a virtual PLC system.
This third camp is likely to become huge: Traditional embedded development cannot produce new designs in the quantities and at the rate needed to deliver the 50 billion IoT devices predicted by 2020.
Transition will take time. The enviroment is different than computer and mobile world. There are too many application areas with too widely varying requirements for a one-size-fits-all platform to arise.
Sources
Most important information sources:
New approaches to dominate in embedded development
A New Approach for Distributed Computing in Embedded Systems
New Approaches to Systems Engineering and Embedded Software Development
Embracing Java for the Internet of Things
Embedded Linux – Shell Scripting 101
Embedded Linux – Shell Scripting 102
Embedding Other Languages in BASH Scripts
PHP Integration with Embedded Hardware Device Sensors – PHP Classes blog
JavaScript: The Perfect Language for the Internet of Things (IoT)
Anyone using Python for embedded projects?
JavaScript: The Perfect Language for the Internet of Things (IoT)
MICROCONTROLLERS AND NODE.JS, NATURALLY
Node.JS Appliances on Embedded Linux Devices
The smartest way to program smart things: Node.js
Embedded Software Can Kill But Are We Designing Safely?
DEVELOPING SECURE EMBEDDED SOFTWARE
1,687 Comments
Tomi Engdahl says:
Menara Networks announces availability of new OTN tunable SFP+ for commercial and industrial temperature applications
http://www.lightwaveonline.com/articles/2018/03/menara-networks-announces-availability-of-new-otn-tunable-sfp-for-commercial-and-industrial-temperature-applications.html?cmpid=enl_lightwave_lightwave_enabling_technologies_2018-03-15&pwhid=6b9badc08db25d04d04ee00b499089ffc280910702f8ef99951bdbdad3175f54dcae8b7ad9fa2c1f5697ffa19d05535df56b8dc1e6f75b7b6f6f8c7461ce0b24&eid=289644432&bid=2035875
Menara Networks said its OTN tunable SFP+ transceiver is generally available for commercial and industrial temperature applications. The “system-in-module” features integrated forward error correction (FEC) and improved monitoring capabilities.
According to Menara, its OTN SFP+ is based on the company’s proprietary high speed integrated circuit, and delivers enhanced optical performance, FEC, and full G.709 OTN functionalities similar to functionalities in chassis-based DWDM transponders, in a pluggable small form factor.
Compatible with all key routers and Ethernet/MPLS switches, the OTN tunable SFP+ processes 10G Ethernet, 10G FC, and 9.96 Gbps SONET/SDH transparently, and is the only module in the industry capable of 120 km reach without optical amplification or dispersion compensation at 11.1 Gbps, Menara asserts. With “near-end” and “far-end” in-service monitoring, Menara’s transceiver is well-suited for zero foot-print 10G NID applications, the company says. The Telcordia qualified module is tunable over the entire C-Band on the 50-GHz grid.
Tomi Engdahl says:
Cumulus Networks announces availability of Cumulus Linux for early access on Voyager
http://www.lightwaveonline.com/articles/2018/03/cumulus-networks-announces-availability-of-cumulus-linux-for-early-access-on-voyager.html?cmpid=enl_lightwave_lightwave_enabling_technologies_2018-03-15&pwhid=6b9badc08db25d04d04ee00b499089ffc280910702f8ef99951bdbdad3175f54dcae8b7ad9fa2c1f5697ffa19d05535df56b8dc1e6f75b7b6f6f8c7461ce0b24&eid=289644432&bid=2035875
The availability of Cumulus Linux on Voyager follows the ADVA Optical Networking and fellow Telecom Infra Project (TIP) member InterNexa S.A. announcement in November 2017 that a successful trial of TIP’s Voyager open whitebox packet DWDM transponder platform was complete
Integrating DWDM technology with switching and routing functionality, Voyager is the industry’s first open packet-optical transport system, Cumulus Networks attests. Cumulus Linux meets operator demand for scalable, affordable backhaul infrastructure to support growing internet usage worldwide and bandwidth-intensive applications, including scientific research, machine learning, video, and virtual reality.
Cumulus says it offers interfaces for programmability and automation, along with delivering a L2/L3 stack, and an open Linux model that provides operators with deep, fabric-wide visibility. With the combination of IP and optical, Cumulus Linux’s routing protocol stack, VXLAN, and EVPN enable customers to build low-cost, high-performance long haul systems. The collaboration creates a market for Cumulus beyond the data center to data center interconnect
Tomi Engdahl says:
MACOM and ColorChip use PRISM PAM4 PHY to launch full bi-directional 100G Serial QSFP28 module
http://www.lightwaveonline.com/articles/2018/03/macom-and-colorchip-use-prism-pam4-phy-to-launch-full-bi-directional-100g-serial-qsfp28-module.html?cmpid=enl_lightwave_lightwave_enabling_technologies_2018-03-15&pwhid=6b9badc08db25d04d04ee00b499089ffc280910702f8ef99951bdbdad3175f54dcae8b7ad9fa2c1f5697ffa19d05535df56b8dc1e6f75b7b6f6f8c7461ce0b24&eid=289644432&bid=2035875
MACOM Technology Solutions Inc. (MACOM) said it has partnered with optical transceiver developer ColorChip to launch a full bi-directional 100G Serial QSFP28 module using the patented MACOM PRISM PAM4 PHY.
A highly integrated PAM4 PHY, the MACOM PRISM converts 100 Gigabit Ethernet traffic from four lanes running at 25 Gbps to a single lane running at 100 Gbps, says MACOM. With only one set of optical components required in a 100GE module, customers will be able to obtain the required cost points for next generation 100G links.
Tomi Engdahl says:
EXFO unveils new test system for passive components
http://www.lightwaveonline.com/articles/2018/03/exfo-unveils-new-test-system-for-passive-components.html?cmpid=enl_lightwave_lightwave_enabling_technologies_2018-03-15&pwhid=6b9badc08db25d04d04ee00b499089ffc280910702f8ef99951bdbdad3175f54dcae8b7ad9fa2c1f5697ffa19d05535df56b8dc1e6f75b7b6f6f8c7461ce0b24&eid=289644432&bid=2035875
EXFO Inc. (NASDAQ: EXFO) (TSX: EXF) has released what it asserts is the fastest component test system for insertion loss (IL) and return loss (RL) measurement for an array of passive components, such as photonics integrated circuits. The CTP10 component test platform combines technology obtained from EXFO’s acquisition of test and measurement instrument developer Yenista Optics in September of 2017 (see “EXFO eyes Yenista Optics acquisition”). The new CTP10 platform can be used by research scientists to characterize components, or in automated mode for high volume production, says EXFO.
The growing demand for photonics integrated circuits (PICs) comprised of hundreds of passive components, and for lowering network equipment costs have contributed to passive component manufacturers’ need to decrease their testing time, while maintaining accuracy and reliability. According to EXFO, the CTP10 component test platform has a capability to measure IL and RL in a single sweep up to 1000 Nmps to address these challenges.
“When EXFO acquired Yenista, the objective was to leverage their expertise to bring some of the most innovative testing solutions for the optical telecom industry,”
Tomi Engdahl says:
Lightwave Announces Winners of 2018 Innovation Reviews
http://www.lightwaveonline.com/articles/2018/03/lightwave-announces-winners-of-2018-innovation-reviews.html?cmpid=enl_lightwave_lightwave_enabling_technologies_2018-03-15&pwhid=6b9badc08db25d04d04ee00b499089ffc280910702f8ef99951bdbdad3175f54dcae8b7ad9fa2c1f5697ffa19d05535df56b8dc1e6f75b7b6f6f8c7461ce0b24&eid=289644432&bid=2035875
Lightwave Editorial Director Stephen Hardy revealed the highest scoring entries in 10 product categories as 2018 Innovation Reviews Winners during a reception held on the second day of OFC 2018 in San Diego, CA. The event marked the first time in the program’s five-year history that Lightwave named the top scoring entry in each category a 2018 Lightwave Innovation Reviews Winner!
Tomi Engdahl says:
Mitigate Stress and Angst Over IoT Embedded Software Development
http://www.electronicdesign.com/embedded-revolution/mitigate-stress-and-angst-over-iot-embedded-software-development?code=NN6TI108&utm_rid=CPG05000002750211&utm_campaign=15904&utm_medium=email&elq2=1277cda1e00c441a9015102d751b0287
Sponsored by Texas Instruments: Software tools like those available with the SimpleLink Platform and SDK offer an easier way to develop more code sooner.
Virtually every electronic product contains at least one embedded controller. For that reason, it’s safe to say that at some point every design ultimately becomes a software development project. That makes software design and coding the critical chore of the project. The result is a massive amount of stress and responsibility on the engineer or team creating the software. The hardware is dead in the water until the code comes along.
Tomi Engdahl says:
Yet another 5 embedded software programming tips
https://www.mentor.com/embedded-software/blog/post/yet-another-5-embedded-software-programming-tips-7562356f-3fde-4db6-acf2-528b243a02be?cmpid=10168
Do not confuse “real time” with “real fast”.
Real time means predictable or deterministic, but not necessarily fast. Although the term is commonly used to say that a system is fast enough to do a job, it would be equally accurate to use the term to describe a systems that was slow enough.
Always write code with the human reader in mind, not the compiler
If you overload an operator in C++, it is generally unwise to completely change its functionality
If you have a choice between if…else and switch, always choose switch
Never use a shared variable to communicate between tasks
In a multi-tasking application, data commonly needs to be passed from one task to another. A global variable might seem like a good idea, but it does not provide any access management, which can cause problems. The best practice is to use facilities provided by the RTOS, like mailboxes, event flags, signals or queues.
Tomi Engdahl says:
Tail End Latency And Server Debug
How to deal with excessive latency and performance issues.
https://semiengineering.com/tail-end-latency-and-server-debug/
In the drive to deliver highly scalable services that meet the demands of mobile users, enterprises and, increasingly, the Internet of things, the software underpinning them has become incredibly complex. At the same time, the systems that run these complex workloads have become prone to troublesome and often baffling performance issues.
Tomi Engdahl says:
How To Build Security Into Your Software Development Process
https://semiengineering.com/how-to-build-security-into-your-software-development-process/
Adding security into the software development lifecycle can improve efficiency and reduce costs.
Download the eBook to:
Learn how to add security to the various phases of your SDLC
Understand how secure software development works in theory and in the real world
Examine how to implement security activities with purpose
See how to get started
Tomi Engdahl says:
What’s All This Software Stuff, Anyhow?
http://www.electronicdesign.com/analog/what-s-all-software-stuff-anyhow?NL=ED-003&Issue=ED-003_20180327_ED-003_137&sfvc4enews=42&cl=article_2_b&utm_rid=CPG05000002750211&utm_campaign=16162&utm_medium=email&elq2=77095be93d694dd6899af60598014ebb
The only thing more frustrating than using software is writing it. These days you can’t just avoid it like Bob Pease did.
The Atlantic article references the same Toyota unintended acceleration problem Pease alluded to in his email. It also acknowledges that software is wickedly complex, “…beyond our ability to intellectually manage.” Intellect cannot help us understand something as complex as a software program.
My programmer buddy says, “Over 100,000 lines of code, and you just poke it with sticks, hoping it doesn’t break somewhere else.”
The Atlantic article maintains that “The FAA (Federal Aviation Administration) is fanatical about software safety.” No, the FAA is fanatical about software documentation. So was the Army, which required contractors to comment every line of code. So we would have silly comments like “Move register C to the accumulator.” Factually correct, but absolutely useless to understand the design intent. A friend who works on products under FAA certification tells me it’s the worse code he has ever seen. One problem is that it never gets patched or upgraded, since that would trigger another expensive time-consuming FAA review.
Team…Building…
To build a successful skyscraper you need architects, engineers, and interior decorators. The architect has to mediate between the fanciful interior decorators and the down-to-earth engineers. If the decorators want some giant unsupported glass wall, the architect has to check with the engineers to make sure this is possible. If the architect wants some cantilevered open-span structure, she knows to check with the engineer to make sure it won’t collapse.
When I have worked with website software teams, I noticed they were mostly interior decorators, with a few programmers. There were no website architects. The marketing or design people wanted snazzy rounded corners and pop-up light-boxes and all kinds of trendy features. The engineers just put their nose to the grindstone and tried to deliver. Then the marketing people were surprised to see the website slow, buggy, and not compatible with all browsers. Nothing was architected. It was non-technical people demanding things work a certain way, and powerless engineers in the trenches trying to make things work that way.
I saw one engineer spend a day trying to make nice radiused corners on a box. When his boss gave him guff for taking so much time, he explained that getting rounded corners on all browsers without using non-approved JavaScript was not easy. When they told the marketing types, the reply was, “Why didn’t you tell us? We could have lived with square corners.” No architect.
That same programmer used to work at eBay many years ago. He noted a vice president had come from Oracle and insisted that the customer-facing servers be 170 Windows computers. Being Windows, it was necessary to reboot the machines every few days so that the inevitable Windows memory leaks didn’t crash the computer.
Problem was, as long as any given customer would have an eBay session open, you could not just reboot and cut him off. So the system administration was designed to stop any new pages views on that one machine, while waiting for all existing sessions to end. Then the computer could be rebooted and start to accept new page requests. It might take days.
To me, that says one of the biggest websites on earth didn’t have an architect. We all know how this happens. Something is slapped together to get working fast. Things are added onto that. Nobody ever just tosses all of the code and starts over.
Modes of Modeling
The Atlantic article talks about model-based design like it’s a new thing. Companies like ANSYS were talking about model-based design years ago. Simulink works in Matlab to characterize multi-domain dynamic systems using model-based design
If model-based design gets you a working system sooner, that’s great. Mentor Graphics sells software to help understand the interaction of multiple CAN (controller area network) buses. Modern autos often have multiple CAN buses as well as other buses such as LIN, MOST, and VAN. With 100 million line of code in a modern car, the engineers need all of the tools they can get to help ensure the software runs as intended.
Companies like National Instruments gave us LabVIEW three decades ago. This allows for better architecture, since it’s so visual. You can finally see the software and how it works. There are pretty little boxes you hook up, that can be understood by other programmers at a glance. Then again, there’s also a place for a few lines of old-fashioned code, which LabVIEW will let you put inline. It’s the best of both worlds.
I see Arduino as a hopeful future for software. It took me less than an hour to get an Arduino board communicating over the USB port, while sensing switches and lighting LEDs.
The problem with any design, model-based or otherwise, is that you have to understand the model.
The consultant that architected OrCAD told me that he doesn’t start writing code until he has three different ways to solve the problem. Then he evaluates all three for those unintended consequences we all suffer with. A wag has noted, “The best programming language is the language your best programmer likes best.” The thing is, software is a language, and it’s one we hardware folks don’t always get
Sometimes software can be the most abstract mathematics made real and beautiful. Other times, it can be a programmer punishing the world for teasing him in Junior High School. We are going to get both
Tomi Engdahl says:
For example, software can be described in a textual language familiar to programmers while serving as a model for generating error-free, MISRA compliant C-code. Software engineers can focus on core functionality rather than worry about malicious code constructs causing havoc during run time.
This approach also enables the easy management of multiple variants of the same functionality by separating the design from the implementation details, further reducing development effort and time.
Tomi Engdahl says:
Moving from an Rtos to Linux? (Practical Insights Nobody’s Telling You)
https://www.mentor.com/embedded-software/resources/overview/moving-from-an-rtos-to-linux-practical-insights-nobody-s-telling-you–e25c4c82-eeb7-4d2d-8868-7b9520269426?uuid=e25c4c82-eeb7-4d2d-8868-7b9520269426&contactid=1&PC=L&c=2018_04_03_esd_newsletter_update_mar_2018
There is much written about considerations of moving from RTOS to Linux for embedded projects.
Tomi Engdahl says:
https://www.uusiteknologia.fi/2018/04/03/iot-laitteiden-kehittamiseen-uusi-suunnittelumenetelma/
Tomi Engdahl says:
PLUG AND PLAY
RECONFIGURABLE
SOLUTIONS FOR
HETEROGENEOUS IOT
http://jultika.oulu.fi/files/isbn9789526218410.pdf
Tomi Engdahl says:
Testing Distributed Systems for Linearizability
04 Jun 2017 · 8 min read — shared on Hacker News, Lobsters, Reddit and Twitter
https://www.anishathalye.com/2017/06/04/testing-distributed-systems-for-linearizability/
Distributed systems are challenging to implement correctly because they must handle concurrency and failure. Networks can delay, duplicate, reorder, and drop packets, and machines can fail at any time. Even when designs are proven correct on paper, it is difficult to avoid subtle bugs in implementations.
Unless we want to use formal methods1, we have to test systems if we want assurance that implementations are correct. Testing distributed systems is challenging, too. Concurrency and nondeterminism make it difficult to catch bugs in tests, especially when the most subtle bugs surface only under scenarios that are uncommon in regular operation, such as simultaneous machine failure or extreme network delays.
Tomi Engdahl says:
Go on very small hardware (Part 1)
Mar 30, 2018
https://ziutek.github.io/2018/03/30/go_on_very_small_hardware.html
How low we can Go and still do something useful?
Tomi Engdahl says:
Tiny Neural Network Library in 200 Lines of Code
https://hackaday.com/2018/04/08/tiny-neural-network-library-in-200-lines-of-code/
Neural networks have gone mainstream with a lot of heavy-duty — and heavy-weight — tools and libraries. What if you want to fit a network into a little computer? There’s tinn — the tiny neural network. If you can compile 200 lines of standard C code with a C or C++ compiler, you are in business. There are no dependencies on other code.
https://github.com/glouw/tinn
Tomi Engdahl says:
5 more embedded software programming tips
https://www.mentor.com/embedded-software/blog/post/5-more-embedded-software-programming-tips-a50b5869-8783-4881-8a62-5bbaa6f6e412?cmpid=10168
In C/C++, always put braces ({ }), both opening and closing, on lines by themselves and line up a corresponding pair horizontally
Even if you inline a function in C/C++, the compiler is likely to make an out-of-line copy
Even though an assignment in C/C++ yields a value, it is very bad practice to embed one in an expression
An extra word at the end of a stack may be used to monitor overflow
Function prototypes are not mandatory in C. Just pretend that they are
Tomi Engdahl says:
Is Your ‘Safe’ FPGA Design Safe Enough?
https://www.mentor.com/hls-lp/multimedia/is-your-safe-fpga-design-safe-enough?clp=1&mid=15254983&PC=L&c=2018_04_26_catapult_safe_enough_od_promo
automated synthesis-based mitigation methods such as triple modular redundancy (TMR) and safer finite state machine (FSM) encoding – fault tolerant and fault recovery modes, on an FPGA device
Tomi Engdahl says:
Hidden Costs Of Shifting Left
https://semiengineering.com/hidden-costs-of-shifting-left/
How much time and effort can be saved by doing certain tasks earlier, and where are the pain points.
The term “Shift Left” has been used increasingly within the semiconductor development flow to indicate tasks that were once performed sequentially must now be done concurrently. This is usually due to a tightening of dependences between tasks. One such example being talked about today is the need to perform hardware/software integration much earlier in the flow, rather than leaving it as a sequential task that starts when first silicon becomes available. But does it work, and does it really save time and effort?
Systems have changed significantly over the past 10 years. Historically, bringing up software on hardware was not that difficult.
“Products are getting complicated,” proclaims Alex Starr, senior fellow at Advanced Micro Devices. “A typical system today has over thirty firmware engines in it, in addition to the actual CPU. There has been a huge complexity increase plus there are also security concerns for these firmware engines, there is power management and it is all controlled by the firmware engines.”
Suman Mandal, emulation architect for Intel, adds “there are more programmable components in a system, and the list just keeps growing. You can no longer just verify the hardware. You can no longer just verify the software based on a scalable unchanging hardware that hasn’t changed much over the years. You have had the luxury of building on the shoulders of giants and not having to worry about it much. Today, we are seeing all of these coming together in a timeframe that a lot of the engineering communities are not used to.”
Even if all the IP blocks used within a system have been exhaustively verified, there are still verification challenges. “Unless there is one company who makes everything, then you will always have integration problems,”
How far left?
When is the right time to start developing and integrating software? “When Arm develops IP, we start developing a system and software as soon as it is even in the concept stage,” says Neifert. “We start with the methodology as early as we can. We are developing models now for processors that we won’t even talk to partners about for another year or two.”
Arm isn’t alone on this. “We develop performance models before the hardware gets started,” adds Ullah. “We have to be able to give the architects ideas about what they need to do, and we rely on the model to allow us to make tradeoffs. These are C++ virtual models.”
The situation is helped by the incremental nature of most designs. This is especially true of processors and many of the interfaces into a design. “We take the design from a previous generation and extract traces of the software that we can run on the models of the next generation,” continues Ullah. “Some can be virtual models, some can be hardware, and if we are lucky we get something that we can boot the OS on. Then we can look at newer software. In the past that used to be when all features were complete, but we are moving that up.”
Tomi Engdahl says:
Software: The Most Essential Part of Hardware Design
https://www.mentor.com/embedded-software/events/software–the-most-essential-part-of-hardware-design?mid=15254983&PC=L&c=2018_04_26_esd_newsletter_update_apr_2018
Designing a hardware architecture is difficult, requiring a complex balance among functionality, resources, and timing. Because an abstract architecture is of little value until it has a physical implementation, hardware architects tend to be more immersed in the details how things are done and less focused around what things are done. While virtually everyone agrees that the right way to do hardware design is in conjunction with software, few manage to successfully surmount the language and cultural hurdles involved in a joint development process. Computer graveyards are littered with the careers and prototypes of hardware architects who were unable to successfully incorporate software in the hardware design process.
Tomi Engdahl says:
How to Achieve Low-Cost, Advanced Security For Your Embedded System
http://www.electronicdesign.com/embedded-revolution/how-achieve-low-cost-advanced-security-your-embedded-system?code=NN8DK004&utm_rid=CPG05000002750211&utm_campaign=17027&utm_medium=email&elq2=adb98e6ec77646f683537bfeb28da18d
The availability of low-cost processing power plus ubiquitous connectivity have spurred the rise of the Internet of Things (IoT) and the development of large-scale embedded applications that rely on networks of smart nodes. A smart node in an embedded system typically consists of one or more sensors, a microcontroller, and a wired or wireless connection. Examples are found in almost every IoT application: the electrical grid, the home, the doctor’s office, the factory floor, the automobile are just a few.
As embedded systems proliferate, so have concerns about their security, fueled by well-publicized stories about data breaches, viruses, botnets, trojan horses and the like. The results of an embedded-system security breach can range from inconvenient to life-threatening: video cameras, home routers, cars, drug-delivery systems, and even pacemakers have been hacked.
Sponsored By Digi-Key and Maxim Integrated: Implementing and maintaining security in an embedded system requires a multi-faceted approach that involves both software and specialized hardware.
Tomi Engdahl says:
Partitioning Becomes More Difficult
https://semiengineering.com/partitioning-becomes-more-difficult/
Exploding gate counts, multiple domains, and hardware/software content are making it tougher to verify that designs will work as planned.
Tomi Engdahl says:
R00ZZ0008EU0100-synergy
Renesas Synergy™Software Package(SSP) Redefines Software Development for the IoT Market
https://www.renesas.com/en-us/doc/products/renesas-synergy/doc/r00zz0008eu0100-synergy.pdf?ls=email&cid=em_nws_s3a1_eew_00002
Tomi Engdahl says:
Tech Talk: HW Security
https://semiengineering.com/tech-talk-hw-security/
How to minimize the risk of hardware attacks in the shadow of Meltdown and Spectre.
Rambus’ Ben Levine explains how to minimize the risk of attacks on chip hardware, why design for security is becoming more critical for connected devices, and strategies for making devices less vulnerable.
Tomi Engdahl says:
Designing Hardware For Security
https://semiengineering.com/designing-hardware-for-security/
Most attacks in the past focused gaining access to software, but Meltdown and Spectre have changed that forever.
Tomi Engdahl says:
How To Build Functional Safety Into Your Design From The Start
https://semiengineering.com/how-to-build-functional-safety-into-your-design-from-the-start/
Accelerating time to market in safety-critical markets.
The focus on functional safety IP is rapidly growing and we’re seeing this growth not just in automotive but in many other markets including, avionics, medical, industrial and railways, where systems need to efficiently identify and mitigate the occurrences of faults, and where more confidence is required with respect to the design practises employed for the development of IP.
Currently, many processors are not designed with functional safety standards in mind and the use of these can lead to lengthy and costly qualification processes for safety relevant applications.
Building a robust functional safety process
When designing functional safety related products, one must follow the so-called product life-cycle process. Such a process is often far more structured and formal compared to other standard development processes.
Tomi Engdahl says:
14 Operating Systems of Interest for Embedded Systems
https://www.eeweb.com/profile/kumarb/articles/14-operating-systems-you-need-to-use-for-embedded-system
Today, there are many operating systems that are competing with each other. Moreover, many of them are becoming open-source and available for free, thereby allowing users and developers to build robust products.
Conclusion
Today’s operating systems are enriched with better RTOS services and multitasking capabilities. The reason behind using an OS in a small scale embedded system or generic device is to achieve real-time functionality and to add power to the user interface.
Many open-source operating systems exist with Linux, and these are becoming the favorite for many developers.
Tomi Engdahl says:
Tech Talk: Traceability In Functional Safety
https://semiengineering.com/tech-talk-traceability-in-functional-safety/
Regulations, standards and liability.
Dominik Strasser, vice president of engineering at OneSpin Solutions, talks about the impact of functional safety regulations on liability and traceability in automotive, rail, industrial, nuclear and machinery applications.
Tomi Engdahl says:
New MIPI System Software Trace (MIPI SyS-T)
https://www.eeweb.com/profile/eeweb/news/new-mipi-system-software-trace-mipi-sys-t
The MIPI® Alliance released the MIPI System Software Trace (MIPI SyS-T), a common data format for transmitting software trace and debug information between a test system and a device, such as a system-on-chip (SoC) or platform. The specification is publicly available to developers, and an accompanying example implementation library is accessible via GitHub.
Until now, available methods have been vendor-specific or based on major operating systems and there has been no independent format for exchanging debug information across software, firmware or hardware implementations. This fragmentation has been challenging for developers because devices typically incorporate software and components from different vendors, which increases debugging complexity and drives up development costs.
“MIPI SyS-T addresses a very real need in the debug and test industry for a universal data format that alleviates fragmentation and provides a convenient, vendor- and OS-agnostic solution for developers across the embedded software ecosystem,” said Joel Huloux, chairman of MIPI Alliance.
Tomi Engdahl says:
IAR Systems with Updated Design and Code Generation Tool
https://www.eeweb.com/profile/eeweb/news/iar-systems-with-updated-design-and-code-generation-tool
IAR Systems® has launched version 9.1 of the graphical modeling tool IAR Visual State®. The new version further speeds up and simplifies development when working in teams.
The design and code generation tool IAR Visual State helps developers bring order to their designs and speed up their projects. It is used to graphically design state machines and generate C/C++ source code. With IAR Visual State, developers can speed up time to prototype and shorten time to market. For efficient team work, smart features for organizing and modularizing the design is available. Because the tool is made for embedded systems, it enables developers to use state machines in an easy and intuitive way.
Tomi Engdahl says:
Secure Boot with ATECC608A
https://www.eeweb.com/profile/microchip/articles/secure-boot-with-atecc608a
This video shows the part one of Microchip’s CryproAuthentication devices Use-Case Series. Learn how to architect a secure boot with Microchip secure element ATECC608A. It offers a strong security implementation by verifying the signed boot image of a small microcontroller with a truly immutable public key kept in the secure element.
https://www.youtube.com/watch?v=cbOuo-wL2Ms
Tomi Engdahl says:
Embedded AI: A Designer’s Guide
https://www.eetimes.com/author.asp?section_id=36&doc_id=1333348
Plenty of resources are becoming available to help engineers explore how to harness the new world of deep learning in their power-constrained designs.
https://www.electronicproducts.com/Robotics/AI/Engineer_s_guide_to_embedded_AI.aspx
Tomi Engdahl says:
It’s UNIX. On A Microcontroller.
https://hackaday.com/2018/06/03/its-unix-on-a-microcontroller/
It’s difficult to convey in an era when a UNIX-like operating system sits in your pocket, how there was once a time when the mere word was enough to convey an aura of immense computing power. If you ran UNIX, your computer probably filled a room, and you used it for Serious Stuff rather than just checking your Twitter feed.
Of course, the UNIX in question is not exactly the same as the one you’d find on a supercomputer, either in the 1970s or now. Mini UNIX is a minimalist version of the operating system developed by [Heinz Lycklama] at Bell Labs four decades ago. It gives you a complete UNIX V6 system for the DEC PDP-11, but which needs only 56K of RAM, and no MMU. Emulating a PDP-11 on an STM32 microcontroller allows it to run happily, and while it’s not the most minimalist of microcontrollers it’s still a pretty cheap part upon which to run UNIX.
MXE11: run UNIX on a microcontroller
http://www.jcwolfram.de/projekte/mxe11_en/main.php
Tomi Engdahl says:
Someone Set us Up the Compiler Bomb
https://hackaday.com/2018/06/03/someone-set-us-up-the-compiler-bomb/
We aren’t sure what practical use this would have, but it did illustrate a few interesting points. First, the code itself is simple
To us, this seems less of an exploit as a strange bug in the linker. The reason it works is that the compiler runs out of memory during the link phase.
How to dismantle a compiler bomb
https://codeexplainer.wordpress.com/2018/01/20/how-dismantle-compiler-bomb/
the source code is only 14 bytes, but the generated executable will be over 16 GB in size.
In the code main is not a function, but an array of ints. The value of -1u, that is, negative one as unsigned, is exactly 0xFFFFFFFF — the maximum value of unsigned int. The array will contain 4294967295 integers, each with the size of four bytes, taking up 17179869180 bytes in total.
The important element of the code is the array initialization — {1}. The first element of the array will be initialized to 1, and all the remaining elements will be set to 0.
Tomi Engdahl says:
IEC 62443: How to Achieve the Highest Levels of Industrial Security
http://www.electronics-know-how.com/article/2669/iec-62443-how-to-achieve-the-highest-levels-of-industrial-security
n recent years, a rising tide of cyber-attacks on industrial systems have threatened safety and reliability. The world has learned that there is no industrial safety without cyber security. And now we must take the next step to improve industrial cybersecurity. Fortunately, an international group of experts have developed a comprehensive standard for industrial security. The IEC 62443 standards have been widely praised for their use of practical but effective countermeasures.
Tomi Engdahl says:
IoT Software Testing: Four Essential Elements
https://www.eetimes.com/author.asp?section_id=36&doc_id=1333359
IoT devices pose a tremendous threat to cybersecurity. Many devices have weak security features and receive insufficient testing.
The global Internet of Things (IoT) market is slated to grow to $8.9 trillion by 2020. IoT segments in the B2B sector alone will generate more than $300 billion annually by 2020, according to Bain & Company. These figures attest to IoT’s enormous potential —– and with more than 11 billion connected things projected to be in use this year, that potential is already being realized.
But the promise of IoT is not without risk. Hackers have exploited connected devices to mine cryptocurrency and launch high-profile cyberattacks, fostering public distrust and generating regulatory scrutiny that could ensnare a wide range of stakeholders. Amid this climate, it has never been more essential to ensure the proper testing of IoT devices.
Often combining new technology with rapidly developed software on newly created hardware, IoT devices can be difficult to test, and the means by which these devices are developed can expose them to critical bugs undermining functionality, interoperability, reliability, safety, and performance. Here are the four most important aspects to avoiding disaster and enabling IoT to securely fulfill its potential.
Interoperability testing
Software systems’ ability to communicate, exchange, and apply information — their interoperability — is at the heart of IoT. When testing interoperability, testers check syntax and data format compatibility, physical and logical connection methods, and user-friendliness. Software programs must be able to route data back and forth without compromising the device’s operation or losing data. Each component of the software must therefore recognize incoming data from other programs, seamlessly integrate with the larger architecture, and provide users with readily accessible, useful results. Real-world crowd testing and advanced lab testing are both valuable tools for testing interoperability, allowing testers to test both real devices and in a controlled, simulated network environment.
Automated test
Companies are delivering software-based services, products, updates, and patches at an ever-accelerating rate, and factors such as time-to-market can make or break a company. Test automation is crucial to both a company’s continued, fast-paced operations and time-to-market, making it not a nice bonus but rather an absolute necessity.
DevOps, in which a core focus is improving time-to-market, is inseparable from test automation.
End-to-end testing
Finally, ensuring a system’s integrity requires end-to-end testing. The multiple subsystems that comprise a software system must all function properly, lest the entire system risk failure. End-to-end testing verifies a system’s functionality and the proper communication of its sub-systems, which makes this process essential to understanding how well an application will function.
Tomi Engdahl says:
Replace Fixed-Function ICs with Low-Cost Microcontrollers
http://www.electronicdesign.com/analog/replace-fixed-function-ics-low-cost-microcontrollers?NL=ED-003&Issue=ED-003_20180607_ED-003_206&sfvc4enews=42&cl=article_1_b&utm_rid=CPG05000002750211&utm_campaign=17775&utm_medium=email&elq2=7063732c536541d8a6d2a14c6163d24d
Sponsored by Texas Instruments: For about 25 cents, you can implement many simple analog and digital functions into applications ranging from pulse-width modulation to a stopwatch.
Most engineers have known for years that microcontrollers are the best choice in building new digital products. Legacy TTL and CMOS functional logic devices gave way to single-chip MCUs years ago. Yet some operations are still implemented with fixed-function devices because an MCU seems like expensive overkill in certain cases. Not anymore, though. When the price for a tiny MCU comes down to pennies, it’s time to reconsider the use of fixed-function circuits. Here are some ideas to help you go in that direction.
A cheap MCU can replace more discrete logic and mixed-signal devices than you think. One example is a two-bit 8-bit microcontroller that’s able to replace the still popular 555 timer IC. But that’s not all. There are four basic areas where an inexpensive MCU can replace a fixed-function device: communications, system housekeeping, pulse-width modulation (PWM), and timing. The examples illustrate how it can be done.
Tomi Engdahl says:
Embedded AI: A Designer’s Guide
https://www.eetimes.com/author.asp?section_id=36&doc_id=1333348
https://www.electronicproducts.com/Robotics/AI/Engineer_s_guide_to_embedded_AI.aspx
Tomi Engdahl says:
STM8 eForth Wireless Sensor
Just because everyone else is doing it with C doesn’t make it right
https://hackaday.io/project/158459-stm8-eforth-wireless-sensor
Tomi Engdahl says:
Splitting hairs: When is a flash file system not a flash file system?
https://www.datalight.com/blog/2018/06/13/splitting-hairs-flash-file-system/
To be clear, a flash file system is not just a file system that happens to write to and read from flash memory-based media, like SD cards, eMMC, or UFS. A file system’s fundamental job is to organize and manage data that is created and used by one or more applications in a system. It also keeps track of access times and sometimes grants or denies permission based on security settings. The organizational structure used by different file systems can be quite complex and features such as those required to ensure data and structural integrity can be present or not.
In contrast, a flash file system, like JFFS2 and UBIFS, has additional capabilities that are specifically required by the underlying flash-memory based storage device. A true flash file system must contain functionality to address the specific requirements of flash memory: such as tracking the erase count and actively shifting data around to ensure even wear (wear-leveling), detecting and correcting errors (EDC), tracking and scrubbing bad blocks (BBM), and handling read and write disturb. These complex functions cannot be ignored. On eMMC, SD, and UFS (managed flash), internal firmware handles those details and the complexity of making the flash function properly, in effect insulating the file system from it.
Tomi Engdahl says:
Linux kernel 4.17 is great for embedded designs
https://www.datalight.com/blog/2018/06/13/linux-kernel-4.17-released/
Last weekend, Linux kernel 4.17 was released, disappointing a few pundits who thought it should be kernel 5.0. Here are some of the exciting features in this release, and confirmation of something Datalight has always said.
Initial support for newer power efficiency features is probably one of the most exciting directions for embedded designs. Another serious improvement for embedded is significant power-savings for idle systems on some hardware, around 10% on affected systems. A lot of dead architecture was removed – half a million lines of code! – which is great news for anyone with concerns over untested code in the kernel.
Probably the biggest inclusion is a removal – UBIFS will now outright refuse to work with MLC NAND flash.
“While UBI and UBIFS seem to work at first sight with MLC NAND, you will most likely lose all your data upon a power-cut or due to read/write disturb.” [1] This very much confirms our assertion that MLC NAND flash is not easy, even if it is inexpensive.
Tomi Engdahl says:
8 Bit or 32 Bit? Choosing Your Next Design’s MCU
http://www.electronicdesign.com/microcontrollers/8-bit-or-32-bit-choosing-your-next-design-s-mcu?PK=UM_Classics06218&elqTrackId=cf5c060def1a4584b9c9ce4b9157f69e&elq=f6023f595e514c55afd0d8ce699996a3&elqaid=17792&elqat=1&elqCampaignId=14976&utm_rid=CPG05000002750211&utm_campaign=17792&utm_medium=email&elq2=f6023f595e514c55afd0d8ce699996a3
Though the popularity of 32-bit MCU devices continues to rise across the embedded community, recent MCU market trends reveal that 8-bit MCUs show a compound growth rate close to that of their 32-bit cousins.
The rise in popularity of 32-bit microcontroller (MCU) devices across the embedded community comes as no surprise. These function-rich devices suit an array of different applications, which explains why many embedded developers select them for their next designs. Designers recognize that such complex devices offer everything they need in terms of raw compute power, a rich peripheral set, and easy access to a wide range of development tools and libraries.
Many of these 32-bit devices are based on the highly successful ARM cores.
However, taking a closer look at recent MCU market trends reveals that 32-bit devices aren’t the only ones experiencing strong growth (Table 1). The surging 8-bit MCU market boasts a compound growth rate (6.4%) close to that of 32 bit (6.9%).
The upswing in 8-bit devices clearly highlights that there must be some compelling reasons to use an 8-bit device in place of a 32-bit MCU.
Essential Differences
The principle differences between 8- and 32-bit MCUs are cost and price structure, CPU performance, ease of use, efficiency in hardware near functions, and static power consumption. When embarking on a new design, developers need to carefully scope out the requirements for an MCU based on the amount of processing capability required, the degree of interfacing needed, and, for battery-powered designs, the all-important power consumption profiles. There’s no doubt that a 32-bit MCU delivers higher performance than an 8-bit device, but the engineer faces the traditional decision of choosing between the best available device in the market versus an application’s actual needs.
With a lower gate count, a less complex 8-bit device will certainly be cheaper than a 32-bit device.
8-bit devices typically cost about 20% less
MCU suppliers tend to add more features and functionality to their 32-bit devices as opposed to 8-bit products. Consequently, far more setup considerations emerge with a more complex device.
Such a setup can be much simpler with an 8-bit MCU
The architecture is also much more straightforward than a 32-bit device with internal registers, peripherals, and SRAM all mapped on the same data bus.
Many modern microcontrollers incorporate some hardware functions that serve to help the CPU operate as efficiently as possible.
saying 1.5 to 3 times more SRAM is needed for the same 8-bit-centric application on a 32-bit (versus a native 8-bit) device is a fair estimation.
No MCU article would be complete without investigating static power consumption. This alone may be a key factor in choosing between an 8- or 32-bit device, especially for battery-powered applications.
Conclusion
Contemplating whether to use an 8- or 32-bit microcontroller for a future design may involve an Internet of things (IoT) application. How IoT actually takes shape provokes lots of debate, but it will certainly challenge engineers to make a detailed appraisal of the MCU requirement. Wireless connectivity, especially ZigBee, will also be an essential component, but that doesn’t automatically mean that it will need a higher power device.
Tomi Engdahl says:
More handy embedded software tips
https://www.mentor.com/embedded-software/blog/post/more-handy-embedded-software-tips-fc5ccfc5-9cd8-485c-acc4-ad36a2f29ad0?cmpid=10168
Tomi Engdahl says:
Silexica Raises $18 Million to Smooth Over Programming Changes in Cars
http://www.electronicdesign.com/embedded-revolution/silexica-raises-18-million-smooth-over-programming-changes-cars?NL=ED-004&Issue=ED-
004_20180628_ED-
004_906&sfvc4enews=42&cl=article_2_b&utm_rid=CPG05000002750211&utm_campaign=18231&utm_medium=email&elq2=18e73a93c6b3467b87fce3431dee2646
Almost two decades after multicore processors were introduced to restart advances in computer speed, multicore programming is still
devilishly difficult. But the Cologne, Germany-based startup Silexica has developed software tools that are basically multicore
compilers to make things easier. And the company on Thursday raised $18 million from investors to fund additional work on its software.
Tomi Engdahl says:
Agile Planning and DevOps Methodologies for Embedded Design
https://www.eeweb.com/profile/chuckgehman/articles/agile-planning-and-devops-methodologies-for-embedded-design
Long-established for code repositories, version control systems are now increasingly used across all file types and across the entire lifecycle of an asset.
All this has put the spotlight on how to best manage all the elements involved in an electronic design project, across all types of digital assets, systems, platforms, networks and contributors. We asked some of our customers and partners involved in embedded, chipset, IoT and electronics design what they consider to be ‘best practice’ in development today. We received inputs from ADTRAN, MathWorks, Methodics, Woodward, and u-blox.
Some common themes emerge, particularly the need to address scale and flexibility, not just now but for the future, which can be hard to predict. Component-based development, Agile, DevOps, IP re-use, and model-based design are all cited, alongside increased dependency on version control as a ‘single source of truth’ across the entire lifecycle of an asset. The combination of the right tools and the right culture is critical too.
Tomi Engdahl says:
http://www.etn.fi/index.php/13-news/8169-moniydinsuorittimet-tulevat-lentokoneisiin
Tomi Engdahl says:
4 Reasons Embedded Developers Should Avoid Cloned Hardware
https://www.eeweb.com/profile/beningo/articles/4-reasons-embedded-developers-should-avoid-cloned-hardware
Tomi Engdahl says:
top 5 considerations:
Does the design need an operating system at all?
Why is a custom implementation rarely a wise choice?
RTOS or Linux?
How do you compare the performance of different RTOS products? Data sheets are not enough!
What about multi-core? How does this impact your selection
Tomi Engdahl says:
MCU Metamorphosis—Adding Analog Circuits On-Chip
https://www.electronicdesign.com/analog/mcu-metamorphosis-adding-analog-circuits-chip?code=NN6TI114&utm_rid=CPG05000002750211&utm_campaign=18695&utm_medium=email&elq2=896728db9cf84714bd6442d8e80eafdf
Sponsored by Texas Instruments: Putting selectable linear interface circuits on the same chip with an MCU greatly simplifies many sensing and measuring designs.