Archive

Posts Tagged ‘open source’

Open Surgery Initiative Aims to Build DIY Surgical Robots

February 7th, 2017 No comments

Medical equipments can be really expensive because of the R&D involved and resulting patents, low manufacturing volume, government regulations, and so on. Developed countries can normally afford those higher costs, but for many it may just be prohibitively expensive. The Open Surgery initiative aims to mitigate the costs by “investigating whether building DIY surgical robots, outside the scope of healthcare regulations, could plausibly provide an accessible alternative to the costly professional healthcare services worldwide”.

DIY Surgical Robot – Click to Enlarge

The project is composed of member from the medical, software, hardware, and 3D printing communities, is not intended for (commercial) application, and currently serves only academic purposes.

Commercial surgical robots can cost up to $2,000,000, but brings benefits like smaller incisions, reduced risks of complications and readmissions, and shorter hospital stays thanks to a faster recovery process. There have already been several attempts within the robotics community to come up with cheaper and more portable surgical robots, such as RAVEN II Surgical robot initially developed with funding from the US military to create a portable telesurgery device for battlefield operations, and valued at $200,000. The software used to control RAVEN II has been made open source, so other people can improve on it.

The system is currently only used by researchers in universities to experiment with robotic surgery, but it can’t be used on humans, as it lacks the required safety and quality control systems. This is a step in the right direction, but the price makes it still out of reach for most medical hacker communities, so Frank Kolkman, who setup the Open Surgery initiative, has been trying to build a DIY surgical robot for around $5000 by using as many off-the-shelf parts and prototyping techniques such as laser cutting and 3D printing for several months with the help of the community.

Three major challenges to designing a surgical robot (theoretically) capable of performing laparoscopic surgery have been identified:

  1. The number and size of tools: during a single operation a surgeon would switch between various types of tools, so a robot would either have to have many of them or they should be able to be interchangeable. The instruments are also extremely small, and difficult to make
  2. Anything that comes into contact with the human body has to be sterile to reduce the risk of infection, and most existing tools are made of stainless steel so that they can be sterilized by placing them in an autoclave, that may not be easily accessible to many people.
  3. The type of motion a surgical robot should be able to make, whereby a fixed point of rotation in space is created where the tool enters the body through an entry port – or ‘trocar’. The trocar needs to be stationary so as to avoid tissue damage.

He solved the first  issue by finding laporoscopic instruments on Alibaba, as well as camera, CO2 insufflation pumps, and others items. For the second hurdle, he realized a domestic oven turned to 160 degrees centigrade for 4 hours could be an alternative to an autoclave. The mechanical design was the most complicated, as it required many iterations, and he ended with some 3D printed parts, and DC servo motors. Software was written using Processing open source scripting language. You can see the results in the short video below.

While attempting surgery with the design would not be recommended just yet, a $5,000 DIY surgical robot appears to feasible. Maybe it could be evaluated by one or more trained surgeons first, and then tested on animals that needs surgery, before eventually & potentially being used on human, who would not get the treatment otherwise.

While there’s “Open” in “Open Surgery” and the initial intent was to make the project open source, it turned out it is almost impossible to design surgical robots without infringing on patents. That’s no problem as long as you make parts for private use, however Frank explains that sharing files could cause problems, and the legality of doing so requires some more research.

Olimex Teres I A64 DIY Open Source Hardware Laptop Kit Design Complete, To Sell for 225 Euros

February 2nd, 2017 21 comments

Olimex has been working on an open source hardware Olimex A64 laptop for a little over a year, and the company has now complete thed hardware design of their TERES I laptop, and are working on finalizing the software design before accepting orders for 225 Euros for TERES-A64-BLACK and TERES-A64-WHITE models.

As explained in the instructions manual, Olimex laptop will not be sold assembled, but as a kit to let the users assemble the following parts themselves:

  • TERES-006-Keyboard QWERTY keyboard
  • TERES-023-Touch touchpad with TERES-022-Touch-Cover and TERES-010-Touch-Btns
  • TERES-014-Screw-Set with 42 pieces of different kind of screws.
  • TERES-PCB3-Touch PCB
  • TERES-PCB2-IO PCB with headphone jack, micro SD slot, and a USB port
  • TERES-PCB4-Btn PCB for the power button together with TERES-009-Pwr-Btn plastic and TERES-013-LED-pipe
  • TERES-PCB1-A64 motherboard based on Allwinner A64 processor.
  • TERES-PCB5-KEYBOARD keyboard control board
  • Display parts: TERES-008-LCD-Back, TERES-016-Hinge-Set, TERES-007-LCD-Frame, and TERES-015-LCD 11.6″ LCD panel
  • TERES-019-Camera & TERES-020-Camera-Lens for the webcam
  • Speakers, battery,WiFi antenna, and a few flat cables to connect all the boards together

Click to Enlarge

That’s quite a lot of parts, but the instructions are clear enough, and you and/or your kid) will have bragging rights to say “I’ve made my own laptop!” wchich should have the following specifications:

  • SoC – Allwinner A64 quad core ARM Cortex-A53 processor @ 1.2 GHz with Mali-400MP2 GPU
  • System Memory – 1GB DDR3L
  • Storage – 4GB eMMC Flash, micro SD slot
  • Display – 11.6″ 1366×768 pixels display
  • Video Output – 1x mini HDMI 1.4 port
  • Audio – Via mini HDMI, 3.5mm audio jack, 2x speakers, microphone
  • Connectivity – 802.11 b/g/n WiFi up to 150Mbps, Bluetooth 4.0 LE
  • USB – 2x USB port ports
  • Front camera
  • QWERTY keyboard + touchpad with 2 buttons
  • Battery – 7,000mAh capacity
  • Weight – 980 grams

