Difference between revisions of "BeagleBoard/GSoC/Ideas"

From eLinux.org
Jump to: navigation, search
(Ideas)
(Reset for 2019)
Line 7: Line 7:
  
 
=Welcome!=
 
=Welcome!=
BeagleBoard.org is applying to be a mentoring organization in the [[BeagleBoard/GSoC|Google Summer of Code]] for 2018!  Below, we're collecting project ideas for the GSoC-2018.
+
BeagleBoard.org is applying to be a mentoring organization in the [[BeagleBoard/GSoC|Google Summer of Code]] for 2019!  Below, we're collecting project ideas for the GSoC-2019.
  
 
==What is Google Summer of Code?==
 
==What is Google Summer of Code?==
Line 17: Line 17:
  
 
==BeagleBoard.org Background==
 
==BeagleBoard.org Background==
BeagleBoard.org is a volunteer organization that seeks to advance the state of open-source software on [http://en.wikipedia.org/wiki/Open-source_hardware open-source hardware] platforms capable of running high-level languages and operating systems (primarily Linux) in embedded environments. Born from taking mobile phone processors and putting them on low-cost boards to build affordable desktop computers, BeagleBoard.org has evolved to focus on the needs of the "maker" community with greater focus on the I/O needed for controlling motors and reading sensors to build things like robots, 3d printers, flying drones, in-car computer systems and much more. Past BeagleBoard.org GSoC projects included [[BeagleBoard/GSoC/2014_Projects#Project:_BotSpeak_PRU_Firmware|creating an interpreter for tiny CPUs]], [[BeagleBoard/GSoC/2014_Projects#Project:_PyBBIO|adding SPI and sensor support to Python]], [[BeagleBoard/GSoC/2014_Projects#Project:_Bone101|an HTML and git based tutorial sharing environment]], [[BeagleBoard/GSoC/2014_Projects#Project:_BeaglePilot|porting autopilot software to Linux]], [[BeagleBoard/GSoC/2014_Projects#Project:_BeagleLogic|an open source 100MHz 14-channel logic analyzer]], [[BeagleBoard/GSoC/2014_Projects#Project:_Android_Remote_Display|using Android tablets as Linux displays]], [[BeagleBoard/GSoC/2013_Projects#Linux_ADC_IIO_Support|putting ADC support in Linux under the IIO framework]], [[BeagleBoard/GSoC/2013_Projects#Android-based_Boot|using Android phones as a network boot source]], [[BeagleBoard/GSoC/2013_Projects#Userspace_Arduino|Running Arduino code on Linux]], [[BeagleBoard/GSoC/2013_Projects#Robot_Operating_System|Robot Operating System support within the Yocto Project build system]], [[BeagleBoard/GSoC/2013_Projects#Minix_I2C|Minix I2C support]], [[BeagleBoard/GSoC/2010_Projects/C6Run|an RPC framework for heterogeneous processor communication]], [[BeagleBoard/GSoC/2010_Projects/USBSniffer|a transparent USB packet sniffer]], [[BeagleBoard/GSoC/2010_Projects/XBMC|ARM optimizations for XBMC]], [[BeagleBoard/GSoC/2010_Projects/FFTW|ARM optimizations for FFTs]], [[BeagleBoard/GSoC/2010_Projects/Pulse_Width_Modulation|make-shift pulse-width-modulation]] and [[BeagleBoard/GSoC/2010_Projects/OpenCV|RPC optimizations for OpenCV]]. BeagleBoard.org has benefited from sponsorship from Texas Instruments, [[CircuitCo]], Digi-Key, element14 and others, but avoids any dependence on that sponsorship for sustaining the effort. The project has evolved over the past few years with over 1,000,000 boards in circulation with developers worldwide and strong roots in the Linaro, Yocto Project, Angstrom Distribution, Debian and Linux communities---and support for running most major Linux distributions including Ubuntu, Android, Fedora, ArchLinux, Gentoo, Buildroot and many more.
+
BeagleBoard.org is a volunteer organization that seeks to advance the state of open-source software on [http://en.wikipedia.org/wiki/Open-source_hardware open-source hardware] platforms capable of running high-level languages and operating systems (primarily Linux) in embedded environments. Born from taking mobile phone processors and putting them on low-cost boards to build affordable desktop computers, BeagleBoard.org has evolved to focus on the needs of the "maker" community with greater focus on the I/O needed for controlling motors and reading sensors to build things like robots, 3d printers, flying drones, in-car computer systems and much more. Past BeagleBoard.org GSoC projects included [[BeagleBoard/GSoC/2014_Projects#Project:_BotSpeak_PRU_Firmware|creating an interpreter for tiny CPUs]], [[BeagleBoard/GSoC/2014_Projects#Project:_PyBBIO|adding SPI and sensor support to Python]], [[BeagleBoard/GSoC/2014_Projects#Project:_Bone101|an HTML and git based tutorial sharing environment]], [[BeagleBoard/GSoC/2014_Projects#Project:_BeaglePilot|porting autopilot software to Linux]], [[BeagleBoard/GSoC/2014_Projects#Project:_BeagleLogic|an open source 100MHz 14-channel logic analyzer]], [[BeagleBoard/GSoC/2014_Projects#Project:_Android_Remote_Display|using Android tablets as Linux displays]], [[BeagleBoard/GSoC/2013_Projects#Linux_ADC_IIO_Support|putting ADC support in Linux under the IIO framework]], [[BeagleBoard/GSoC/2013_Projects#Android-based_Boot|using Android phones as a network boot source]], [[BeagleBoard/GSoC/2013_Projects#Userspace_Arduino|Running Arduino code on Linux]], [[BeagleBoard/GSoC/2013_Projects#Robot_Operating_System|Robot Operating System support within the Yocto Project build system]], [[BeagleBoard/GSoC/2013_Projects#Minix_I2C|Minix I2C support]], [[BeagleBoard/GSoC/2010_Projects/C6Run|an RPC framework for heterogeneous processor communication]], [[BeagleBoard/GSoC/2010_Projects/USBSniffer|a transparent USB packet sniffer]], [[BeagleBoard/GSoC/2010_Projects/XBMC|ARM optimizations for XBMC]], [[BeagleBoard/GSoC/2010_Projects/FFTW|ARM optimizations for FFTs]], [[BeagleBoard/GSoC/2010_Projects/Pulse_Width_Modulation|make-shift pulse-width-modulation]] and [[BeagleBoard/GSoC/2010_Projects/OpenCV|RPC optimizations for OpenCV]]. BeagleBoard.org has benefited from sponsorship from Texas Instruments, Circuitco, Digi-Key, element14 and others, but avoids any dependence on that sponsorship for sustaining the effort. The project has evolved over the past few years with over 1,000,000 boards in circulation with developers worldwide and strong roots in the Linaro, Yocto Project, Angstrom Distribution, Debian and Linux communities---and support for running most major Linux distributions including Ubuntu, Android, Fedora, ArchLinux, Gentoo, Buildroot and many more.
  
BeagleBoard was inspiration for Raspberry Pi[http://www.linuxuser.co.uk/features/raspberry-pi-interview-eban-upton-reveals-all] and is available for about $25 through over 30 distributors world-wide (and is even available at Micro Center in the USA), but is more than a throw-away computer. It is an instance of true open hardware, exposing users to the broader world of electronics, demystifying computers and fostering an environment of clones that have changed the industry for good.
+
BeagleBoard was inspiration for Raspberry Pi[https://web.archive.org/web/20120302232755/www.linuxuser.co.uk/features/raspberry-pi-interview-eban-upton-reveals-all] and PocketBeagle is available for about $25 through over 30 distributors world-wide (and is even available at Micro Center in the USA), but is more than a throw-away computer. It is an instance of true open hardware, exposing users to the broader world of electronics, demystifying computers and fostering an environment of clones that have changed the industry for good.
  
 
Students will be expected to demonstrate an understanding of cross-compiling before being accepted, but support for demonstration is available through the IRC channel that typically has approximately 150 online chatters logged on at any time, most with sufficient experience to explain the process.
 
Students will be expected to demonstrate an understanding of cross-compiling before being accepted, but support for demonstration is available through the IRC channel that typically has approximately 150 online chatters logged on at any time, most with sufficient experience to explain the process.
Line 27: Line 27:
 
Additional hardware will be provided depending on need and value.
 
Additional hardware will be provided depending on need and value.
  
For more information, check out http://beagleboard.org and http://beagleboard.org/brief.
+
For more information, check out https://beagleboard.org and https://beagleboard.org/brief.
  
 
==Students looking for ideas==
 
==Students looking for ideas==
Line 55: Line 55:
  
 
==Idea template==
 
==Idea template==
Description
+
Please place your idea in a suitable section.
 +
 
 +
===Summarizing project name===
 
<br>
 
<br>
  
Line 66: Line 68:
  
 
=Ideas=
 
=Ideas=
== Offline SmartSpeaker with BeagleBone ==
+
Throughout all of these ideas, contributions specifically contributing to the Linux kernel will be given extra attention. The ability for the BeagleBoard.org community to leverage software created out of GSoC is greatly expanded when those contributions land in the upstream Linux kernel where they are shared across many platforms and maintained by the broadest possible support community. In each application area, consideration how a kernel module submitted upstream could be a central component should be considered. In lieu of contributing to the Linux kernel, finding an upstream project, like ArduPilot, RTEMS, DonkeyCar, etc., where there is already an active community, is strongly desired. Of course, some projects are very BeagleBone-specific, like Adafruit_BBIO and BoneScript, and those projects do have an active user community and contributions are welcome in those areas, but more weight is given the more broad the impact of the coding project is. We've seen bug fixing projects to be very productive as well.
''Goal'':  The big picture goal is a entire offline smart speaker system using a BeagleBone (or another member of the Beagle family. Within the timeframe of GSoC, the goal is to have a piece (open to definition in the application) of the smart speaker system implemented. Most current implementations of a smart speaker system perform most of the processing in the cloud. This has a lot of potential ramifications including but not limited to privacy and other abuses of the dataset. The purpose of this is to provide a possible offline implementation. Piece to focus on for this project are: Trigger word detection and Voice recognition. Ideally, this should run on the Cortex-A8 based Beagles (BeagleBone, BeagleBoard Classic, BeagleBoard Xm) for maximum flexibility. The BeagleBones can initially use a USB sound card.

<br>
 
''Hardware Skills'':  Minimal. Ability to connect a microphone and speaker<br>
 
''
Software Skills'':  C/C++ programming mainly. Ability to work with different build systems (Cmake/autoconf/etc).  ;  Linux device drivers
<br>
 
''Possible Mentors'': Hunyue Yau<br>
 
''Upstream Repository'': <br>
 
''References'':
 
 
 
== Update PRU Python loader ==
 
''Goal'':  Provide an update to PyPRUSS to support remote-proc loading and the latest BeagleBone images.

<br>
 
''Hardware Skills'':  Minimal<br>
 
''
Software Skills'':  Linux, C and Python programming
<br>
 
''Possible Mentors'': Jason Kridner, Kumar Abhishek<br>
 
''Upstream Repository'': https://github.com/beagleboard/linux, https://github.com/beagleboard/pypruss<br>
 
''References'':  https://bitbucket.org/intelligentagent/pypruss, https://beagleboard.org/latest-images
 
 
 
== Connected PocketBeagle ==
 
''Goal'':  Have reference application notes, code, example, and “How-To” document for each type of wireless communications for PocketBeagle.  Wireless protocols should include at a minimum:  802.11 (WiFi), BLE, Cellular (GSM or LTE), NFC, ZigBee and GPS.  Each should have easy to use references for users building projects to use as a cut/paste library.

<br>
 
''Hardware Skills'':  Prototyping skills with MikroElektronika Click Boards<br>
 
''
Software Skills'':  C and Python programming;  Linux device drivers
<br>
 
''Possible Mentors'':<br>
 
''Upstream Repository'': https://github.com/beagleboard/linux<br>
 
''References'':  https://www.mikroe.com/click/wireless-connectivity, https://github.com/beagleboard/bb.org-overlays, https://github.com/beagleboard/linux
 
 
 
== Getting Started Materials for PocketBeagle ==
 
''Goal'':  Update the BeagleBone getting started materials for PocketBeagle.  This includes having Bone101 updated to work with PocketBeagle and updates BeagleBone Blue Control Libraries to work with PocketBeagle.
<br>
 
''Hardware Skills'':  Basic prototyping skills
<br>
 
''Software Skills'':  C, Assembly, and JavaScript programming.  Linux
<br>
 
''Possible Mentors'': Jason Kridner<br>
 
''
Upstream Repository'': https://github.com/beagleboard/bone101<br>
 
''
References'':  https://beagleboard.org/support/bone101 and http://strawsondesign.com/#!manual-source-code
 
 
 
== Modern “Speak & Spell” using PocketBeagle ==
 
''Goal'':  To celebrate the 40th anniversary of the “Speak & Spell” from Texas instruments, create an updated “Speak & Spell” using a PocketBeagle.
 This should be a general Linux application that can be reproduced and should not be a one-off build.<br>
 
''Hardware Skills'':  Prototyping / Re-braining electronics
<br>
 
''Software Skills'':  C and Python programming; Linux<br>
 
''
Possible Mentors'':<br>
 
''
Upstream Repository'':<br>
 
''
References'':  https://en.wikipedia.org/wiki/Speak_%26_Spell_(toy)
 
 
 
==BeagleBone Audio Platform==
 
''Goal'': [https://bbb.io/bone BeagleBone] and/or [https://bbb.io/x15 BeagleBoard-X15] as Audio Platform (e.g. effects box for musicians)<br>
 
''Hardware Skills'': New audio and hardware UI capes<br>
 
''Software Skills'': Audio and UI applications<br>
 
''Possible Mentors'': Robert Manzke, Henrik Langer, tbd<br>
 
''Upstream Repository'': [https://github.com/beagleboard/linux Beagle Kernel] or Use Case repo<br>
 
''References'': Audio Project from 2016 [[BeagleBoard/GSoC/2016_Projects]], [http://www.creative-technologies.de/linux-based-low-latency-multichannel-audio-system-2/ CTAG face2|4], http://bela.io/, [[CircuitCo:Audio_Cape_RevB|Beagle Audio Cape]]
 
 
 
==BeagleBone synchronous data collection==
 
''Goal'': Synchronous data collection via the PRU. This complements BeagleLogic which asynchronously acquires data.<br>
 
''Hardware Skills'': Understanding of a synchronous signal<br>
 
''Software Skills'': C and assembly programming<br>
 
''Possible Mentors'': Hunyue Yau, Kumar Abhishek<br>
 
''Upstream Repository'': <br>
 
''References'': [http://beaglelogic.net/ BeagleLogic] from prior years.
 
 
 
==BeagleBone GPU offload==
 
''Goal'': Sample programs to utilize the GPU for computations. The GPU on most of the [https://bbb.io/bone BeagleBone]/[https://bbb.io/x15 Board] are limited to OpenGL ES 2; Goal is to provide sample programs to show using GLES2 for computations.<br>
 
''Hardware Skills'': N/A<br>
 
''Software Skills'': OpenGLES<br>
 
''Possible Mentors'': Hunyue Yau<br>
 
''Upstream Repository'': possibly [https://github.com/patriciogonzalezvivo/thebookofshaders thebookofshaders] <br>
 
''References'': http://thebookofshaders.com/
 
 
 
==BeagleBone/Beagle board PRU DMA ==
 
''Goal'': Create a sample program to demostrate using EDMA on the PRU to transfer data to and from the main (DDR) memory with a Linux host. Most existing code utilizes(wastes) the 2nd PRU on the PRUSS for data xfer. Using DMA can allow the PRU to be used for other purposes.<br>
 
''Hardware Skills'': Datasheet/specification reading<br>
 
''Software Skills'': Assembly language programming/Linux kernel programming<br>
 
''Possible Mentors'': Hunyue Yau<br>
 
''Upstream Repository'': N/A<br>
 
''References'': N/A
 
 
 
==BeagleBone Remote Seismometer Node ==
 
''Goal'': Working prototype remote strong motion sensor, web-based control and display. Determine "best" sensor library interface, integrate accelerometer output with QCN client software.<br>
 
''Hardware Skills'': Datasheet/specification reading, patch cables/breadboard<br>
 
''Software Skills'':Python, C++, C programming, basic understanding of serial buses, sensors and data, physical principles<br>
 
''Possible Mentors'': Stephanie Lockwood-Childs, Steve Arnold<br>
 
''Upstream Repository'': [https://github.com/VCTLabs/qcn QCN Client]<br>
 
''References'': [http://qcn.usc.edu/ quake catcher network] , [https://www.sparkfun.com/tutorials/235 generic project desc.] , [http://wiki.seeed.cc/BeagleBone_Green/ BeagleBone Green] , [http://processors.wiki.ti.com/index.php/PRU-ICSS_Remoteproc_and_RPMsg PRU-ICSS]
 
 
 
==BeagleBone Sonic Anemometer / Basic Weather Station==
 
''Goal'': Working prototype sonic anemometer using BeagleBone, high speed DAC (eg, PRUDAQ), and ultrasonic sensors.  Analyze methods for accuracy/sensitivity (eg, time-of-flight vs. phase difference) and implement "best" method. Use PRUs for independent real-time control of ultrasonics.  Example architecture and software on github (see repos and references below)<br>
 
''Hardware Skills'': Datasheet/specification reading, patch cables/breadboard/soldering (at least two), serial/debug<br>
 
''Software Skills'': C/assembly and python programming, basic understanding of serial buses, sensors and data, physical principles<br>
 
''Possible Mentors'': Stephanie Lockwood-Childs, Steve Arnold<br>
 
''Upstream Repository'': [https://github.com/thetransformerr/beagle-sonic beagle-sonic] from prior years, also [https://github.com/herrera-luis-alberto/UChSonicAnemometer UChSonicAnemometer] from Univ of Chile.<br>
 
''References'': [http://processors.wiki.ti.com/index.php/PRU-ICSS_Remoteproc_and_RPMsg PRU-ICSS] , [http://www.cas.manchester.ac.uk/restools/instruments/meteorology/sonic/ sonic anemometer basics]
 
 
 
==BeagleBone Cubesat Software/Platform Integration==
 
''Goal'': Integrate BeagleSat "satellite" platform with existing MAVLink/autopilot framework, including previous GSoC BeagleSat magnetometer application.  Determine best autopilot platform for BeagleBone (mainly begalepilot vs. apm2) based on science experiment needs; using BeagleSat project magnetic field measurements as example, requirements include SPI burst data reads from 2 independent magnetometers (ie, use BBIO MPU9250 SPI driver for data acquisition).  Integrate navigation model with autopilot firmware and selected Beaglebone hardware and data acquisition example.<br>
 
''Hardware Skills'': Datasheet/specification reading, soldering/prototyping, serial/debug<br>
 
''Software Skills'': high-level language skills (Python, C, etc), some knowledge of micro-controller compilers and targets, kernel config/programming and serial bus interfaces (some)<br>
 
''Possible Mentors'': Stephanie Lockwood-Childs, Steve Arnold<br>
 
''Upstream Repository'': [https://github.com/nvisnjic/BeagleSat BeagleSat] , [https://github.com/mavlink/mavlink MAVLink] , [https://github.com/BeaglePilot/ardupilot BeaglePilot]<br>
 
''References'': [http://www.strawsondesign.com/#!board-features BeagleBone Blue board features] , [http://dev.ardupilot.com/wiki/building-for-beaglebone-black-on-linux/ Building (ardupilot) for BeagleBone Black on Linux] , [http://dev.ardupilot.com/wiki/mavlink-commands/ MAVLink Commands]
 
  
==BeagleBone-based Serial Terminal Server==
+
==Deep Learning==
''Goal'': Often in embedded development it is valuable to have a serial terminal server which can retain a serial port connection along with buffered past I/O separate from a typical host PC, either for longer term logging of serial port data or to enable remote management of a device via serial port. Commercial units which have this capability are very expensive. The BeagleBones have 4 highly capable UARTs exposed besides UART0 through the cape connectors and a simple cape hardware could easily enable a BeagleBone to physically have all the interfaces needed to be a serial terminal server. The cape hardware does not need to be created for this project to go forward, so long as other devices which connected to the BeagleBone terminal server used 3.3 V UARTs themselves.<br>
+
BeagleBoard-X15 has accelerators for running deep learning tasks using TIDL ([https://training.ti.com/deep-learning-tidl-overview 1], [http://www.ti.com/lit/wp/spry314/spry314.pdf 2]). We'd love projects that enable people to do more deep learning application and end-nodes and leverage cloud-based training more easily. Goal here is to create tools that make learning about and applying AI and deep learning easier. Contributions to projects like ArduPilot and DonkeyCar (DIY Robocars and BlueDonkey) to introduce autonomous navigation to mobile robots are good possible candidates.
  
This project would begin with a survey of existing software which could be adapted to provide a terminal server experience (for example something as simple as using GNU screen with some adaptations over an SSH connection to the BeagleBone) and then proceed to create software changes needed to enable such operation in an easy to use and deploy way.  This resulting (or found) software would likely end up being generic for Linux based serial terminal servers.  The end result of this project should likely be an easy to deploy SD card image to enable someone to setup a low cost serial terminal server based on a BeagleBone in only a few minutes.<br>
+
==Low-Power Wide Area Networking==
 +
A number of wireless connectivity solutions to low-cost sensor nodes exist, including things built around TI CC13x, LoRa, narrow-band LTE and other [https://en.wikipedia.org/wiki/LPWAN low-power wide area networks]. Projects that create tools and learning around these technologies should find a large user and mentor community around BeagleBone.
  
A reach goal would be to enable the cape hardware and also to potentially provide DC relays which could switch 5-12 V at 2-3 A such that development boards could be powered on and off through the same software interface as is used for the serial communications.  Since hardware is not the focus of GSoC, actual development of such hardware should not be the focus of the project itself.<br>
+
==Automation and Industrial I/O==
''Hardware Skills'': Datasheet/specification reading<br>
+
BeagleBone gets used a lot in automation tasks, be they in industrial, building, home or otherwise. Software that helps enable individual hobbyists, but can bridge into professional automation tasks, is strongly desired.
''Software Skills'': C programming/Linux kernel programming<br>
 
''Possible Mentors'': Michael Welling<br>
 
''Upstream Repository'': N/A<br>
 
''References'': N/A
 
  
==PRUs to offload processing of raw data from on-board Peripherals==
+
* MikroElectronika click board manifests for the Greybus simulator, instead of device tree overlays
''Goal:'' The goal is to be able to access on-board peripherals like the McSPI, McASP etc from the PRUs and to be able to use fetch data directly from these peripherals. This will allow to offload processing of the Raw data onto the PRUs. The project will basically involve developing C libraries for the PRUs to connect to these peripherals, developing DT overlays for the peripherals to be used and developing Drivers to reserver the device on behalf of the PRUs. <br>
+
* learning tools like BlockyTalky3 and Makecode, but with a focus on  
''Hardware Skills:'' Datasheet/Specification reading<br>
+
* open source PLC software
''Software Skills:'' C programming/Linux Kernel Programming, Assembly language<br>
 
''Possible Mentors:'' Zubeen Tolani, tbd<br>
 
''Upstream Repository:'' N/A<br>
 
'References:'' [http://git.ti.com/pru-software-support-package/pru-software-support-package/ pru-software-suppor-package] <br>
 
  
==Integrate node-beagle-boot to Chrome plug-in==
+
==Low latency and soft peripherals using co-processors==
Modify node-beagle-boot's use of node-usb calls to allow them to be replaced by Chrome USB calls and create a Chrome plug-in around it.
+
The programmable real-time units are one of the coolest features of BeagleBone. Of course, the architecture of using a main processor running a high-level operating system and co-processors running without an operating system is a general architecture. Projects that help create tools and learning around this architecture can be rather successful around BeagleBone. See https://beagleboard.org/pru.
<br>
 
''Goal:'' Boot PocketBeagle via a Chrome plug-in, download the latest image from beagleboard.org/latest-images and use the bootloaded PocketBeagle code to write that latest image to a microSD card.<br>
 
''Hardware Skills:'' some familiarity with USB architecture, knowledge of what bootloaders do and basic embedded systems concepts<br>
 
''Software Skills:'' JavaScript, Linux and browsers<br>
 
''Possible Mentors:'' Jason Kridner<br>
 
''Upstream Repository:'' TBD (https://github.com/beagleboard/node-beagle-boot)<br>
 
''References:'' https://github.com/ravikp7/node-beagle-boot, https://github.com/ungureanuvladvictor/BBBlfs, https://developer.chrome.com/apps/app_usb<br>
 
  
==Integrate node-beagle-boot into Etcher.io==
+
* low-latency audio (bela.io)
node-beagle-boot works stand-alone, but now we must complete the integration into the Etcher.io API.
+
* LED lighting (Falcon Player, PocketScroller, etc.)
<br>
 
''Goal:'' Etcher.io should boot a PocketBeagle into mass storage class mode and write the latest image from beagleboard.org/latest-images to a microSD.<br>
 
''Hardware Skills:'' understanding bootloaders, knowledge of USB<br>
 
''Software Skills:'' C, JavaScript (node.js)<br>
 
''Possible Mentors:'' Jason Kridner<br>
 
''Upstream Repository:'' TBD (https://github.com/beagleboard/node-beagle-boot)<br>
 
''References:'' https://github.com/ravikp7/node-beagle-boot, Etcher.io API<br>
 
  
==Port BeagleBone USB-based bootloader server from C to JavaScript (node.js)==
+
==Security and Privacy==
The BBBlfs project is capable of booting a BeagleBone into USB mass storage class mode. This will eventually be integrated into a variant of http://etcher.io to make an all-in-one BealgeBone flasher/updater.
+
The BeagleBoard.org community cares a lot about understanding how information is managed. Projects that open up technology for more personal control and help secure data from external manipulation are generally well accepted. Consider how you can make contributions to existing projects in this area.
<br>
 
''Goal:'' Booting BeagleBone into USB mass storage class mode should be as easy as 'npm install beaglebone-boot; cd node_modules/beaglebone-boot; npm start' and connecting the board with the BOOT button pressed via USB.<br>
 
''Hardware Skills:'' understanding bootloaders, knowledge of USB<br>
 
''Software Skills:'' C, JavaScript (node.js)<br>
 
''Possible Mentors:'' Jason Kridner<br>
 
''Upstream Repository:'' TBD (https://github.com/beagleboard/node-beaglebone-boot)<br>
 
''References:'' https://github.com/ungureanuvladvictor/BBBlfs, https://boundarydevices.com/u-boot-usb-mass-storage-gadget/, https://github.com/tessel/node-usb<br>
 
  
==Re-purpose PiTop Power Interface for BeagleBone==
+
* penetration testing (The Deck, Kali)
Port power monitor and backlight software to Beaglebone SPI interface (using prototype power cable) and integrate with standard desktop power interface (upower/pm-utils dbus abstraction).  Replace existing UI with desktop integration (ie, LXQT and XFCE power managers).
+
* self-hosted services (Freedombone)
<br>
+
* car hacking (Macchina)
 
 
''Goal'': Battery status, power/backlight control on BeagleTop running standard Debian desktop.<br>
 
''Hardware Skills'': Datasheet/specification reading, wiring.<br>
 
''Software Skills'': C and Python, some knowledge of XDG desktop specification<br>
 
''Possible Mentors'': Michael Welling, Stephen Arnold, Stephanie Lockwood-Childs<br>
 
''Upstream Repository'': [https://github.com/rricharz/pi-top-install pi-top-install]<br>
 
''References'': [https://www.freedesktop.org/wiki/Specifications/ freedesktop.org specs] [https://learn.adafruit.com/pi-top-assembly/raspberry-pi-to-base hub assembly]
 
 
 
==Fix bugs in BoneScript==
 
Run through the issues list at http://github.com/jadonk/bonescript/issues and fix them!
 
<br>
 
 
 
''Goal'': Close all issues.<br>
 
''Hardware Skills'': Wiring LEDs and simple sensors<br>
 
''Software Skills'': JavaScript and Linux<br>
 
''Possible Mentors'': Jason Kridner<br>
 
''Upstream Repository'': https://github.com/beagleboard/bonescript<br>
 
''References'': http://beagleboard.org/bonescript
 
 
 
==Port am335x_pru_package to remoteproc==
 
The am335x_pru_package is a community supported set of tools and examples on using the PRU. It includes an assembler and a C library for managing the PRU over [https://www.kernel.org/doc/html/latest/driver-api/infrastructure.html?highlight=uio#userspace-io-devices UIO]. The BeagleBoard community mostly desires to migrate PRU development to [https://www.kernel.org/doc/Documentation/remoteproc.txt remoteproc] to give the Linux kernel greater knowledge of the cores.
 
<br>
 
 
 
''Goal'': Move all examples to remoteproc, including adding elf support to pasm, adding an option to build using clpru and updating the C library to use the remoteproc interface for basic PRU control and using mmap() for a limited set of communications functions.<br>
 
''Hardware Skills'': N/A<br>
 
''Software Skills'': C, assembly, Linux kernel<br>
 
''Possible Mentors'': Jason Kridner, Kumar Abhishek<br>
 
''Upstream Repository'': https://github.com/beagleboard/am335x_pru_package<br>
 
''References'': [https://git.ti.com/pru-software-support-package v5 examples] [http://processors.wiki.ti.com/index.php/PRU_Training:_Hands-on_Labs TI Training Labs ]
 
 
 
==Add BeagleBone Pinmux/Overlay Manger to Mainline U-Boot==
 
Add a pinmux/overlay manager to U-Boot, similar to the old kernel pin manager used in 3.8.x/4.1.x kernels. This manager should read the 4 eeprom, auto load those capes, then also allow enable/disable/override functionality.  Currently we run a nasty u-boot script to load each overlay with a very basic pin manager. (see references).  Currently both the Pi and Chip boards in u-boot have a basic overlay manager already integrated.
 
 
 
''Goal'': Add a pinmux/overlay manager to U-Boot, for the BeagleBone family.<br>
 
''Hardware Skills'': N/A<br>
 
''Software Skills'': C, assembly, U-Boot<br>
 
''Possible Mentors'': Robert Nelson<br>
 
''Upstream Repository'': http://git.denx.de/?p=u-boot.git;a=summary<br>
 
''References'': https://github.com/RobertCNelson/Bootloader-Builder/blob/master/patches/v2018.01/0002-U-Boot-BeagleBone-Cape-Manager.patch
 
 
 
==Create a PRU based soft-peripheral example==
 
The PRU is a hard realtime co-processor with dedicated realtime pins. Previous GSoC have created an assortment of examples
 
and foundation pieces. However, most of them have custom interfaces. This project is to tie things together to implement
 
at least one example of using the PRU with a standard interface. For example, this can be a SPI master interface that
 
can be bound with another peripheral via DT.
 
 
 
''Goal'': Create at least one non trivial example that includes both the PRU firmware and the kernel driver interface. Utilization of remoteproc (other means of loading the firmware will be considered provided it is appropriately justified) to
 
load the firmware and control the PRU. A device driver should expose the functionality using standard kernel APIs. The example
 
should NOT be a trivial one (i.e. GPIO controller, simple input events, plain on-off LEDs) unless proper justification
 
is provided. Simple non trivial possible examples include SPI master, I2C master (potential HW issues), or UART. This project
 
includes creating the relevant PRU firmware.<br>
 
''Hardware Skills'': Some understanding of I/O is needed esp if the I2C master is choosen.<br>
 
''Software Skills'': C, assembly, Linux kernel<br>
 
''Possible Mentors'': Hunyue Yau<br>
 
''Upstream Repository'': N/A<br>
 
''References'':
 
 
 
==Reference Design For A GPIO-based Parallel Bi-Directional Bus==
 
While the BeagleBone family has a large number of pins available on their P8/P9 headers, projects requiring a large amount of GPIO I/O may still be infeasible due to pinmux conflicts with other interfaces (SPI, UARTs, etc.). The newer PocketBeagle platform is even more restricted in the number of available GPIOs for interfacing. In addition, bi-directional bus communication using GPIOs is infeasible, as each GPIO is configured for either input or output. This project will combine your hardware and software skills to address these limitations by creating a shift register-based hardware design that will allow serial streams of data going in/out of the PocketBeagle or BeagleBone family GPIOs to be mapped into a bi-directional communications bus. Some practical uses of this are for GPIO-based game controller inputs (using *lots of buttons*), communication address/data buses for interfacing with older microcontrollers and microprocessors, and providing large numbers of logical bi-directional GPIOs.
 
 
 
''Goal'': Create a hardware design will incorporate shift registers (and potentially logic level converter solutions as appropriate) to allow BB.org hardware to communicate with hardware via a parallel, bi-directional bus. Create a software design that incorporates both a kernel driver to communicate with the parallel bus and a user space application/library using ioctl() calls to communicate with this kernel driver. The kernel device tree fragment associated with the kernel driver shall configure it by specifying the number of parallel lines to use, the input/output/both direction of each bus signal, and the GPIOs allocated to the serial input/output/clock/latch signals. In addition, the device tree and kernel driver may also support specifying particular parallel bus lines as GPIO inputs that are mapped as GPIO keys.<br>   
 
''Hardware Skills'': Basic digital logic (i.e. comfortable prototyping IC-based circuits on a breadboard, understanding of buses and signals, able to read/write/understand schematics), use of logic analyzer/multimeter/oscilloscope as needed for troubleshooting, ability to read component data sheets.<br>
 
''Software Skills'': C, kernel driver development, kernel device tree, interfacing with kernel drivers using ioctl() calls from user space.<br>
 
''Possible Mentors'': Andrew Henderson<br>
 
''Upstream Repository'': TBD<br>
 
''References'': http://www.ti.com/lit/ds/sdfs071b/sdfs071b.pdf , https://www.arduino.cc/en/Tutorial/ShiftOut
 
  
 
=Mentors=
 
=Mentors=
Line 292: Line 106:
 
! Hardware help
 
! Hardware help
 
! Focus projects
 
! Focus projects
|-
 
| Nidhi Gupta
 
| philonidhi2000
 
| Hindi
 
| English
 
| GMT +5:30
 
| C, C++, Linux, Android, Embedded Computing
 
| Circuit Design, Datasheets, Schematic Review, I2C, SPI, ARM
 
| Not specific, any.
 
 
|-
 
|-
 
| Jason Kridner
 
| Jason Kridner
Line 309: Line 114:
 
| JavaScript, C, u-boot
 
| JavaScript, C, u-boot
 
| wiring, timing diagrams, basic debug
 
| wiring, timing diagrams, basic debug
| BoneScript development
+
| BoneScript development, deep learning, long-range wireless mesh networking
|-
+
}-
| Michael Welling
 
| m_w
 
| English
 
| -
 
| US Central
 
| C, Linux kernel
 
| schematics, PCB, FPGA, Robotics
 
| Kernel development
 
|-
 
| Robert Manzke
 
| rma
 
| German
 
| English, Spanish
 
| CET
 
| C, C++, JavaScript, Audio Processing, OpenGLES, GLSL
 
| Cape Design, Audio Codecs, SPI
 
| Audio FX Project, OpenGLES on Beaglebone
 
|-
 
| Henrik Langer
 
| henrix_
 
| German
 
| English
 
| CET
 
| Linux kernel, C, C++, Audio Processing, OpenCL, JavaScript
 
| Audio Codecs, I2S, SPI, I2C
 
| Audio FX Project
 
|-
 
| Hunyue Yau
 
| ds2
 
| English
 
|
 
| Pacific
 
| C, PASM
 
| Any
 
| No specific focus/any
 
|-
 
| Zubeen Tolani
 
| zeekhuge
 
| Hindi
 
| English
 
| IST
 
| C, PASM
 
| PRU, basic debug, wiring
 
| PRU based projects
 
|-
 
| Stephen Arnold
 
| nerdboy
 
| English
 
| Math
 
| PST8PDT
 
| kernels, toolchains, libraries, Python, sensor buses, yocto/OE
 
| Components/Data sheets, wiring/breadboard, debug
 
| Data acquisition, earth science, other fun stuff
 
|-
 
| Vladimir Pantelic
 
| av500
 
| English, German
 
| Math
 
| CET
 
| C, kernel, Android, embedded computing
 
| Components/Data sheets, wiring/breadboard, debug
 
| electronic music, microcontrollers
 
|-
 
| Jonathan Cameron
 
| Jic23
 
| English
 
|
 
| GMT
 
| Kernel
 
|
 
|
 
|-
 
| Matt Porter
 
| mdp
 
| English
 
| C
 
| EST5EDT
 
| U-Boot, kernel, USB, DMA, performance
 
| data sheets, schematic review, debug
 
|
 
|-
 
| Trevor Woerner
 
| tlwoerner
 
| English
 
|
 
| EST
 
| C, userspace/app development, embedded development, real-time, OE/Yocto/build/CI
 
|
 
|
 
|-
 
| Anuj Deshpande
 
| anujdeshpande
 
| English
 
|
 
| GMT+530
 
| C, Python, JavaScript. Userspace, web app.
 
| debug, schematic
 
|
 
|-
 
| Kumar Abhishek
 
| Abhishek_
 
| Hindi, English
 
| -
 
| IST (+0530)
 
| PRU assembly
 
| Yes
 
| BeagleLogic
 
|-
 
| Henderson, Andrew
 
| hendersa
 
| English
 
|
 
| EST/EDT (UTC-5)
 
| C/C++, ARM asm, Linux, Linux kernel, Android
 
| Prototyping, Eagle PCB
 
| BeagleBone Black, Android, Linux userspace multimedia
 
|-
 
| Robert Nelson
 
| rcn-ee
 
| English
 
| Other languages
 
| US Central
 
|
 
|
 
|
 
|-
 
| Patryk Mezydlo
 
| pmezydlo
 
| Polish
 
| English
 
| CET
 
| C, kernel development
 
| data sheets, schematic review, debug, kicad
 
|
 
|-
 
 
| Name
 
| Name
 
| IRC nickname
 
| IRC nickname
Line 455: Line 125:
 
| Focus projects
 
| Focus projects
 
|}
 
|}
[[BeagleBoard/GSoC/Ideas-2017#Mentors|Previous mentors]]
+
[[BeagleBoard/GSoC/Ideas-2018#Mentors|Previous mentors]]

Revision as of 11:34, 19 November 2018


Welcome!

BeagleBoard.org is applying to be a mentoring organization in the Google Summer of Code for 2019! Below, we're collecting project ideas for the GSoC-2019.

What is Google Summer of Code?

Spend your summer break writing code and learning about open source development while earning money! Accepted students work with a mentor and become a part of the open source community. Many become lifetime open source developers! The 2018 student application window is open March 27th 2018!

Google Summer of Code is open to post-secondary students, age 18 and older in most countries.

Read more on the GSoC site and the FAQ.

BeagleBoard.org Background

BeagleBoard.org is a volunteer organization that seeks to advance the state of open-source software on open-source hardware platforms capable of running high-level languages and operating systems (primarily Linux) in embedded environments. Born from taking mobile phone processors and putting them on low-cost boards to build affordable desktop computers, BeagleBoard.org has evolved to focus on the needs of the "maker" community with greater focus on the I/O needed for controlling motors and reading sensors to build things like robots, 3d printers, flying drones, in-car computer systems and much more. Past BeagleBoard.org GSoC projects included creating an interpreter for tiny CPUs, adding SPI and sensor support to Python, an HTML and git based tutorial sharing environment, porting autopilot software to Linux, an open source 100MHz 14-channel logic analyzer, using Android tablets as Linux displays, putting ADC support in Linux under the IIO framework, using Android phones as a network boot source, Running Arduino code on Linux, Robot Operating System support within the Yocto Project build system, Minix I2C support, an RPC framework for heterogeneous processor communication, a transparent USB packet sniffer, ARM optimizations for XBMC, ARM optimizations for FFTs, make-shift pulse-width-modulation and RPC optimizations for OpenCV. BeagleBoard.org has benefited from sponsorship from Texas Instruments, Circuitco, Digi-Key, element14 and others, but avoids any dependence on that sponsorship for sustaining the effort. The project has evolved over the past few years with over 1,000,000 boards in circulation with developers worldwide and strong roots in the Linaro, Yocto Project, Angstrom Distribution, Debian and Linux communities---and support for running most major Linux distributions including Ubuntu, Android, Fedora, ArchLinux, Gentoo, Buildroot and many more.

BeagleBoard was inspiration for Raspberry Pi[1] and PocketBeagle is available for about $25 through over 30 distributors world-wide (and is even available at Micro Center in the USA), but is more than a throw-away computer. It is an instance of true open hardware, exposing users to the broader world of electronics, demystifying computers and fostering an environment of clones that have changed the industry for good.

Students will be expected to demonstrate an understanding of cross-compiling before being accepted, but support for demonstration is available through the IRC channel that typically has approximately 150 online chatters logged on at any time, most with sufficient experience to explain the process.

Every accepted student will be sent a PocketBeagle and either a BeagleBone Black Wireless, BeagleBone Black, BeagleBone Blue, SeeedStudio BeagleBone Green, SeeedStudio BeagleBone Green Wireless or BeagleBoard-X15 before the first week of coding for testing their project.

Additional hardware will be provided depending on need and value.

For more information, check out https://beagleboard.org and https://beagleboard.org/brief.

Students looking for ideas

Student proposals can encompass projects inspired from the following list of ideas or can include personal project ideas. Previous Google Summer of Code projects show that the key to success is being passionate about your project, so propose something that is extremely interesting to you, even if it is not on this list. We will be glad to help students develop ideas into projects via the BeagleBoard GSoC IRC or the BeagleBoard-GSoC mailing list. There are many potential project ideas and we will match students to projects based on their interests and help scope the proposals to something that can be completed in the Summer of Code timeframe.

There are more than 500 existing projects listed at http://beagleboard.org/project. If you are interested in any of the projects listed on the BeagleBoard.org projects page, contact the project members to see if there are any aspects of their projects that can be enhanced to create a GSoC project. There are also several ideas on the ECE497 class project idea list. You can also check out last year's idea page.

Mentors wondering where to help

Please start by registering your ideas for student projects below by following the template provided with the existing ideas. Furthermore, scroll down to the bottom and give everyone a bit of information about your expertise and availability by adding yourself to the table. Jason will make final approvals for mentor assignments based on if we first get accepted as a mentoring organization and best matching mentor skill sets with student project ideas deemed valuable to the community.

You will also need be invited by an administrator to register on the GSoC site and request to be a mentor for BeagleBoard.org.

General requirements

All projects have the following basic requirements:

  1. Students must create accounts on Github, eLinux, Freenode and Google Groups prior to creating their application.
  2. All newly generated materials must be released under an open source license.
  3. Individual students shall retain copyright on their works.
  4. Students will demonstrate their ability to cross-compile and utilize version control software by creating a "Hello World" application and generating a pull request to https://github.com/jadonk/gsoc-application/tree/master/ExampleEntryJasonKridner. For assistance, please visit http://bbb.io/gsocchat or utilize the beagleboard-gsoc Google Group. The "Hello World" application must print your name and the date out in an ARM Linux environment. Freely available emulators may be used to test your application or you can ask anyone on the chat or mailing list to help you test.
  5. All projects will produce reusable software components and will not be "what–I-built-over-my-summer-vacation" projects. Including a hardware component is welcome, but the project *deliverable* will be software that may be utilized by a wide audience of the BeagleBoard.org community.
  6. Students will demonstrate their ability to collaborate by creating an eLinux wiki page for their proposal and utilizing Freenode to collect quotes regarding the usefulness of their proposal to the BeagleBoard.org community. The wiki timestamp will help mentors recognize the provenance of ideas from prospective students. Use of Google Docs for proposal development is discouraged due to insufficient revision control and extensive use of computing resources having numerous documents open simultaneously.
  7. Source code generated during the project must be released on Github (to be cloned to github.com/beagleboard or merged with appropriate upstream project upon successful completion).
  8. To help you to break your project down into manageable chunks and also to help the project's mentors to better support your efforts, weekly project status reports should be e-mailed to the the beagleboard-gsoc Google Group. Each status report should outline:
    1. what was accomplished that week,
    2. any issues that prevented that week's goals from being completed and
    3. your goals for the next week.
  9. Students will provide two recorded audio/video presentations uploaded to Youtube or Vimeo (screencasts are appropriate), one near the beginning of the project summarizing their project goals and another in the wrap-up phase to summarize their accomplishments. Examples can be found on http://beagleboard.org/gsoc. There is no requirement to show your faces or use English.

Idea template

Please place your idea in a suitable section.

Summarizing project name


Goal:
Hardware Skills:
Software Skills:
Possible Mentors:
Upstream Repository:
References:

Ideas

Throughout all of these ideas, contributions specifically contributing to the Linux kernel will be given extra attention. The ability for the BeagleBoard.org community to leverage software created out of GSoC is greatly expanded when those contributions land in the upstream Linux kernel where they are shared across many platforms and maintained by the broadest possible support community. In each application area, consideration how a kernel module submitted upstream could be a central component should be considered. In lieu of contributing to the Linux kernel, finding an upstream project, like ArduPilot, RTEMS, DonkeyCar, etc., where there is already an active community, is strongly desired. Of course, some projects are very BeagleBone-specific, like Adafruit_BBIO and BoneScript, and those projects do have an active user community and contributions are welcome in those areas, but more weight is given the more broad the impact of the coding project is. We've seen bug fixing projects to be very productive as well.

Deep Learning

BeagleBoard-X15 has accelerators for running deep learning tasks using TIDL (1, 2). We'd love projects that enable people to do more deep learning application and end-nodes and leverage cloud-based training more easily. Goal here is to create tools that make learning about and applying AI and deep learning easier. Contributions to projects like ArduPilot and DonkeyCar (DIY Robocars and BlueDonkey) to introduce autonomous navigation to mobile robots are good possible candidates.

Low-Power Wide Area Networking

A number of wireless connectivity solutions to low-cost sensor nodes exist, including things built around TI CC13x, LoRa, narrow-band LTE and other low-power wide area networks. Projects that create tools and learning around these technologies should find a large user and mentor community around BeagleBone.

Automation and Industrial I/O

BeagleBone gets used a lot in automation tasks, be they in industrial, building, home or otherwise. Software that helps enable individual hobbyists, but can bridge into professional automation tasks, is strongly desired.

  • MikroElectronika click board manifests for the Greybus simulator, instead of device tree overlays
  • learning tools like BlockyTalky3 and Makecode, but with a focus on
  • open source PLC software

Low latency and soft peripherals using co-processors

The programmable real-time units are one of the coolest features of BeagleBone. Of course, the architecture of using a main processor running a high-level operating system and co-processors running without an operating system is a general architecture. Projects that help create tools and learning around this architecture can be rather successful around BeagleBone. See https://beagleboard.org/pru.

  • low-latency audio (bela.io)
  • LED lighting (Falcon Player, PocketScroller, etc.)

Security and Privacy

The BeagleBoard.org community cares a lot about understanding how information is managed. Projects that open up technology for more personal control and help secure data from external manipulation are generally well accepted. Consider how you can make contributions to existing projects in this area.

  • penetration testing (The Deck, Kali)
  • self-hosted services (Freedombone)
  • car hacking (Macchina)

Mentors

Name IRC nickname Native language Other languages Timezone Software help Hardware help Focus projects
Jason Kridner jkridner English - US Eastern JavaScript, C, u-boot wiring, timing diagrams, basic debug BoneScript development, deep learning, long-range wireless mesh networking

}-

Name IRC nickname Native language Other languages Timezone Software help Hardware help Focus projects

Previous mentors