About this project
We want to make MicroPython run like clockwork on the bare metal of the ESP8266 Wi-Fi chip. MicroPython gives you the benefits of a well-known high-level programming language - simple and powerful code, and rapid development - all in the constraints of a microcontroller. Using MicroPython on the ESP8266 will allow you to create beautiful Internet of Things devices with ease, much quicker than with C or similar compiled languages, and using Python is a lot of fun!
On to stretch goals!
We have already achieved our funding level, excellent! And we have achieved our main stretch goal of GBP 12,000, which means that all of the source code will be released Open Source (MIT licensed) on GitHub right after the campaign ends! But we still have some great extended stretch goals so please consider backing the project!
The stretch goals are:
- GBP 8,000 unlocked! - We will implement a module or major feature as voted by backers (see "vote for module" in rewards).
- GBP 10,000 unlocked! - We will implement a second module or major feature as voted by backers (see "vote for module" in rewards).
- GBP 12,000 unlocked! - We will release the source code on GitHub as soon as the campaign ends.
- GBP 15,000 unlocked! - We will develop, test and document a suite of drivers for environmental sensors that can run on the ESP8266 (and other MicroPython boards). The sensors are (subject to actually being compatible with the ESP8266): DS18B20: 1-wire temperature sensor; DHT22: temperature and humidity sensor; BMP180: I2C temperature and pressure sensor; HDC1008: I2C temperature and humidity sensor; MCP9808: I2C temperature sensor; TSL2561: I2C light sensor; LSM303DLHC: I2C accelerometer and compass (magnetometer); L3GD20H: I2C gyroscope; HTU21D: I2C temperature and humidity sensor.
- GBP 18,000 unlocked! - We will implement a simple micro database on the ESP8266. Details are not worked out, but likely it would be stored in flash and allow you to do simple key/value storage and lookup.
- GBP 20,000 unlocked! - We will implement a native emitter for the ESP8266 (Xtensa architecture). This will allow you to use @micropython.native, @micropython.viper and @micropython.asm_xtensa decorators to write code that runs faster than normal Python bytecode.
- GBP 23,000 unlocked! - We will add support for running "upip" on the ESP8266. upip is a package manager for MicroPython modules (similar to CPython's pip) and will allow you to install Python modules on your ESP board's filesystem directly from the internet (without it, you would need to download needed modules manually to your PC, unpack them, and then transfer to your module - upip automates these steps).
- GBP 26,000 unlocked! - We will implement integrated asyncio support for the ESP8266 (via MicroPython's uasyncio module).
- Final stretch goal: For each GBP500 that we get beyond GBP26,000 we will make a video tutorial on using some feature of MicroPython on the ESP8266.
Tell me more!
The Internet is huge. The Internet of Things will be even bigger and we need an efficient way to build it. Microcontrollers and small embedded devices are at the heart of the Internet of Things and can be hard to program because of their limited resources, and the fine details associated with low-level peripheral access. MicroPython was written specifically to run on such small devices and make it easy to program them, while still giving you the feel of running on bare metal.
A fantastic addition to the IoT (Internet of Things) ecosystem arrived about a year ago: the Espressif ESP8266 system on a chip. It contains just the right balance of ingredients to make it a perfect little IoT component: a 32-bit CPU, built-in Wi-Fi and some GPIO. And it also has just the right amount of RAM and power to run MicroPython.
So why this Kickstarter? There is already a proof of concept port of MicroPython to the ESP8266 but it uses the execution model provided by Espressif. This model requires you to set up callbacks to process Wi-Fi requests and leads to very cumbersome code. Python is built around standard Berkeley sockets and what we want to do is develop such “proper” sockets for MicroPython on the ESP8266. We aim to provide a true Python socket API to make development a pure joy.
And we need your help! MicroPython is open source software and as such needs support from the community to grow. Quality software requires time and money to develop, and with your pledge to this campaign we can put our efforts into making MicroPython run silky smooth on the ESP8266. We will develop a true Python socket API (application programming interface). We will make optimisations specific to the ESP8266 chip to squeeze out as much RAM and resources as possible. We will also provide sustainable support, bug fixes and ongoing improvements way past the end of the campaign. Your support of this campaign also helps to keep MicroPython growing and to keep it open source and MIT licensed, for everyone to benefit from.
MicroPython is great for IoT and the ESP8266 is an awesome little Wi-Fi chip. Pledge now to help us get them both working together like they were made to be!
So what will I get from this Kickstarter?
As a backer you’ll get the MicroPython ESP8266 firmware, ready to run, to put on your favourite ESP8266 development board. Bug fixes and critical updates will also be provided to all backers. You can get guaranteed regular feature updates if you want to pledge a little more.
We will also produce tutorials to help you get started, and documentation so that you know exactly how to use the software. We will foster and moderate the ESP8266 part of the existing MicroPython forum, allowing you to join a community of like-minded people who have the answers to your questions. We are setting the project up for long-term support and maintenance so that you get improvements to the code beyond the end of this campaign.
The source code will be released open-source after 6 months, and from then on you can hack and build it to your hearts content.
But wait! If we reach our main stretch goal of GBP 12,000 during this campaign then we will release the source code straight away, right after the campaign closes. So, please, spread the word and help us reach our goal to get the code into everyone’s hands as soon as possible!
What is the Berkeley socket API and why is it so important?
Berkeley sockets (also known as BSD sockets, or POSIX sockets) are the de facto way for a computing device to talk on the Internet. You create a socket on your local device which connects to a socket on another device, usually far away. The devices then transfer information to each other over this socket connection. For example, in Python (and of course MicroPython) you can write:
This Berkeley socket API is mature, simple and robust. It offers an imperative way of programming whereby the layout of your code corresponds to the execution of that code. Berkeley sockets are used in almost all programming languages and form the basis of more sophisticated services such as HTTP, email (SMTP) and many other things.
The current way of programming the ESP8266 is not like the above. It’s based on callbacks whereby you register functions that should be called when something happens, like a connection is established, or there is data ready to process. This callback-based execution model makes it hard to write more than the most simplest of programs because you very quickly get lost in a spaghetti code of callback functions.
This campaign aims to get MicroPython working as smooth as can be on the ESP8266 so you can write code on this chip exactly as it is written above. In addition to Berkeley sockets providing a more logical way of programming compared to callbacks, having MicroPython run on the device means that you can prototype and debug your socket code (eg HTTP, FTP, SMTP, websocket, AJAX etc) on a normal PC first, running under normal Python. And then once it’s ready to go you can just copy the script to your ESP8266 and have it work without spending any extra effort. How cool is that?
What is the timeline of this campaign?
- Backers who go for the "Follower" or "Driver" rewards will get the alpha version of the software within 1 week of the close of the campaign.
- Physical rewards will ship by the end of the first month.
- We intend to finish the programming (well, at least get to a solid v1.0) within 2 months of the closing of the Kickstarter campaign, which is when all backers will receive their v1.0 firmware.
- Everyone will receive bug fixes and critical updates for 1 year. Backers of the "Extended supporter" and above rewards will also receive feature updates of the firmware for 1 year.
- The source code will be released on GitHub at the 6-month mark.
- If we reach our stretch goal of GBP 12,000 then the full source code will be released as Open Source software right after the campaign closes!
Why a software Kickstarter?
There are so many ESP8266 boards out there that we didn’t want to make yet another one. Instead we decided to concentrate on making quality software and support the hardware that already exists.
The port of MicroPython that we will develop will run perfectly on the ESP8266 chip, and as a consequence will run on all the existing - and future - ESP8266 development boards.
Whatever hardware you have this campaign is for you!
As well as running on all hardware, we will be officially supporting the Adafruit HUZZAH boards, both the original and the Feather version. We are really pleased to support Adafruit because their hardware is top-notch. We will support their IO layout and pin mapping, as well as various Feather add-on boards.
Why now for MicroPython on the ESP8266?
MicroPython was the first Open Source scripting language ported to ESP8266. However, the ESP8266 port at that time was mainly proof of concept, and the main focus of the project was on elaborating the language core, supporting the pyboard, and furthering Linux, Mac OSX and Windows ports. This kind of work was essential to grow MicroPython to the size it is today, which is reflected in its impressive statistics.
Back when the ESP8266 first appeared we would have spread our efforts too thin if we had added it to the mix of active work, especially considering the multiple issues it had at that time (from reliability to credibility and licensing). So we kept the ESP8266 port running as community-driven project. While many people contributed to it, it followed the route most of the other ESP826 projects took - wrapping a proprietary, limited vendor API, to be confined by its bounds.
But this way doesn't work for Python, which provides a wealthy set of easy to use and understand APIs (including Berkeley sockets), which everyone knows. And people who don't know can easily learn!
The ESP8266 chip itself is now well known in the Maker community, but its viral popularity started only a little more than a year ago, making it a very young chip. Exciting new chips appear regularly, but most of them are not to be heard of again, for various reasons. The ESP8266 seems to have avoided that fate, and recently there has started to appear commercial/consumer products based on it. Licensing issues regarding the use of the ESP8266 SDK have been settled just in the last 6 months, and the next chip in the series (the ESP32) has been announced. This confirms the long-term future of the chip.
And so the reason for this Kickstarter right now: MicroPython is mature and the ESP8266 is viable and credible. It just remains to do the coding!
What about the ESP32?
There is recent news that Espressif will soon release their next chip, the ESP32. But it's not a replacement for the ESP8266:
We though hard whether we should wait for the ESP32 or proceed with this ESP8266 campaign now. Considering that it will take some time until the ESP32 is ready and available for consumers, we thought the best way to prepare is to finish the ESP8266 port and get it into your hands to build an active community. If this campaign is successful we'll definitely work on ESP32 support, and we will hopefully lead on it.
What will my money be used for?
This Kickstarter campaign is all about raising money to fund the development of a piece of free and Open Source software, that would otherwise not get written. The funds will be used for subsistence of Damien and Paul while developing the software. In particular the areas that will receive attention are:
Coding: The bulk of the work consists of programming the port of MicroPython to the ESP8266 chip. This is highly technical work that requires a deep understanding of MicroPython, of networking protocols, of embedded systems and microcontrollers, and of the ESP8266 chip itself. We will concentrate primarily on: 1) having a Python compatible execution model; and 2) having a proper Berkeley sockets API exposed as the socket module. After these goals are achieved we will implement peripheral support (eg GPIO, I2C, UART, SPI, etc) and drivers for some common components (eg 1-wire temperature sensor, NeoPixel LEDs, OLED display, etc). All of these things already have working proof-of-concept code.
Optimisation: In addition to coding new features, we will also perform various optimisations, in particular to squeeze out as much RAM as possible for the user to use.
Documentation: We understand that a technical project is not useful without documentation making it accessible to end users. Our funding goal includes effort required to write documentation and keep it up to date.
Support: We have set reward tiers for at least one year of continued support, during which backers will receive guaranteed ready-to-use updates with both bug fixes and new features. Note that even backers who did not select continued updates option will receive fixes for critical issues (like crashes). Our funding goal also includes provision for accepting, triaging and investigating bug reports from backers, as well as providing other means of support. Note that the figures specified are conservative and correspond to the basic funding goal of the project. We are keen to provide more, not less, support and for longer, not shorter, time. Achieving the campaign stretch goals will enable us to do exactly this.
What about the long-term future of the software?
Our aim for this project is to provide a long-term solution for developing with the ESP8266, using MicroPython. As such we are committed to setting things up from the start so that a community can grow around our work, and the software can continue well beyond the end of this Kickstarter campaign.
Long-term support and maintenance: The MicroPython port for ESP8266 will be released as Open Source, and running this campaign will allow to get together all the interested parties to form a self-sustaining community. The creators of the project are keen to provide guidance and support for such community.
Project longevity: One of the top goals of the project is to avoid usage of ad-hoc and proprietary, chip- and vendor-specific APIs. Instead, we seek to implement well-known, standard, reusable APIs. Users familiar with Python will be able to use MicroPython immediately. Users not familiar with Python will be able to reuse their MicroPython experience with standard Python, and thus will have their time and effort investment protected. Application written for MicroPython/ESP8266 will be easily portable to other hardware supported by MicroPython and to desktop/server environments.
Why 6 months until the source code is released?
The matter: Open Source software by itself isn't that useful. What is useful is Open Source with a big, active community, and to have such a community requires support - bugs should be fixed, new versions released, question answered, and help provided. We are keen to not just write Open Source software, but also support it, to make it actually useful for you! But support takes time, which amounts to money (or we'll need to spend more time finding ways to pay the bills and less on providing support).
What we really want to achieve is to meet our stretch goal and collect enough funds to provide support for a reasonable time, while a community around ESP8266 MicroPython builds and become self-sustained. So we give you the incentive to help us reach that stretch goal: if we get there the source code will be released just after the campaign closes.
Please note that we will release the ESP8266 port as Open Source software no matter what - our ultimate goal is to make MicroPython run everywhere, take our word for it! It also sucks to have our own private git repository - we want to share it with you on Github as soon as possible!
So please, help us, you don't even need to pledge more money - just help to spread the word. What we really need are more people who are excited by the idea!
Okay, that’s a lot of info. Can you please sum it up?
We sure can! Here are the main points of this campaign:
- This is a software-only campaign, to raise funds to develop Open Source software.
- MicroPython is ideally suited to the ESP8266 and we want to get them running together like clockwork, so that you can make beautiful IoT devices with ease.
- We need your support so we can write the code, tutorials and documentation.
- The main technical challenge for us is to get a proper Berkeley sockets API running on the ESP8266, which allows you to write Internet code much more easily.
- Programming in MicroPython is just like programming in Python and allows you to write sophisticated and robust programs very quickly.
- As a backer you will get firmware that’ll run on any ESP8266 board.
- The code will be made open source after 6 months. But straight away if we reach our stretch goal.
Who are the people behind this project?
Damien has a background in theoretical physics, robotics and computer engineering, and loves to program and build things. He is the creator of MicroPython and ran a very successful Kickstarter campaign just over 2 years ago to build a community around this microcontroller language. Since then he has built a successful company around MicroPython and the pyboard, brought it to makers, teachers and industry developers around the world, and embarked on a project with the European Space Agency to bring MicroPython into space. Damien now works full time improving and maintaining the MicroPython ecosystem.
Paul has been a major contributor to MicroPython for 2 years. He is the maintainer of the Unix port, a number of builtin modules, and micropython-lib (the standard library for MicroPython). Paul was an avid reader of esp8266.com during its few initial months and contributed to early hacking projects like esptool and ida-xtensa. He maintains the esp-open-sdk project which allows to easily create a ready-to-use toolchain. This project quickly grew popular in the community and was selected by a number of other projects for toolchain needs. He also raised concern of wrongly selected GPL license for ESP8266 SDK and drove it to the resolution with other concerned professionals, to make sure there are no liability concerns for independent vendors who use the ESP8266 SDK for their products.
Viktoriya takes care of the production, management, logistics and creative side of the project. She is a professional photographer and videographer, holds MSc, MBA, and HNC in Photography and Filming diplomas. Viktoriya has been with the team since the first days of MicroPython and will be filming all upcoming project updates.
References and Acknowledgements
MicroPython main page: http://micropython.org
MicroPython on GitHub: https://github.com/micropython/micropython
MicroPython Forum: http://forum.micropython.org
ESP8266 Community Forum: http://esp8266.com
Music in the video: "Divider" by Chris Zabriskie
Risks and challenges
Being a software-only Kickstarter we do not foresee any logistical challenges associated with a hardware Kickstarter. Instead there are technical challenges from the software development point of view, as well as the general running of a Kickstarter campaign. Damien has previously delivered on a very successful hardware-based Kickstarter (that of MicroPython) and so he is knowledgeable and confident about running this campaign.
To achieve a standard socket-based networking API we are going to utilise a novel approach to network communication on the ESP8266 chip, which, to the best of our knowledge, hasn’t been utilised by anyone else. We have a prototype of this method which works really well, and we intend for it to be the basis of our software. However, if we face blockers with this approach down the road we are ready to switch to a more traditional approach using an external pre-emptive RTOS (such a solution will be less efficient in terms of RAM usage, i.e. leave less memory for user applications, and that's why we developed an original, efficient alternative).
Both Damien and Paul have extensive knowledge and experience in programming, in MicroPython and embedded systems, as well as with the ESP8266 chip. We are very confident that we can deliver on the goal of this project. And we are confident that it will be done in a timely matter.Learn about accountability on Kickstarter
Support this project
- (35 days)