You’re not quite done yet, as you still have to flash the firmware/operating system – either Android or Linux – on a micro SD, in order to boot the laptop. Software and hardware documentation is available in github. The software currently includes ARM trusted firmware, u-boot, the Linux kernel and device tree files with more common soon. The hardware has been designed with KiCAD open source EDA software, and if you want to change or improve one of the boards in the design, you can do so, as the source schematics and PCB layout are there for everyone to study and/or modify. If you don’t want to modify anything, but would like to have access to spare parts, you will be able to buy them instead.

eMMC, Audio, T-Card section of the Schematics – Click to Enlarge

If you go FOSDEM 2017, you’ll have opportunity to check out the laptop yourself since Olimex will be there.

$79 Digilent OpenScope Open Source Multi-function Programmable Instrument Works over USB and WiFi (Crowdfunding)

February 1st, 2017 7 comments

Digilent OpenScope is an open source, portable, multi-function programmable instrument used for capturing, visualizing, and controlling analog and digital signals, that works with your smartphone or computer over USB or WiFi, and it can also be used in standalone mode as a development board, like you would use an Arduino or Raspberry Pi board.

OpenScope MZ key features and specifications:

  • MCU – Microchip PIC32 MZ (MZ2048EFG124) MIPS Warrior M-class micro-controller @ up to 200 MHz with 2048KB flash, 512 KB RAM
  • External Storage – micro SD slot
  • Wireless Connectivity – WiFi module
  • USB – 1x micro USB for power and programming over FTDI
  • Programming / Debugging – micro USB port, programming header
  • Expansion – 30-pin Fly Wire connector with:
    • 2x scope channels with 12 bits @ 2 MHz bandwidth and up to 6.25MS/s sampling rate
    • 1x function generator output with 1 MHz bandwidth and up to 10MS/s update rate
    • 10x user programmable DIO pins up to 25 MHz update rate
  • Misc – 4x user LEDs, programming and reset buttons
  • Power Supply – via micro USB or ext pin; programmable power supplies up to 50 mA and +/- 4V

The platform can be used with (soon-to-be) open source, web based Waveforms Live multi-instrument software written in JavaScript and allowing you to  use OpenScope as an oscilloscope, a function generator, a logic analyzer, a power supply, or a data logger.

Since the software runs in a web browser it will work with most operating systems including Linux, Windows, Mac OS X, Android or iOS. As mentioned in the introduction, OpenScope is also a development board, and can be programmed using the Arduino IDE or Microchip MPLAB-X IDE. The company will provide  a programmer’s guide, and make PIC32MZ firmware, the agent source code, the browser app for Android & IOS, the communication protocol, and the JavaScript API available on Github

Digilent launched OpenScope on Kickstarter, where the board can be backed together with a 3D printed enclosure for $79. An “OpenScope Learning Edition” is also offered for $150 with a “parts kit with workbook example”, but no details have been provided for the latter. Delivery is planned for June or August 2017 depending on selected reward, and shipping is free to the US, but adds $20 to the rest of the world.

FOSDEM 2017 Open Source Meeting Schedule

January 31st, 2017 4 comments

FOSDEM (Free and Open Source Software Developers’ European Meeting) is a 2-day free event for software developers to meet, share ideas and collaborate that happens on the first week-end of February, meaning it will take place on February 4 & 5, 2017 this year. FOSDEM 2017 will features 608 speakers, 653 events, and 54 tracks, with 6 main tracks namely: Architectures, Building, Cloud, Documentation, Miscellaneous, and Security & Encryption.
I won’t be there, but it’s always interesting to look at the schedule, and I made my own virtual schedule focusing especially on talks from “Embedded, mobile and automotive” and “Internet of Things” devrooms.

Saturday 4, 2017

  • 11:00 – 11:25 – Does your coffee machine speaks Bocce; Teach your IoT thing to speak Modbus and it will not stop talking, by Yaacov Zamir

There are many IoT dashboards out on the web, most will require network connection to a server far far away, and use non standard protocols. We will show how to combine free software tools and protocols from the worlds of IT monitoring, Industrial control and IoT to create simple yet robust dashboards.

Modbus is a serial communication protocol developed in 1979 for use with programmable logic controllers (PLCs). In simple terms, it is a method used for transmitting information over serial lines between electronic devices., it’s openly published, royalty-free, simple and robust.

Many industrial controllers can speak Modbus, we can also teach “hobby” devices like Arduino boards and ESP8266 to speak Modbus. Reliable, robust and simple free software Modbus client will be used to acquire the metrics from our device, then the metrics will be collected and sent to Hawkular and Grafana to store and visualize our data.

  • 11:30 – 11:55 – Playing with the lights; Control LIFX WiFi-enabled light bulbs, by Louis Opter

In this talk we’ll take a close look at a one of the “smart” (WiFi-connected) light-bulbs available on the market today. The bulbs expose a small API over UDP that I used to run an interface on a programmable buttons array. We will see how topics like reverse engineering, security, licensing, “self-hosting” and user experience came into play.

monolight is an user interface to control LIFX WiFi-enabled light bulbs. monolight runs on a programmable button array; it is written in Python 3.6 (to have type annotations and asyncio), and it interfaces with the bulbs through a more complex daemon written in C: lightsd.

