-
Notifications
You must be signed in to change notification settings - Fork 108
Ideas for Google Summer of Code 2016
If you are a student and would like to make a proposal for Soletta™ Project Organization on GSoC program please read this page carefully.
Please use the proposal template when submitting. We suggest to talk to us before your final submission so potential mentors could help you to improve them.
You may also be interested to take a look at Soletta project's Quickstart page and see more information about ideas on our list archives before asking for more details.
If you're looking for simple tasks to understand a bit more about Soletta project, there are some easy tasks and documentation tasks in our tracker.
- Templates
- List of ideas
- Communication protocols:
- Porting
- Editor
- Implement auto-complete in Soletta Dev-App
- [Support the development of custom nodetypes] (#support-the-development-of-custom-nodetypes-in-soletta-development-application)
- Tools
- Bindings
- Nodes
- Others
Students, when submitting proposal, please try to provide the following items:
- Proposal Description - explain what do you want to do and reasons you believe it may beneficial for Soletta Project, for the open source community or even for IoT developers (Soletta project users).
- Project deliverables - please be to the point. A list of items is enough. It should be accomplished on Google Summer of Code timeline (about 3 months). So be conservative, even experienced engineers often underestimate tasks. If you want to set stretch goals with extra deliverables that you're not promising to deliver, but eventually you'll do if you have time (and that won't be considered for approval purposes).
- Implementation - on this section you may provide all technical details you have on mind. You should mention tools you intend to use (if any), development approaches. Make us feel confident you have a clear vision of how you are going to execute your proposal.
- Timeline - very important sections. Set some milestones for your deliverables here. Despite there are only to mandatory milestone (the mid-term and final evaluations), it's much better for you and your mentor if you is able to break your task on smaller parts. So if you start to get behind the schedule we can't help you to get back to trails before it's too late.
- About me - brief description of your educational and technical background. What are you studying? Which areas do you like? Are you contributing to other projects? Were you a GSoC student in the past? Any evidences that may show you're able to complete your job and that you're the best to do it counts here. Also please add contact information. IRC nick, email, IM.
Let's say you've read the ideas list and really liked the idea of creating Python bindings for Soletta.
Let's suppose you love to code in Python, you like to hack around with makers boards, but you never head about Soletta framework before - that's fine, it's a new technology.
You could write something in the lines of (just ideas - we expect you to elaborate on that):
- Deliverables - tangible stuff:
- List of Soletta subsystems that are provided by well established Python modules. Since they're provided already, there is no need to expose them. Some Soletta framework's core API won't be there for sure, like the flow and I/O systems - it could be also done as part of the proposal or community bonding period ;)
- Specification of Soletta framework's Python API - how should look like. Node.js specification may be used as reference.
- mainloop integration
- I/O module work in progress branch with a sample using GPIO
- full working I/O module
- flow wrappers
- Stretch goals:
- module for OIC communication protocol
- Timeline (please set specific dates instead of weeks after program beginning and check ):
- modules list - 10 May
- API Spec - 30 May
- mainloop - 15 June
- mid term evaluation - 27 June
- I/O wip - 30 June
- I/O full - 15 July
- flow wrappers - 10 August
This template should be used by Soletta developers adding ideas in this page.
Mentors: Bruno Dilly, Gustavo Lima ...
Difficulty: [Easy|Medium|Hard]
Short description of the idea (1-3 paragraphs)
Requirements:
- Language
- Protocol
- Technology
- [Basic|Heavy] understanding of something
Long description (optional)
Mentors: Bruno Dilly
Difficulty: Medium
Soletta supports many OSes:
- Linux
- Zephyr
- RIOT
- Contiki
Idea here is to do the same on top of Brillo, making sure Soletta subsystems are properly coupled with Brillo stacks. For example, Soletta provides an API to trigger and report updates, that would need a specific implementation for Brillo update core system.
The first step on this task would be to go through Soletta components and evaluate which requires specific implementations for Brillo and which can go with regular Linux implementations.
Please get familiarized with Soletta project's porting guide before writing a proposal for this idea.
Requirements:
- Knowing C is mandatory
Mentors: Bruno Dilly, Gustavo Barbieri, Rodrigo Chiossi
Difficulty: Medium
Create Python bindings for Soletta.
Soletta provide C API covering many aspects required by an IoT product. It has API to deal with mainloops, I/O, network, crypto, some parsers, and sure, to deal with flows (see flow-based-programming).
But many of these areas are covered by well established Python modules. So first thing to do is identify which Soletta modules should be provided. Maybe making it possible to deal with flows and I/O is enough.
Some tools can be used to help on this task, like SWIG. But a common pitfall when writing language bindings is to end up with a C API written on other language. So Python types and idioms must be taken on consideration. Soletta framework's Python API need to properly feel like a Python API, so Python coders will feel comfortable writing code on it.
Requirements:
- Previously knowledge about Python is highly recommended. Don't need to be an expert, but should be comfortable with Python programming idioms.
Long description (optional)
Mentors: Flavio Ceolin, Ricardo Gonzaga
Difficulty: Medium
Allows Soletta node's type development using python. Soletta already supports the development of metatypes using javascript.
Requirements:
- Previously knowledge about Python is highly recommended. Don't need to be an expert, but should be comfortable with Python programming idioms. Also would be nice a general knowledge about mainloop.
Long description (optional)
Mentors: Bruno Dilly
Difficulty: Medium
Write Go bindings for Soletta. Please see Python bindings idea, it's pretty much the same thing and I don't want to repeat myself.
Requirements:
- Previously knowledge about Go is highly recommended. Don't need to be an expert, but should be comfortable with Go programming idioms. We don't want to end up with a C API on Go.
Long description (optional)
Mentors: Flavio Ceolin, Ricardo Gonzaga
Difficulty: Medium
Allows Soletta node's type development using Go. Soletta already supports the development of metatypes using javascript.
Requirements:
- Previously knowledge about Go is highly recommended. Don't need to be an expert, but should be comfortable with Go programming idioms. Also would be nice a general knowledge about mainloop.
Long description (optional)
Mentors: Ederson de Souza, Ricardo Gonzaga
Difficulty: Medium
Allows Soletta node type development using Lua. Soletta already supports the development of metatypes using javascript.
Requirements:
- Previously knowledge about Lua is highly recommended. Don't need to be an expert, but should be comfortable with Lua programming idioms.
- General knowledge about mainloop;
- C programming language.
Mentors: Leandro Pereira
Difficulty: Medium
Port Soletta to run on cheap ESP8266 modules. It's already possible to run a Lua runtime on them, so it must be possible to run Soletta as well. Modules can be obtained from online stores for about $3 with S&H included, which makes it a very desirable target.
Requirements:
- Language: Good knowledge of C.
- Cross compilation experience not required but desirable.
Mentors: Bruno Bottazzini
Difficulty: Hard
Today Soletta Dev-App allows to use the default Soletta nodetypes[1]. Although this list of Nodetypes is extensive, the Soletta developer may want to add new features that it is not covered.
The Soletta Dev-App's editor should allow the creation of a custom node-type project in which the custom nodetype may be written in C or Javascript. We recommend to choose what language to give support first.
Beyond of allowing the creation of the project, the editor should manage syntax errors and run the properly commands to append this new nodetype to the Soletta framework. Treating all the exceptions that these may cause.
In the end the user will be able to use the new custom node inside of a FBP program.
[1] - http://solettaproject.github.io/docs/nodetypes/
Requirements:
- Language: Knowledge in Javascript and/or C. Experience with NodeJS, AngularJS is required
Mentors: Bruno Bottazzini
Difficulty: Easy
Auto-complete the code in the Soletta Development Application editor while the FBP is being programmed.
It's possible to get what nodetypes Soletta has. Now it will have to get these nodetypes, processing it and make auto-completion tips for the users when they are programming with Soletta Dev-App. We can also auto-complete the syntax to make the FBP development easier and faster.
The auto-complete should have the same behavior as the majority IDE. It will open a box allowing the user of Soletta Dev-App to choose what code to be completed.
Requirements:
- Language: Knowledge in Javascript. Experience with NodeJS, AngularJS or Jquery would be good
Mentors: Flavio Ceolin, Ivan Briano
Difficulty: Medium
Soletta already has a basic port for Contiki, it means build integration, mainloop and basic IO (only GPIO). It's missing network support and others IO, such as, I2C and SPI.
Requirements:
- Language: Good knowledge of C.
- Cross compilation experience not required but desirable.
Mentors: Vinicius Gomes, Andre Guedes
Difficulty: Medium
In Bluetooth Smart (also known as Bluetooth Low Energy) the most interoperable way of communicating with devices is using the GATT protocol. GATT provides a low overhead protocol, with high level concepts (services, characteristics, decriptors) ideal for low power devices, which may be coin cell battery operated.
The Bluetooth Special Interest Group (SIG) already defines many protocols implemented on top of GATT for many common applications[2].
sol-gatt will provide a high-level API (initially for Zephyr[3] and Linux)
for registering and manipulating local and remote services and characteristics.
Requirements:
- C programming language experience;
- Knowledge of networking programming, Bluetooth technology has many analogs with TCP/IP/Ethernet;
[1] https://learn.adafruit.com/introduction-to-bluetooth-low-energy/gatt
[2] https://www.bluetooth.com/specifications/adopted-specifications
[3] https://www.zephyrproject.org/
Mentors: Murilo Belluzzo
Difficulty: Easy
Add the capability to attach to sol-fbp-runner remotely (ip:port) and receive the inspection output for the flow being executed as well the logging messages.
Requirements:
- C programming language experience;
- Knowledge of networking programming;
Mentors: Vinicius Gomes
Difficulty: Medium
AllSeen[1] is a notable protocol in the IoT market, AllJoyn is the implementation of the protocol, providing a unified way for discovering devices and services over multiple transports.
Requirements:
- C programming language experience;
- Knowledge of networking programming;
[1] https://allseenalliance.org/
Mentors: Guilherme Iscaro
Difficulty: Medium
Soletta has its own implementation of the lightweight machine to machine (LWM2M) [1] protocol. The LWM2M protocol is used to remotely control IoT devices, these include: Firmware updates, status reporting and etc. Although Soletta already implements the LMWM2M server and the LWM2M client, Soletta implementation is lacking some main features, that are: a bootstrap server, message encryption and data access control.
Expected Deliveries:
- A LWM2M bootstrap server.
- CoAP message encryption.
- Data access control.
Requirements:
- C programming language experience.
- LWM2M knowledge is desirable.
Mentor: Leandro Pereira
Difficulty: Easy
Firmata is a protocol for communicating with microcontrollers from software on a computer (or smartphone/tablet, etc). The protocol can be implemented in firmware on any microcontroller architecture as well as software on any computer software package (see list of client libraries below).
This task would make it possible to have Firmata node types available to Soletta project's Flow Based Programming engine, both to allow Soletta to control other devices, and to be controlled by other devices. Full documentation and links to implementations are available here.
Requirements:
- Ability to program in C
- Have an Arduino or other device which is compatible with Firmata to test the implementation
Mentors: Vinicius Gomes, Andre Guedes
Difficulty: Extra hard
Soletta is a library to offer developers a framework for making IoT products with which they can easily write software for diverse devices, providing a high level API which users can use to target many different platforms, among these: PID1 processes on barebones Linux kernel (known as micro-Linux), Riot-OS, Contiki and Zephyr. But what if we don’t even need the services provided by the OS?
For the Intel Quark Microcontrollers family, Intel has open-sourced QMSI[1] (Quark Microcontroller Software Interface), which provides a consistent API for interfacing with peripherals and such, giving total control of the platform to developers. All this control implies extra care when writing softwares, that should be employed in every software written.
Soletta aim is clear, it's a framework for building devices. What's a better way than to build devices using a consistent and high level interface and have the generated code run comfortably on the smallest Quark Microcontroller? The increased growth of the IoT market is putting even more pressure in development time, so that extra care when development applications with full control of the hardware is better employed when it can be re-used, Soletta fills this niche nicely.
Requirements:
- C programming language experience;
- Low level programming experience;
[1] http://github.com/01org/qmsi
Mentors: Gustavo Lima Chaves
Difficulty: Easy
Soletta already supports OAuth 1 authentication (it's got an
oauth/v1 node),
and using that infrastructure, the
twitter node.
We lack, though, a Facebook node with the same functionality, i.e. to
post and get timeline entries. The get there, we'd have to add to
Soletta OAuth 2 infrastructure. The task consists of exposing such
infrastructure as an oauth/v2 node as well, and then coding the
facebook node.
Soletta also has a thingspeak node, that implements the ThingSpeak open data platform API. With this task, the student would also implement a dweet.io node, which is a similar API.
With these 3 tasks (oauth 2, facebook and dweet nodes), Soletta would come one more step closer to completeness with regard to communications nodes.
Requirements:
- Knowing C is mandatory
Mentors: Bruno Dilly, Guilherme Iscaro, Otavio Pontes
Difficulty: Easy
On Soletta Machine Learning there are backends for neural network and fuzzy logic based algorithms to be run on client side.
It's nice for some product architectures, when you don't want to go to a cloud to perform machine learning processing. But in many cases, it's complete ok, and even wanted that the data goes to a cloud and get processed there, specially because some IoT products will run on very constrained hardware.
So this idea consist to add one or more backends for machine learning services, like Amazon Machine Learning or Microsoft Azure.
Requirements:
- Machine Learning knowledge isn't mandatory, but may help to speed up things.
Soletta is missing media element support which would be very useful in some IoT applications.
This task would consist of writing basic audio and video end points (sink and sources) to Soletta to be used either through Soletta C-API or with Soletta flow based programming.
As this task could be very tedious it should be started with a minimal requirement like "record raw audio with fixed parameters into a file". If the implementation proceeds fast the student can move to video, more advanced media pipeline, cloud interfaces, wireless sensors etc.
This task is mainly intended for Linux-type full featured operating systems, which means the student can do the implementation with a main stream laptop (which usually has audio and probably camera also). Again if the task proceeds fast there's a possibility to move to smaller operating systems and micro controllers.
Mentors: Bruno Dilly, Jaska Uimonen
Difficulty: Medium to Hard
Requirements:
- Knowing C is mandatory
- Basic knowledge of audio and video formats and processing will help.
- Previous knowledge of linux media API's like alsa and v4l2 are a plus.