About this project
VIPER is an easy to use development suite for the high level design of interactive objects ready for the cloud and the IoT.
With VIPER creatives, designers and professionals can develop in Python for Arduino DUE, UDOO and all Spark products (Core, Photon and Electron), and similar boards using paradigms and features typical of PC and mobile programming.
With VIPER you can build almost everything! Amazing installations and projects can be built with few clicks. You need just a pinch of creativity!
With VIPER you can design and prototype the objects of the future!
This is the VIPER Daily Life Assistant we built in collaboration with the designer Zhiyao Chen from MBVision
Using VIPER is very easy!
You just need to download a single package from our website, and unpack it on your computer or on a USB stick. VIPER is ZERO-install!
VIPER is a complete solution: It also includes an embedded, portable Python 3.0 engine in order to make your life easier!
Launch the VIPER IDE and develop your project, or test one of the examples we made for you. Just connect to the VIPER App to control everything on your board!
Time to play with your board: you need only 5 simple steps.
VIPER is a set of open source software and hardware tools developed and professionally maintained by our team with a specific mission: make your design activity productive and enjoyable!
We want to share with you what exactly we have developed so far, and what we want to offer as a final product. Your help will allow us to refine our current tools into a polished product.
Let's go in detail with the VIPER components:
THE VIPER APP
Whether you are creating an interactive object or an art installation, you will need some form of interface for it. LCDs and buttons are so passé... you need a mobile App!
This is why we developed a ready to use App that acts as an interface for your VIPER powered projects. Just install it on your smartphone or tablet, and you are ready to go!
When launched the VIPER App will discover all the VIPER devices available on your network. Once one of them will be selected the App will become its interface.
VIPER App interfaces are based on HTML templates that you can select and edit through the VIPER IDE integrating them in your VIPER Python scripts.
You don’t have to write any iOS or Android code!
Data can be easily exchanged between VIPER objects and mobile devices, possibly triggering mobile features like notifications and SMS.
THE TOI SHIELD
We don’t want to see you getting insane with funky electronic circuits setup! Therefore, the VIPER suite works out of the box with a multi-sensor board that allows you to start developing your interactive projects in minutes. Just plug your Arduino DUE or Spark Photon into the TOI Shield and start playing with the VIPER examples!
TOI shield is the first shield compatible with both Arduino and Spark Core or Photon footprints!
The shield contains a number of sensors and actuators so you can unleash your creativity:
Aux ports are also included allowing the use of other sensors like Grove, ThinkerKit, Phidgets and similar kits and of the Adafruit Neopixel LED strips.
THE VIPER IDE
The VIPER IDE is a browser-based development environment that runs on Windows, Linux and Mac. Through the VIPER IDE you can manage your boards and develop the corresponding logic in Python 3.
The IDE is based on Code Mirror, one of the most used open source browser-based text editor. We extended it with several VIPER-specific tools.
The VIPER IDE already supports various amazing features such as multi-tab, boards smart detector, and an embedded serial console. We need your help to finalize and improve it!
THE VIPER VIRTUAL MACHINE
The core of VIPER is the VIPER Virtual Machine.
Through our IDE you can viperize your boards by installing on them the VIPER VM. Once viperized, a board is no longer a simple Arduino DUE or Spark Photon or UDOO -- now it has a multithreaded real-time operating system running on it, as well as a virtual machine ready to execute your compiled Python 3 scripts.
VIPER supports all the most used high-level features of Python like modules, classes, multithreading, callbacks, timers and exceptions, plus our custom hardware-related features like interrupts, PWM, digital I/O, etc.
The VIPER VM provides real hardware independence -- you can reuse or integrate your code on different boards and do simulation and debugging on a PC .
VIPER runs on top of CHIBIOS, an embedded device operating system with real-time capabilities. Hence, VIPER supports all ARM architectures. If you need it, you can also link native C functions to your VIPER scripts.
A rich library of modules comes with VIPER, including CC3000 WiFi for Spark Core and Adafruit Shield; Adafruit/Sparkfun Thermal Printer; Adafruit Neopixel LED; RTTTL smart melody player; Streams library; TCP, UDP network protocols. We are currently working on more, including SPI communication; Infra Red emitter, receiver and decoder library; TOI Shield Library with easy sensors reading.
The VIPER VM also supports TCP and UDP connections, allowing the use of HTTP and HTTPS protocols. Carriots and Paraimpu cloud services will be included in the library. We are also working with the Spark team for the integration of the Spark Cloud! Do you like other cloud services and providers? No problem, you can easily add them yourself using Python!
Let’s write your first VIPER script!
We could show you a simple LED blinking example known as the “Hello World of embedded devices"..... but with VIPER we can make it funnier. This is the code required to blink 2 LEDs at different frequencies using two separated threads:
Just Click “Run”. The VIPER IDE will upload it on your viperized board.
The board embedded LED 1 (we have already defined this labels for you in the VIPER Library) will blink every 500 milliseconds while the LED 2 every 800 milliseconds. Under the hood, the IDE compiles the script into optimized bytecode and instructs the VM on the viperized board to load and run it.
Once the script is run, two additional threads are created (the main thread is always available), each running a specific instance of the blink function, with different parameters.
Of course you can do it also with Arduino..... but please, try doing it :)
Liked it? Let's go on to the next: TOI Shield and the VIPER Library in action.
Ok, let’s get hardcore. With this script you can control a Neopixel LEDs ring from the VIPER App!
The VIPER App module makes all the dirty job for you. Just load the App template you prefer and link your Python scripts functions with the interface template callbacks!
This is the power of programming in a high level language like Python!
You don’t have to lose your sanity with writing single-loop logic that checks UDP packets from an app while keeping the time to smoothly animate the LEDs: VIPER is multithreaded!
Viperizing your boards is also very simple! let's have a look!
With VIPER, possibilities are endless. You can use all the power of the Python language to do whatever you wish!
Are you a Geek? Do you have a rover kit with a motor shield for Arduino? Have a look how you can hack it with VIPER and a Spark Core!
This is the VIPERized Car with mobile based remote controller!
This is the VIPER Python code
and this is the HTML template to be shown on the VIPER App
We have implemented the main components of the VIPER suite. We need your help with turning them into a finished product.
The VIPER suite production plan is organized according to the following main activities:
With this campaign, we do not want to give you just a set of software tools, but also a reliable and professional support service together with comprehensive documentation.
We have already solved the major challenges concerning the VIPER VM development. At the moment, a version of the VIPER VM runs on Arduino DUE, Spark Core and UDOO. Porting to the Spark Photon has started, and we aim to have a full release in case of a successful campaign in June 2015.
The TOI Shield has already undergone a full development cycle, and we are currently testing the second prototype. We need your help to finalize the testing procedure and scale up the production!
The VIPER App skeleton is completed and the alpha release is working fine. We are designing a very simple user interface and we have already started the development of a VIPER native SDK for Android. We need your help to finalize and document these modules and also to start the iOS SDK development!
The VIPER IDE beta release is up and running. We are using it to develop our example code and to debug the VIPER VM. We need to finalize by performing rigorous validation and documenting the code.
Depending on the funds raised, we plan on reaching the following milestones:
Wanna know more about VIPER’s past, present and future? Here you can see the main steps we took to make VIPER ready for Kickstarter! Help us cross the last mile, and picture yourself developing with VIPER in a few months’ time.
There are various ways to support VIPER. Become a SUPPORTER and you will receive a TOI Shield in June or, if you want to explore the power of the new Spark Photon plugged on the TOI Shield you can apply for the PHOTONIC SUPPORTER.
If you are planning to use VIPER for professional uses we can provide you a dedicated design support through the DESIGNER pledges. In one hour of dedicated Hangout video call and with some back-office activities, we will help you in designing your VIPER Python smartification code and also in using the TOI Shield in the smartest way!
We strongly believe in the value of education, therefore thanks to our high-value EDU pledge, you can viperize your class.
Are you Bu$ine$$ oriented individual? Want to smartify your commercial products? The last three pledges are for you! If you are a company, you can contact us for a Company Commercial License.
Special Offer: Do you like Spark devices as we do? Have you already backed an Electron or are you going to do that? All our backers who backed also the Electron will receive an additional TOI shield for free. So you can plug the Electron onto one TOI shield, your Core or Photon or Arduino on the other, program all of them in Python and join the M2M2U revolution.
We are asking your contribution to transform an already working environment into a professional platform that will be more stable, reliable and secure.
We chose Kickstarter because here is where exciting projects like UDOO, Spark Core, Micro Python, Espruino and others have become successful products. The Kickstarter community was the first to support the IoT revolution, and we believe that you are the right people to call upon to extend the IoT revolution to a wider audience.
We're a team of engineers, designers, and creatives who want to remove the barriers still existing between a brilliant idea, and realizing a working interactive object.
Gabriele Montelisciani, PhD, CEO, is a management engineer with specific expertise on methods and tools for early stage innovation, business modeling and management. He takes care of industrial collaboration, new projects and VIPER licences.
Daniele Mazzei, PhD, Electronics and System Integration Designer, has a PhD in robotics and his research aims at investigating the social and empathic link between humans and robots or machines. He helps companies and designers in converting rough ideas into terrific products.
Giacomo Baldi, Software Architect, is a computer scientist and medical doctor! He developed from scratch all our core software. Giacomo provides the soul for your new products.
Gualtiero Fantoni, PhD, Products Designer, is a Professor of mechanical engineering at University of Pisa, working on advanced robotic and mechanical design. He loves the challenge of designing impossible products. Any suggestion?
Raymond Garcia, Executive Manager, is an entrepreneur with over 20 years of global experience in creating business value with innovative ICT products and services. He looks after the most effective ways to allow our customers to make money by using VIPER.
Risks and challenges
Thanks to years of professional and academic successes in conceiving and managing new software and hardware development projects, the team is confident that the VIPER Suite will be released on schedule.
Thus, in order to release VIPER on a large scale, the last challenge is the code optimization and documentation. In addition the pledges will allow us to develop the VIPER support system based on live chats, that will be launched on June 2015.
The TOI Shield is the only part of the VIPER campaign that will be outsourced. However we are confident that the production of a simple board like as our shield is nowadays state of the art of the current electronic production. The TOI Shield doesn’t include any special component which could influence or block the timeline of the board production.
Progress updates will be notified to all our backers, including any possible obstacles on the planned software release timeline.
Micro Python and PyMite are two wonderful pieces of code aiming at porting Python into the embedded world. They are very faithful to the cpython implementation and both include a parser and a compiler so you can upload python scripts on your board.
VIPER aims at reducing the resource usage, therefore we removed the parser and the compiler from the boards, they can reside on your development machine and maged through the VIPER IDE.
In terms of resource usage, VIPER uses less space per object compared both to MicroPython and PyMite. As for speed, we are doing various tests, this is why we need your support!
The VIPER VM is built on top of ChibiOS/RT. However they are loosely coupled. VIPER VM just needs a threading mechanism supporting priorities and semaphores, a way to disable threading when necessary (as during garbage collection) and some recurring timers. Also, VIPER VM needs access to the board peripherals possibly via portable drivers. All this machinery is excellently provided by ChibiOS/RT, however it is possible to switch to another embedded RTOS. However, we have a strong professional partnership with the ChibiOS team that we would like to improve making VIPER and ChibiOS the new protagonists of embedded programming!
If this campaign will success the entire VIPER open source code will be published on github in May 2015.
The VIPER virtual machine alone needs around 60-70k of flash at minimum, and it grows as you add drivers (e. g. Wifi, cryptography, double precision math, etc...). The remaining flash is used to store Python bytecode, so an additional 30-40k will be needed for very big Viper scripts, with 10k being the usual size.
We have a smart VIPER compiler in the oven and we think it will reduce bytecode size by a factor of 2, but we need you to make it happen!
Ram usage varies mainly on the number of threads needed: with 4 threads it takes 6-8k of ram. Ram usage however can be fine tuned in custom virtual machines (see the stretches!) by setting the size of serial, usb, net buffers and many other parameters.
In summary, the specs of the Spark Core are the minimum requirements, namely 128k of flash and 20k of ram.
The VIPER APP is both a monitor and a touch interface for your project.
It renders a HTML5 page defined in a Python module acting as a template.
VIPER has been developed to run on microcontrollers while microprocessor board (where linux and/or Android can be executed) are used in VIPER projects to run the VIPER App and/or the VIPER IDE.
Nevertheless VIPER can be ported on the RaspberryPI. We didn't mention it in the campaign because there is still a lot of work to be done in that direction and we can't set a specific deadline.
Porting VIPER to the Raspberry requires the coding of an abstraction layer between VIPER VM and the underlying Linux operating system that mimics the behaviour of a RTOS. ChibiOS (the RTOS we use) provides a "simulator" that allows to test ChibiOS programs on a normal PC without flashing them on microcontrollers. The ChibiOS simulator can be used also as VIPER runner for the RaspberryPi but all the drivers necessarily to link it to the RaspberryPI peripherals need to be written.
The testing of the PC simulator is on our todo list while the RaspberryPI drivers development is currently a "nice to have" feature.
However, depending by the result of the campaign and by the commitment of the VIPER community all these features can be implemented.
VIPER components are open source and released under GPL3 and Apache2 licenses depending on the used libraries and codes.
If you are an individual designer or developer, you can use VIPER in your projects and installations releasing within the original license claiming VIPER in your code.
If you are an individual designer or developer and you want to use VIPER in your commercial products, the Single Designer Commercial License gives you rights for no claims and royalties. The commercial license is also associated with a VIPER Commercial Release which will contains a highly debugged version of the components together with a set of closed sources modules and board portings you can buy separately.
No. The "Single Designer Commercial License" pledge is not available to companies in any way or form and can't be refunded by employers. If you, as an individual, are backing a commercial license using your own funds, then the Single Designer Commercial license is right for you. If you are a company, you can contact us for a Company Commercial License.
Support this project
- (32 days)