This talk will start with a live demo of the button grid remotely controlling the light bulbs. We will then explore how it works and some of the motivations behind it (network isolation, trying to not depend on the “cloud”, reliability, user-experience). Finally, we will look into what kind of opportunities even more open IoT products could bring, and open leave the place to Q&A and discussion.

  • 12:00 – 12:30 – Creating the open connected car with GENIVI, by Zeeshan Ali, GENIVI Development Platform (GDP) technical lead

A number of new components have matured in GENIVI to provide a true connected car experience. A couple of them are key connectivity components; namely SOTA (Software Over the Air) and RVI (Remote Vehicle Interface). This talk will discuss both these components, how they work together, the security work done on them and their integration into the GENIVI Development Platform.

This talk will also run down the overall status of GENIVI’s development platform and how it can enable an automotive stack to speak not just with the cloud, but with IoT devices via Iotivity interface.

  • 12:30 – 13:00 – Making Your Own Open Source Raspberry Pi HAT; A Story About Open Source Harware and Open Source Software, by Leon Anavi

This presentation will provide guidelines how to create an open source hardware add-on board for the most popular single board computer Raspberry Pi using free and open source tools from scratch. Specifications of Raspberry Pi Foundation for HAT (Hardware Attached on Top) will be revealed in details. Leon Anavi has been developing an open source Raspberry Pi HAT for IoT for more than a year and now he will share his experience, including the common mistakes for a software engineer getting involved in hardware design and manufacturing. The presentation is appropriate for anyone interested in building entirely open source products that feature open source hardware and open source software. No previous experience or hardware knowledge is required. The main audience are developers, hobbyists, makers, and students. Hopefully the presentation will encourage them to grab a soldering iron and start prototyping their DIY open source device.

  • 13:00 – 13:25 – Building distributed systems with Msgflo; Flow-based-programming over message queues, by Jon Nordby

MsgFlo is a tool to build systems that span multiple processes and devices, for instance IoT sensor networks. Each device acts as a black-box component with input and output ports, mapped to MQTT message queues. One then constructs a system by binding the queues of the components together. Focus on components exchanging data gives good composability and testability, both important in IoT. We will program a system with MsgFlo using Flowhub, a visual live-programming IDE, and test using fbp-spec.

In MsgFlo each process/device is an independent participant, receiving data on input queues, and sending data on output queues. A participant do not know where the data comes from, nor where (if anywhere) the data will go. This strong encapsulation gives good composability and testability. MsgFlo uses a standard message queue protocol (MQTT or AMQP). This makes it easy to use with existing software. As each participant is its own process and communicate over networks, they can be implemented in any programming language. Convenience libraries exist for C++, Python, Arduino, Node.js and Rust. On top of the message queue protocol, a simple discovery mechanism is added. For existing devices without native Msgflo support, the discovery messages can be sent by a dedicated tool.

  • 13:30 – 13:55 – 6LoWPAN in picoTCP, and how to support new Link Layer types, by Jelle De Vleeschouwer

6LoWPAN enables, as the name implies, IPv6-communication over Low-power Wireless Personal Area Networks, e.g. IEEE802.15.4. A lot of resources are available to allow 6LoWPAN over IEEE802.15.4, but how can one extend the 6LoWPAN feature-set for the use with other link layer types? This talk will cover the details about a generic implementation that should work with every link layer type and how one can provide support for ones own custom wireless network. The goal is to give quite a technical and detailed talk with finally a discussion about when 6LoWPAN is actually useful and when is it not.

Last year, as a summer project, a generic 6LoWPAN adaption layer was implemented into picoTCP, an open source embedded TCP/IP-stack developed by Altran Intelligent Systems, with an eye on the IoT. The layer should also be able to allow multiple link-layer extensions, for post-network-layer processing. This could be used for mesh-under routing, link layer security, whatever you want. This talk will cover how one can take advantage of these features and caveats that come with it.

  • 14:00 – 15:00 – Groking the Linux SPI Subsystem by Matt Porter

The Serial Peripheral Interconnect (SPI) bus is a ubiquitous de facto standard found in many embedded systems produced today. The Linux kernel has long supported this bus via a comprehensive framework which supports both SPI master and slave devices. The session will explore the abstractions that the framework provides to expose this hardware to both kernel and userspace clients. The talk will cover which classes of hardware supported and use cases outside the scope of the subsystem today. In addition, we will discuss subtle features of the SPI subsystem that may be used to satisfy hardware and performance requirements in an embedded Linux system.

  • 15:00 – 15:25 – Frosted Embedded POSIX OS; a free POSIX OS for Cortex-M embedded systems, by Brabo Silvius

FROSTED is an acronym that means “FRee Operating System for Tiny Embedded Devices”. The goal of this project is to provide a free kernel for embedded systems, which exposes a POSIX-compliant system call API. In this talk I aim to explain why we started this project, the approach we took to separate the kernel and user-space on Cortex-M CPU’s without MMU, and showcase the latest improvements on networking and supported applications.

  • 15:30 – 16:00 – How to Build an Open Source Embedded Video Player, by Michael Tretter

Video playback for embedded devices such as infotainment systems and media centers demands hardware accelerators to achieve reasonable performance. Unfortunately, vendors provide the drivers for the accelerators only as binary blobs. We demonstrate how we built a video playback system that uses hardware acceleration on i.MX6 by using solely open source software including Gstreamer, Qt QML, the etnaviv GPU driver, and the coda video decoder driver.

The Qt application receives the video streams from a Gstreamer pipeline (using playbin). The Gstreamer pipeline contains a v4l2 decoder element, which uses the coda v4l2 driver for the CODA 960 video encoder and decoder IP core (VPU in the Freescale/NXP Reference Manual), and a sink element to make the frames available to the Qt application. The entire pipeline including the Gstreamer to Qt handover uses dma_bufs to avoid copies in software.This example shows how to use open source drivers to ease the development of video and graphics applications on embedded systems.

  • 16:00 – 16:25 – Project Lighthouse: a low-cost device to help blind people live independently, by David Teller

The Word Health Organization estimates that more than 250 million people suffer from vision impairment, 36 millions of them being entirely blind. In many cases, their impairment prevents them from living independently. To complicate things further, about 90% of them are estimated to live in low-income situations.

Project Lighthouse was started by Mozilla to try and find low-cost technological solutions that can help vision-impaired people live and function on their own. To this date, we have produced several prototypes designed to aid users in a variety of situations. Let’s look at some of them. This will be a relatively low-tech presentation.

  • 16:30 – 16:55 – Scientific MicroPython for Microcontrollers and IoT, IoT programming with Python, by Roberto Colistete Jr

MicroPython is a implementation of Python 3 optimised to run on a microcontroller, created in 2013 by the Physicist Damien P. George. The MicroPython boards runs MicroPython on the bare metal and gives a low-level Python operating system running interactive prompt or scripts.

The MicroPython boards currently use 32 bit microcontrollers clocked at MHz and with RAM limited to tens or hundreds of Kbytes. These are the microcontroller boards with official MicroPython support currently in the beginning 2017 : Pyboard, Pyboard Lite, WiPy 1/2, ESP8266, BBC Micro:bit, LoPy, SiPy, FiPy. They cost between USD3-40, are very small and light, about some to tens of mm in each dimension and about 5-10 g, have low power consumption, so MicroPython boards are affordable and can be embedded in almost anything, almost anywhere.

Some hints will be given to the FOSS community to be open minded about MicroPython : be aware that MicroPython exists, MicroPython is a better programming option than Arduino in many ways, MicroPython boards are available and affordable, porting more Python 3 scientific modules to MicroPython, MicroPython combines well with IoT.

  • 17:00 – 17:25 – Iotivity from devices to cloud; how to make IoT ideas to real using FLOSS, by Philippe Coval & Ziran Sun (Samsung)

The OCF/IoTivity project aims to answer interoperability issues in the IoT world from many different contexts to accommodate a huge range devices from microcontrollers, to consumer electronics such as Tizen wearables or your powerful GNU/Linux system The vision of Iotivity is not restricted to ad hoc environment but also can be connected to Internet and make the service easily accessible by other parties. With cloud access in place, usage scenarios for IoT devices can be enriched immensely.

In this talk we walk through the steps on how to practically handle IoT use cases that tailored towards various topologies. To introduce the approach used in IoTivity, we first give a detailed background introduction on IoTivity framework. Then we will present a demo that shows a few examples, from setting up a basic smart home network to accessing the IoT resource via a third party online service. Challenges and solutions will be addressed from development and implementation aspects for each step of the demo.

We hope this talk will inspire developers to create new IoT prototypes using FLOSS.

  • 17:30 – 17:55 – Open Smart Grid Platform presentation, an Open source IoT platform for large infrastructures, by Jonas van den Bogaard

The Open Smart Grid Platform is an open source IoT platform. The open smart grid platform is a generic IoT platform, built for organizations that manage and/or control large-scale infrastructures. The following use cases are now readily available: smart lighting, smart metering, tariff switching, and microgrids. Furthermore the following use-cases are in development: distribution automation, load management and smart device management. The architecture of the open smart grid platform is modular and consists multiple layers.

The open smart grid platform is highly unique for embracing the open source approach and the following key features:

  • Suitable for scalable environments delivering high performance
  • High availability and multitenant architectures
  • Built with security by design and regularly tested.
  • It has a generic architecture. More use cases and domains are easily added to the platform.
  • The open smart grid platform is based on open standards where possible.

We believe the platform is interesting for developers who have interest in working on use-cases for Smart Cities, Utility Companies and other large-scale infrastructure companies.

  • 18:00 – 19:00 – AGL as a generic secured industrial embedded Linux; factory production line controllers requirements are not that special, by Dominig ar Foll

There is no de facto secured embedded Linux distro while the requirement is becoming more and more critical with the rise of IoT in Industrial domains. When looking under the hood of the Yocto built AGL project (Automotive Linux), it is obvious that it can fit 95% of the most common requirements as a Secured Embedded Linux. We will look how non Automotive industries can easily reuse the AGL code and tools to build their own industrial product and why it’s a safer bet than to build it internally.

Industrial IoT cannot be successful without a serious improvement of the security coverage. Unfortunately there is as today, no of-the-shelves offer and the skills required to create such solution, are at best rare, more often out of reach. AGL as created a customizable embedded Linux distro which is nicely designed for reuse in many domains outside of Automotive. During the presentation we will see how to: – start your development with boards readily available on the Net, – change the BSP and add peripherals using Yocto layers or project like MRAA, – integrate a secure boot in your platform, – add your middleware and your application without breaking the maintained Core OS – develop a UI on the integrated screen and/or an HTML remote browser – update the core OS and your add-ons. – get support and influence the project.

Sunday 5, 2017

  • 10:00 11:00 – How I survived to a SoC with a terrible Linux BSP, Working with jurassic vendor kernels, missing pieces and buggy code, by Luca Ceresoli

In this talk Luca will share some of his experiences with such vendor BSPs, featuring jurassic kernels, non-working drivers, non-existing bootloaders, code of appallingly bad quality, ineffective customer support and Windows-only tools. You will discover why he spent weeks in understanding, fixing and working around BSPs instead of just using them. The effects on the final product quality will be described as well. Luca will also discuss what the options are when you face such a BSP, and what both hackers and vendors can do to improve the situation for everybody’s benefit.

  • 11:00-12:00 – Open Source Car Control, by Josh Hartung

This fall my team launched the Open Source Car Control (OSCC) project, a by-wire control kit that makes autonomous vehicle development accessible and collaborative to developers at every level. In this presentation, we discuss the project and its implications on the development of autonomous cars in a vertically integrated and traditionally closed industry.

A primary barrier to entry in autonomous vehicle development is gaining access to a car that can be controlled with an off-the-shelf computer. Purchasing from an integrator can cost upwards of $100K, and DIY endeavors can result in unreliable and unsafe solutions. The OSCC project acts as a solution to these problems. OSCC is a kit of open hardware and software (based on Arduino) that can be used to take control of the throttle, brake, and steering in modern cars. The result is a fully by-wire test car that can be built for about $10K (USD), including the vehicle. In this discussion, we unpack the impetus and development of the OSCC project, challenges we encountered during development, and the role projects like OSCC have in a necessary “flattening” of the automotive industry.

  • 12:00 – 13:00 – Kernel DLC Metrics, Statistic Analysis and Bug-Patterns, by Nicholas Mc Guire

SIL2LinuxMP strives to qualify a defined GNU/Linux subset for the use in safety-related systems by “assessment of non-compliant development”. To demonstrate that the kernel has achieved suitable reliability and correctness properties basic metrics of such properties and their statistic analysis can be used as part of the argument. Linux has a wealth of analytical tools built-in to it which allow to extract information on compliance, robustness of development, as well as basic metrics on complexity or correctness with respect to defined properties. While IEC 61508 Ed 2 always pairs testing and analysis, we believe that for a high complexity system traditional testing is of relatively low effectiveness and analytical methods need to be the primary path. To this ends we outline some approaches taken:

  • Bug-age analysis
  • Bug-rates and trend analysis
  • Code-complexity/bug relationship
  • Brain-dead correctness analysis
  • Interface and type-correctness analysis
  • API compliance analysis
  • Analysis of build-bot data

While much of the data points to robust and mature code there also are some areas where problems popped up. In this talk we outline the used methods and give examples as well as key findings. FLOSS development has reached a quite impressive maturity, to substantially go beyond we think it will need the use of quantitative process and code metrics – these results from SIL2LinuxMP may be a starting point.

  • 13:00 – 14:00 – Loco Positioning: An OpenSource Local Positioning System for robotics, presentation with a demo of autonomous Crazyflie 2.0 quadcopter, by Arnaud Taffanel

Positioning in robotics has alway been a challenge. For outdoor, robots GPS is solving most of the practical problems, but indoor, precise localization is still done using expensive proprietary systems mainly based on an array of cameras.

In this talk, I will present the loco positioning system: an open source Ultra Wide Band radio-based local positioning system, why we need it and how it works. I will also speak about its usage with the Crazyflie 2.0 open source nano quadcopter, of course ending with an autonomous flying demo.

  • 14:00 14:50 – Free Software For The Machine, by Keith Packard

The Machine is a hardware project at Hewlett Packard Enterprise which takes a new look at computer architecture. With many processors and large amounts of directly addressable storage, The Machine program has offered an equally large opportunity for developing new system software. Our team at HPE has spent the better part of two years writing new software and adapting existing software to expose the capabilities of the hardware to application developers.

As directly addressable storage is such a large part of the new hardware, this presentation will focus on a couple of important bits of free software which expose that to applications, including our Librarian File System and Managed Data Structures libraries. Managed Data Structures introduces a new application programming paradigm where the application works directly on the stable storage form for data structures, eliminating serialization and de-serialization operations.

Finally, the presentation will describe how the hardware is managed, from sequencing power to a rack full of high-performance computing hardware, through constructing custom Linux operating systems for each processor and managing all of them as parts of a single computing platform.

  • 15:00 – 15:25 – Diving into the KiCad source code, by Maciej Sumiński

Let’s be sincere, all of us would love to change something in KiCad. I bet you have an idea for a new tool or another killer feature that would make your life so much easier.

You know what? You are free to do so! Even more, you are welcome to contribute to the project, and it is not that difficult as one may think. Those who have browsed the source code might find it overwhelming at first, but the truth is: you do not have to know everything to create useful extensions.

I would like to invite you for a walk through the KiCad source code to demonstrate how easy it is to add this tool you have always been dreaming about.

  • 15:30 – 16:00 – Testing with volcanoes – Fuego+LAVA, embedded testing going distributed, by Jan-Simon Möller

LAVA and Fuego are great tools individually already. Combining and extending them allows for a much broader test coverage than each tool alone can provide.

The focus of this talk is to share the experiences made and lessons learned so people can integrate such tools better in their own environment. It also raises the pain-points and open issues when setting up a distributed environment.

Especially for Automotive, Long-Term-Support, CIP or Consumer Electronics, advancing the Test-harness is essential to raise the bar and strengthen the confidence in our embedded platforms. Automated testing can improve our ecosystem from two sides: during development (feature does work and does not break things) and during maintenance (no regressions through backports).

  • 16:00 – 16:30 – Adding IEEE 802.15.4 and 6LoWPAN to an Embedded Linux Device, by Stefan Schmidt

Adding support for IEEE 802.15.4 and 6LoWPAN to an embedded Linux board opens up new possibilities to communicate with tiny, IoT type of, devices.

Bringing IP connectivity to devices, like sensors, with just a few kilobytes of RAM and limited battery power is an interesting IoT challenge. With the Linux-wpan and 6LoWPAN subsystems we get Linux ready to support the needed wireless standards as well as protocols that connect these tiny devices into the wider Internet. To make Linux a practical border router or smart home hub for such networks.

This talk will show how to add the needed transceiver hardware to an existing hardware and how to enable and configure the Linux-wpan and 6LoWPAN mainline subsystems to use it. The demonstration will include setting up the communication between Linux and other popular IoT operating systems like RIOT or Contiki as well.

  • 16:30 – 17:00 – OpenPowerlink over Xenomai, by Pierre Ficheux

Industrial Ethernet is a successor of classic field bus such as CAN, MODBUS or PROFIBUS. POWERLINK was created by B&R Automation and provides performance and real­-time capabilities based on standard Ethernet hardware. openPOWERLINK is open source and runs on lots of platforms such as Linux, Windows, various RTOS and dedicated hardware (FPGA). We will explain how to use openPOWERLINK on top of Xenomai 3, a powerful real-time extension for Linux kernel based on co-­kernel technology.

FOSDEM 2017 will take place at the ULB Solbosch Campus in Brussels, Belgium, and no registration is required, you just need to show up in order to attend the event.

$55 OpenMV Cam M7 Open Source Computer Vision Board is Powered by an STM32F7 Cortex-M7 MCU

January 2nd, 2017 6 comments

I wrote about Jevois-A33 computer vision camera based on Allwinner A33 quad core Cortex A7 processor last week, and today, I’ve come across OpenMV Cam M7 open source computer vision board based on a much less powerful STMicro STM32F7 ARM Cortex M7 micro-controller, but with the advantage of consuming less power, and exposing some extra I/Os.

openmv-cam-m7OpenMV Cam M7 board specifications & features:

  • MCU – STMicro STM32F765VI ARM Cortex M7 @ up to 216 MHz with 512KB RAM, 2 MB flash.
  • External Storage – micro SD slot
  • Camera
    • Omnivision OV7725 image sensor supporting 640×480 8-bit grayscale images or 320×240 16-bit RGB565 images at 30 FPS
    • 2.8mm lens on a standard M12 lens mount
  • USB – 1x micro USB port (Virtual COM Port and a USB Flash Drive)
  • Expansion – 2x 8-pin headers with SPI, I2C CAN bus, asynchronous serial bus (Tx/Rx), 12-bit ADC, 12-bit DAC, 3x I/Os for servo control; interrupts and PWM on all I/O pins; 3.3V (5V tolerant)
  • Misc – RGB LED and 2x 850nm IR LEDs
  • Power Supply – 5V via micro USB port, 3.6 to 5V via VIN pin
  • Power Consumption (@ 3.3V) – Idle: 110mA;  active no μSD Card: 190mA; active with μSD Card: 200mA
  • Dimensions – 45 x 36 x 30 (H) mm
  • Weight – 16 grams
Click to Enlarge

Click to Enlarge

The camera board supports frame differencing (motion detection), marker tracking, face detection, eye tracking, color tracking (up to 32 colors at the same time), optical flow, edge/line detection, template matching, image capture (BMP/JPG/PPM/PGM), and video recording (MJPEG/GIF). Programming is done in OpenMV IDE using MicroPython language. You’ll find more details in OpenMV Cam’s documentation, and watch a description of the board and a QR code detection demo in the video below.


The computer vision board can be pre-ordered now for $55 on the product page with shipping scheduled for March 2017.

How to Build and Flash ESPurna Open Source Firmware to Sonoff POW Wireless Switch

December 3rd, 2016 33 comments

ITEAD Studio Sonoff family is comprised of various inexpensive ESP8266 WiFi power switch, and the company sent me two of their latest CE certified models with Sonoff TH16 + external temperature & humidity probe, and Sonoff POW to measure power consumption. I checked the hardware is the first part of the review, and used Sonoff TH16 to control a water pump with the stock firmware and Ewelink Android app in the second part. It works reasonably well, but it relies on the cloud, so if you lose your Internet connection or the service closed, you can’t control the relay manually anymore. Luckily, the UART pins are exposed on Sonoff switches so you can solder a 4-pin header and connect a USB to TTL to flash your own firmware.

Click to Enlarge

Click to Enlarge

Please don’t connect Sonoff devices to the mains when programming them, it’s very dangerous, instead the USB to TTL board will power the system, and will allow you to program the board safely. Later you’ll be able to update the firmware, if needed, over the network.

The next step is to select the firmware you want to use, and I’ve been advised two firmware for ESP8266, namely ESPurna specifically designed for Sonoff devices, and ESPEasy with a larger community of users. The latter may be usable to control the relay, but it has yet to support HLW8012 chip used to measure power consumption in Sonoff POW, so I decided to go with ESPurna.

That’s the description of the firmware from its bitbucket page:

ESPurna (“spark” in Catalan) is a custom C firmware for ESP8266 based smart switches. It was originally developed with the ITead Sonoff in mind. Features:

  • Asynchronous WebServer for configuration and simple relay toggle with basic authentication
  • Communication between webserver and webclient via websockets with secure ticket check
  • Flashing firmware Over-The-Air (OTA)
  • Up to 3 configurable WIFI networks, connects to the strongest signal
  • MQTT support with configurable host and topic
  • Manual switch ON/OFF with button (single click the button)
  • AP mode backup (double click the button)
  • Manual reeset the board (long click the button)
  • Visual status of the connection via the LED
  • Alexa integration (Amazon Echo or Dot) by emulating a Belkin WeMo switch
  • Support for automatic over-the-air updates through the NoFUSS Library
  • Support for DHT22 sensors
  • Support for the HLW8012 power sensor present in the Sonoff POW
  • Support for current monitoring through the EmonLiteESP Library using a non-intrusive current sensor (requires some hacking)
  • Command line configuration

I could not find firmware release for ESPurna, but Xose Pérez – the developer – has provided some basic instructions to build and flash the firmware to Sonoff. Those are not really detailed however, and it took me nearly a full day to successfully build and flash the firmware to Sonoff POW, mostly because I was not quite familiar with most of the tools used. So I’ve reproduced the step I went through in Ubuntu 16.04, and hopefully this can help people getting things done more quickly.

Let’s retrieve the source code, and enter the code directory first:

You can build the project with PlatformIO or the Arduino IDE. The instructions are for PlatformIO so that’s what I used. There are two ways to build the code with the project wither using Platform IDE for Atom and the command line, or simply using the command line. With insights, I ended up using the command line, but I’ll show both methods.

Setup PlatformIO IDE for Atom to build ESPurna

First, you’ll need to download PlatformIO IDE for Atom for your operating systems, and install it. For Ubuntu 16.04, I selected “Download .deb” for Linux and installed it through through Ubuntu Software program. Alternatively, after download, you can install it from the command line:

You can now start Atom program in Ubuntu dash, select Open Project, and browse for espurna/code directory to load the project we’ve just gotten from Bitbucket.

Click to Enlarge

Click to Enlarge

The tick button on the top left corner is to build the project, and the right button just under is to upload the firmware to the target board. But if we try to build the firmware now it will fail with an error about “espressif8266_stage”. That’s because we need to install Espressif 8266 (Stage) development platform. First we need to enable Developer mode in the IDE by going to the top menu to select PlatformIO->Settings->PlatformIO IDE, and checking “Use development version of PlatformIO“.

platformio_core_enable_development_version

Click to Enlarge

Now install PlatformIO shell commands from either a system Terminal, or PlatformIO IDE terminal (PlatformIO->Terminal->New Terminal):

and finally install ESP8266 development platform:

At this point you can click on the tick icon to build the default “node-debug” environment, a build output window will show in the IDE, and quickly disappear if the build is successful.

Setup PlatformIO via Command Line to Build ESPurna

If instead we want to use the command line we can install the latest pip version, the developer version of PlatformIO, and the staging version of ESP8266 development platform:

You can check the build environment is set properly by running the following command in espurna/code directory:

It will automatically download, build and install all dependencies and build for “node-debug” firmware for NodeMCU board. If it is successful, it will end as follows:

So I find the command line option much more easy and straightforward.

Build ESPurna for Sonoff POW

However, we are not using NodeMCU board here, but Sonoff POW, and there are two environments defined just for that:

  • sonoff-pow-debug – Build firmware to flash over serial
  • sonoff-pow-debug-ota – Build OTA firmware to upgrade the firmware over the network

The parameters for each environment are all defined in platformio.ini. First we need to build sonoff-pow-debug environment:

But it failed with an error message related to hlw8012 library:

I reported the issue on Bitbucket, but the main developer could not reproduce the issue. Eventually I found out that it could be a PlatformIO bug, as the system does not recursively checking for includes outside of main.ino. So I added <hlw8012.h> in the main.ino as follows:

and the build could complete:

Since we’ve already changed the code, you may also consider changing “#define ADMIN_PASS  fibonacci” in code/src/config/general.h to use a different default password. The password can also be changed in the web interface, but this makes sure you won’t have a device somewhere with the default password common to most users.

Flashing Firmware to Sonoff POW

Now that we’ve made sure the firmware could build, it’s time to flash it to the device.

First we need to setup some udev rules to allow flashing over serial:

Now connect the USB to TTL to a USB port on your computer, press the button (connected to GPIO0) on Sonoff POW for several seconds until both LEDs are off to make sure you are in bootloader mode, and start flashing with:

Success! Great. If you have your own firmware to flash it may be useful to know the actual command used to flash the firmware was:

Building and Flashing the ESPurna filesystem

Wait! We’ve just flashed the firmware, isn’t it all? Nope, as the webserver files are stored in another partitions, and compressed in a single index.html.gz file for better performance. The exact reasons why are further explained here.

We’ll need Node.js and gulp command line client:

Now inside espurna/code folder , we can check if building the file systems works with two commands:

Here my successful gulp attempt:

Finally, we can run the following (which also runs the two commands above) to flash the file system to the board, after entering bootloader mode by pressing the button:

Now that’s done.

A Quick look at ESPurna Web Interface

ESPurna firmware and filesystem has now been flashed to Sonoff POW. But does it work?

Click to Enlarge

Click to Enlarge

I can see a new SONOFF_POW_XXXXX access point, so that does look good. I can connect using the default password “fibonacci”, then go to my web browser to access http://192.168.4.1, and login again with admin/fibonacci credentials.

Click to Enlarge

Click to Enlarge

ESPURNA 1.03 interface goes to the status menu first, and there I can turn on and off the relay remotely, and check the power consumption in watts, which remains at 0 watt since I have not connected it to the mains yet. It’s also possible to turn the relay on and off with the button, and there an option to select whether to turn on or off the relay at boot time, which is great since I need it on at all times.

The web interface also allows you to change general parameters including the hostname and password, as well as enable or disable the HTTP API (disabled by default). The WiFi section is used to connect to up to 3 wireless routers, the MQTT section lets you configure an MQTT (Mosquito) broker, and the power section is used to calibrate the power monitoring device.

If you just intend to check the current power consumption and turn on and off the switch with your phone, you don’t have to do anything else. But I’d like to find some ways to draw daily, weekly, monthly charts of my office power consumption using either MQTT or the HTTP API. I’ll have to study how to do that, and that will hopefully be the topic of my next post about Sonoff POW.

Sonoff POW can be purchased on ITEAD Studio for $10.50 plus shipping, but is currently out of stock with the company manufacturing a third batch soon.

Hack Autonomous Driving into Your Car with Open Source Hardware Comma Neo and Open Pilot Software

December 1st, 2016 4 comments

George Hotz setup Comma.ai company and worked on a commercial project called Comma One to add autonomous driving to some car models, but then the US highway authorities started to ask questions and promised ever increasing fines if he could not comply with some specific safety regulations/requirements, and eventually he decided to cancel the project due to the regulatory burden. A few weeks passed since the cancellation, and he has now released Open Pilot auto-pilot software and Comma NEO a work-in-progress open source hardware platform connecting to Qualcomm Snapdragon 820 powered OnePlus 3 smartphone to run the software.

Comma NEO

Comma NEO

The system is said to implement “Adaptive Cruise Control (ACC) and Lane Keeping Assist System (LKAS) for Hondas and Acuras”, and performs about the same as “Tesla Autopilot at launch, and better than all other manufacturers”.

Open Pilot currently only supports the Acura ILX 2016 with AcuraWatch Plus and the Honda Civic 2016 Touring Edition, but since the software is open source, it should be possible to adapt it to other Honda and Acura models with some tinkering, and other car manufacturers could also be added to the list but would require much more work. The system leverages the cars’ cruise control system which becomes disabled at lower speed, so self-driving only works at higher speeds, 18+ mph or 25+ mph depending on the car’s model.

The video above should be using Open Pilot software, but I’m unclear which exact hardware it is using (Comma One or Comma NEO).

The software also has the following disclaimer “THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT. YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS. NO WARRANTY EXPRESSED OR IMPLIED”. But if it does not bother you, George has put together a step by step guide showing exactly how to buy all parts (~$700) from 6 different shops, solder the components to NEO Rev A board, wire and test the board, and assemble the case.

Via Arstechnica and Nanik.

$59 HiFive1 Arduino Compatible Board is Powered by Sifive Open Source RISC-V MCU (Crowdfunding)

November 30th, 2016 8 comments

Royalty-free RISC-V instruction sets has been getting in the news in the last few years with various MMU designs from companies or projects like lowRISC, PULPino, and SiFive, and recently there are been rumors that Samsung may use RISC-V in their future IoT SoCs. Many projects are still in progress, and while you can get involved in OnChip Open-V MCU crowdfunding campaign to their get the MCU or a development board, the cost for the MCU ($49) and development board ($99) is a little on the high side, and delivery is expected in 2018 for most rewards. SiFive appears to have a more interesting open source RISC-V solution with HiFive1 Arduino compatible board going for $59 and slated to ship between December 2016 and February 2017.

HiFive1 Board

HiFive1 Board

HiFive1 development board specifications:

  • MCU – SiFive Freedom E310 (FE310) 32-bit RV32IMAC processor @ up to 320+ MHz (1.61 DMIPS/MHz)
  • Storage – 128 Mbit SPI flash
  • I/Os
    • 19x Digital I/O Pins
    • 19x external interrupt pins
    • 1x external wakeup pin
    • 9x PWM pins
    • 1/3 SPI Controllers/HW CS Pins
    • I/O Voltages –  3.3V or 5V supported
  • USB – 1x micro USB port for power, programming and debugging
  • Power Supply – 5 V via USB or 7 to 12V via DC Jack; Operating Voltage: 3.3 V and 1.8 V
  • Dimensions – 68 mm x 51 mm
  • Weight – 22 g

sifive-fe310

The company’s Freedom SDK with the RTL files for Freedom E310 (and U500) MCUs will allow you to actually play and/or modify the MCU on an FPGA platform, which can be useful for education or if you want to create your own MCU based on SiFive design. If you don’t have the know-how the company’s “chips-as-a-service” offering can customize FE310/U500 MCU to meet your needs.

 Most users will probably just program the board with the Arduino IDE, and many of the usual development tools have already been ported to RISC-V architecture. The processor is also quite faster than our typical Arduino, being about 10 times faster than Intel Curie and Atmel SAMD21G18 used in respectively Arduino 101 and Arduino Zero.

hifive1-vs-arduino

Power efficiency (@ 200 MHz) appears to be much higher compared to Atmel AVR and Intel Quark. However, based on ARM Cortex M0 product brief (I could not find data for M0+), 10DMIPS/mW can be achieved using 180ULL process, and 75 DMIPS/mW with 65LP process.

If you are interested, you can get the board on Crowdsupply with the HiFive1 devkit going for $59 and shipping in February 2017, but if you want to have a piece of history, you may consider HiFive1 Founder Edition for $79 with SiFive Founding Team’s Signature on the silkscreen and shipping at the end of December 2016. Shipping is free to the US, and $15 to the rest of the world.

RISC-V could be a serious competitor to ARM and MIPS in the MCU/IoT space in the years ahead, as it’s royalty-free, and the RISC-V foundation has many players including some heavy weights such as Google, AMD, Microsemi, Qualcomm, Nvidia and more…

Thanks to noone for the tip.