Difference between revisions of "BeagleBoard/GSoC/Ideas-2021"

From eLinux.org
Jump to: navigation, search
(Low-Power Wide Area Networking)
(Mentors)
 
(72 intermediate revisions by 24 users not shown)
Line 7: Line 7:
  
 
=Welcome!=
 
=Welcome!=
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.
+
BeagleBoard.org has been accepted to be a mentoring organization in the [[BeagleBoard/GSoC|Google Summer of Code]] for nine previous years!  Below, we're collecting project ideas for the GSoC-2021!
  
 
==What is Google Summer of Code?==
 
==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 2019 student application window is open March 25th 2019!
+
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 2021 student application window is open March 29th to April 13th 2021! But don't wait for then to engage!  Come to our IRC chat and share ideas today.
  
 
Google Summer of Code is open to post-secondary students, age 18 and older in most countries.
 
Google Summer of Code is open to post-secondary students, age 18 and older in most countries.
Line 23: Line 23:
 
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.
  
'''''<span style="color:red">Every accepted student will be sent a [https://bbb.io/pocket PocketBeagle] and either a [https://bbb.io/wifi BeagleBone Black Wireless], [https://bbb.io/black BeagleBone Black], [https://bbb.io/blue BeagleBone Blue], [https://bbb.io/green SeeedStudio BeagleBone Green], [https://bbb.io/green-wireless SeeedStudio BeagleBone Green Wireless] or [https://bbb.io/x15 BeagleBoard-X15] before the first week of coding for testing their project.</span>'''''
+
'''''<span style="color:red">Every accepted student will be sent a [https://bbb.io/pocket PocketBeagle], TechLab or GamePup, and either a [https://bbb.io/ai BeagleBone AI], [https://bbb.io/wifi BeagleBone Black Wireless], [https://bbb.io/black BeagleBone Black], [https://bbb.io/blue BeagleBone Blue], [https://bbb.io/green SeeedStudio BeagleBone Green], [https://bbb.io/green-wireless SeeedStudio BeagleBone Green Wireless] or [https://bbb.io/x15 BeagleBoard-X15] before the first week of coding for testing their project.</span>'''''
  
 
Additional hardware will be provided depending on need and value.
 
Additional hardware will be provided depending on need and value.
Line 32: Line 32:
 
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 [http://webchat.freenode.net/?channels=beagle-gsoc the BeagleBoard GSoC IRC] or [http://groups.google.com/group/beagleboard-gsoc 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.
 
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 [http://webchat.freenode.net/?channels=beagle-gsoc the BeagleBoard GSoC IRC] or [http://groups.google.com/group/beagleboard-gsoc 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_Project_Ideas|ECE497 class project idea list]]. You can also check out [[BeagleBoard/GSoC/Ideas-2016|last year's idea page]].
+
There are more than a thousand existing projects listed at http://beagleboard.org/p. 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_Project_Ideas|ECE497 class project idea list]]. You can also check out [[BeagleBoard/GSoC/Ideas-2010|last year's idea page]]. Note, however, we are looking for projects that provide a service to the developer community and aren't simply "look what cool thing I made or you can make". The projects should provide a useful software component for other people to utilize.
  
 
==Mentors wondering where to help==
 
==Mentors wondering where to help==
Line 53: Line 53:
 
## your goals for the next week.
 
## your goals for the next week.
 
# 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.
 
# 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.
 +
 +
==How to write a successful proposal==
 +
BeagleBoard.org has received a large number of GSoC student proposals over the years that we have participated in the program. Some of these proposals are quite good, but many are poor proposals that would not be accepted by any organization participating in GSoC. Unsuccessful proposals often do/have the following: 
 +
# Try to pass off previous school projects as something to do for GSoC. The work has already done, and the project often has very little to do with BeagleBoard.org hardware.
 +
# Roughly a half page of "proposal" that is submitted shortly before the submission deadline. These proposals are usually little more than a name, contact information, and a statement of "I will work hard."
 +
# A generic proposal that was sent to every other GSoC org that has very few details on deliverables or schedule.
 +
# A project idea that was never talked about to the BeagleBoard.org mentors in IRC or in the Google Group. The proposal was submitted without ever "meeting" the Beagle community.
 +
 +
In order to be successful, a proposal has to be relevant to BeagleBoard.org, a proposal topic that the mentors recognize (either from being proposed on this page or from the topic being discussed on our Google Group or on IRC), and sufficiently detailed that the mentors know exactly what you'll be creating and when it will be done. Successful proposals are also almost always shown to mentors via IRC well before the submission deadline so that the mentors can comment on it and offer suggestions that improve the proposal.
 +
 +
Start your proposal early, speak with the mentors often, and dedicate an appropriate amount of time to both thinking about the deliverables for your project and how you can describe those deliverables in writing.
  
 
==Idea template==
 
==Idea template==
Line 84: Line 95:
 
''Upstream Repository:'' https://github.com/beagleboard/linux/tree/4.19 kernel.org <br>
 
''Upstream Repository:'' https://github.com/beagleboard/linux/tree/4.19 kernel.org <br>
 
''References:'' https://events.static.linuxfound.org/sites/events/files/slides/USB%20Gadget%20Configfs%20API_0.pdf <br>
 
''References:'' https://events.static.linuxfound.org/sites/events/files/slides/USB%20Gadget%20Configfs%20API_0.pdf <br>
 +
 +
===Update Cape compatibility layer===
 +
 +
''Goal:'' Update the compatibility layer for BeagleBone Black and AI to support more kernel versions.<br>
 +
''Hardware Skills:'' UART, I2C, SPI, ADC, GPIO and PWM <br>
 +
''Software Skills:'' C, Linux kernel <br>
 +
''Possible Mentors:'' Deepak Khatri, jkridner <br>
 +
''Upstream Repository:'' various <br>
 +
''References:''
 +
[[Beagleboard:BeagleBone cape interface spec]]
 +
[https://elinux.org/BeagleBoard/GSoC/2020_Projects/Cape_Compatibility GSoC 2020 project page.]
 +
[https://deepaklorkhatri.me/GSoC2020_BeagleBoard.org/ lorforlinux's GSoC project documentation website.]<br>
  
 
==Deep Learning==
 
==Deep Learning==
 
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.
 
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.
 +
 +
===YOLO models on the X15/AI===
 +
Port the YOLO model(s) to the X15/AI so the accelerator blocks can be leveraged. Currently, running a frame through YOLOv2-tiny takes anywhere from 35 sec to 15 second depending on the how the code is run on the ARM.35 second being a pure brute force compilation for ARM; 15 second utilizing NEON and tweaked algorithms. The goal is to get things down to 1 second or less using the onboard accelerators. Note, there are over 6 different variants of YOLO (YOLOv1, YOLOv2, YOLOv2 and each one has a full size and a tiny version). The main interest is in getting either the YOLOv2 or YOLOv3 versions running. Please discuss with potential mentors on the desired approach as there are many approaches. Just to name a few: Porting the YOLO model into TIDL; OpenCL directly; OpenCL integration with the acceleration library; Integrating TIDL support with an acceleration library.
 +
<br>
 +
''Goal:'' Run YOLOv2 or YOLOv3 with the onboard hardware acceleration.<br>
 +
''Hardware Skills:'' None <br>
 +
''Software Skills:'' C, C++, Linux kernel, Understanding of NNs and Convolution.<br>
 +
''Possible Mentors:'' Hunyue Yau <br>
 +
''Upstream Repository:'' Numerous <br>
 +
''References:'' https://pjreddie.com/darknet/yolo/ <br>
 +
 +
===OpenGLES acceleration for DL===
 +
Current acceleration on the X15/AI focuses on using the EVE and DSP hardware blocks. The SoC on those boards also feature an OpenGLES enabled GPU. The goal with this is to utilize shaders to perform computations. A possible frame work to utilize this on is the Darknet CNN framework.<br>
 +
''Goal:'' Accelerate as many layers types as possible using OpenGLES.<br>
 +
''Hardware Skills:'' None <br>
 +
''Software Skills:'' C, C++, Linux kernel, OpenGLES, Understanding of NNs and Convolution.<br>
 +
''Possible Mentors:'' Hunyue Yau <br>
 +
''Upstream Repository:'' Numerous <br>
 +
''References:'' https://pjreddie.com/darknet/ <br>
  
 
==GPGPU with GLES==
 
==GPGPU with GLES==
 
The BeagleBone and related boards all have a built in GPU that is often unused. It would be useful to create samples showing how it can be used for GPGPU purposes.Since there is no OpenCL drivers, this would need to be done with OpenGLES 2.0. The samples should take data from a C style array and load it onto the GPU. The GPU would then perform the task using sample shader code. The processed data would be retrieved from the GPU back into another C style array. A few processing tasks can be shown - simple do nothing to illustrate moving data between the CPU and the GPU and a real processing task such as running the image against a small kernel (convolution). Sample programs should also have a way of showing the time costs in moving data between GPU and CPU.  
 
The BeagleBone and related boards all have a built in GPU that is often unused. It would be useful to create samples showing how it can be used for GPGPU purposes.Since there is no OpenCL drivers, this would need to be done with OpenGLES 2.0. The samples should take data from a C style array and load it onto the GPU. The GPU would then perform the task using sample shader code. The processed data would be retrieved from the GPU back into another C style array. A few processing tasks can be shown - simple do nothing to illustrate moving data between the CPU and the GPU and a real processing task such as running the image against a small kernel (convolution). Sample programs should also have a way of showing the time costs in moving data between GPU and CPU.  
  
==Low-Power Wide Area Networking==
+
==BeagleConnect - 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.
+
See https://github.com/jadonk/beagleconnect. The BeagleConnect Freedom board runs the [https://www.zephyrproject.org/ Zephyr RTOS] has [[mikroBUS]] ports along with BLE and Sub-GHz radios on it. The code to enable a Linux gateway for the Sub-GHz radio is in the repository.
  
===Greybus over 802.15.4===
+
===Micropython for BeagleConnect Freedom===
802.15.4-based Greybus (instead of Unipro as used by Project Ara), where every [http://www.ti.com/tool/LAUNCHXL-CC1352R1 CC1352 Launchpad] shows up as new SPI, I2C, UART, PWM, ADC, and GPIO controllers that can now be probed to load drivers for the sensors or whatever is connected to them.
+
''Goal:'' Enable Micropython for BeagleConnect Freedom along with basic GPIO, I2C, SPI, PWM, ADC drivers.<br>
<br>
+
''Hardware Skills:'' Basic wiring<br>
''Goal:'' Upstream kernel patches to support USB-UART connected CC1352 Launchpad with a fixed host firmware load talking to a CC1352 Launchpad with a fixed client firmware load and exposing SPI, I2C, UART, PWM, ADC and GPIO controllers.<br>
+
''Software Skills:'' C, RTOS<br>
''Hardware Skills:'' I2C, SPI, UART, PWM, ADC, GPIO basic wiring<br>
 
''Software Skills:'' C, Linux, BeagleBone, Launchpad<br>
 
 
''Possible Mentors:'' jkridner<br>
 
''Possible Mentors:'' jkridner<br>
''Upstream Repository:'' TBD<br>
+
''Upstream Repository:'' https://github.com/micropython/micropython/tree/master/ports/zephyr<br>
''References:'' https://www.youtube.com/watch?v=7H50pv-4YXw, https://bitbucket.org/nuttx/nuttx/src/master/configs/launchxl-cc1312r1/README.txt?fileviewer=file-view-default<br>
+
''References:'' https://github.com/zephyrproject-rtos/zephyr, https://github.com/jadonk/beagleconnect<br>
  
 
==Automation and Industrial I/O==
 
==Automation and Industrial I/O==
Line 111: Line 151:
 
* open source PLC software
 
* open source PLC software
  
===click board support under Greybus===
+
===librobotcontrol support for BeagleBone AI and Robotics Cape===
Today, support for click boards on PocketBeagle is accomplished via device tree overlays via the bb.org-overlays repository[https://github.com/beagleboard/pocketbeagle/wiki/Click-boards%E2%84%A2 *]. This requires /boot/uEnv.txt to be modified to load the drivers at boot, requiring at least one reboot to enable the support in a potentially error-prone way, as modifying that file could prevent the image from booting. Fortunately, some work on BeagleBone to produce a [https://github.com/projectara/gbsim Greybus simulator] opens up a different possibility. Greybus already provides most of the interfaces used on click boards and utilizes [https://lwn.net/Articles/715955/ manifest files] to enumerate hardware at run-time. By using the simulator, similar functionality should be possible to achieve for these existing buses, rather than via true hot-swapping hardware.<br>
+
''Goal:'' Complete implementation of librobotcontrol on BeagleBone AI.<br>
 +
''Hardware Skills:'' Basic wiring<br>
 +
''Software Skills:'' C, Linux<br>
 +
''Possible Mentors:'' jkridner, lorforlinux<br>
 +
''Upstream Repository:'' https://github.com/jadonk/librobotcontrol/tree/bbai<br>
 +
''References:''http://www.strawsondesign.com/docs/librobotcontrol/index.html<br>
 +
 
 +
===Makecode Arcade for PocketBeagle GamePup===
 +
Makecode is a framework for creating special-purpose programming experiences for beginners, especially focused on computer science education. Makecode has a blockly based programming environment served on the browser along with an in-browser board simulator. MakeCode Arcade is a similar environment to MakeCode, but the environment has code blocks that are oriented towards building games. The goal of this project is to support the Makecode Arcade target for the Beaglebone boards and demonstration of example games on the Pocketbeagle Gamepup Cape.
 +
<br>
 
<br>
 
<br>
''Goal:'' Greybus drivers, userspace simulator and example manifests for several MikroElectronkia click boards using PocketBeagle.<br>
+
''Goal:'' Makecode target for Beaglebone boards with Breadboard simulator functionality making use of a UF2 daemon running in Beaglebone<br>
''Hardware Skills:'' Some preliminary understanding of some basic interface protocols like UART, I2C, and SPI<br>
+
''Hardware Skills:'' Basic breadboard prototyping skills<br>
''Software Skills:'' Linux kernel modules<br>
+
''Software Skills:'' Linux,Javascript,PXT<br>
''Possible Mentors:'' Jason Kridner<br>
+
''Possible Mentors:'' Andrew Henderson<br>
''Upstream Repository:'' https://github.com/beagleboard/linux, https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc ([https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git/tree/drivers/staging/greybus 1])<br>
+
''Upstream Repository:'' TBD<br>
''References:'' https://lwn.net/Articles/715955/<br>
+
''References:'' https://github.com/microsoft/pxt-arcade , https://github.com/microsoft/uf2-linux , https://beagleboard.org/capes<br>
  
===Makecode Target for BeagleBone===
+
===Blynk support for BeagleBone Boards===
Makecode is a framework for creating special-purpose programming experiences for beginners, especially focused on computer science education. Makecode has a blockly based programming environment served on the browser along with an in-browser board simulator.The goal of this project is to make a Makecode target for the Beaglebone boards with Breadboard simulator capability similar to Makecode maker (https://maker.makecode.com/) which can interact with hardware making use of the bonescript RPC Server.
+
Blynk is a hardware-agnostic IoT platform with white-label mobile apps, private clouds, device management, data analytics, and machine learning. There are no good examples of Blynk with BeagleBone boards and there is no option for it in their mobile App right now. This project will change that and provide good visibility for BeagleBone boards with well-documented examples and How-To guides.
 
<br>
 
<br>
 
<br>
 
<br>
''Goal:'' Makecode target for Beaglebone boards with Breadboard simulator functionality making use of Bonescript RPC.<br>
+
''Goal:'' Blynk support for BeagleBone Boards (Black, AI, Blue, and Pocket) with well-documented examples<br>
 
''Hardware Skills:'' Basic breadboard prototyping skills<br>
 
''Hardware Skills:'' Basic breadboard prototyping skills<br>
''Software Skills:'' Javascript,PXT,BoneScript<br>
+
''Software Skills:'' Linux and Javascript<br>
''Possible Mentors:'' TBD<br>
+
''Possible Mentors:'' Deepak Khatri, Vedant Paranjape<br>
 
''Upstream Repository:'' TBD<br>
 
''Upstream Repository:'' TBD<br>
''References:'' https://www.microsoft.com/en-us/makecode , https://github.com/Microsoft/pxt-maker<br>
+
''References:'' TBD<br>
  
 
==Low latency and soft peripherals using co-processors==
 
==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.
 
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)
+
* low-latency audio (bela.io) (see more projects below)
 
* LED lighting (Falcon Player, PocketScroller, etc.)
 
* LED lighting (Falcon Player, PocketScroller, etc.)
  
 
Another approach is to add support for Verilog (or VHDL) to synthesis PRU code for the soft peripherals. This can be based on the open source verilog toolchains.
 
Another approach is to add support for Verilog (or VHDL) to synthesis PRU code for the soft peripherals. This can be based on the open source verilog toolchains.
  
=== PRU User Space API ===
+
===Add features to simpPRU===
''Goal'':  Provide a simple API across multiple programming languages to use with the PRUs to load binaries, and communicate with the PRUs from userspace.

<br>
+
''Goal'': Improve the features of simpPRU, namely implement a better error handler, add support for calling C code directly into simpPRU, also fix the known issues given the docs. If possible also fix the docs website<br>
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': C, Linux, Compilers<br>
 +
''Possible Mentors'': Vedant Paranjape, Andrew Henderson<br>
 +
''Upstream Repository'': https://github.com/VedantParanjape/simpPRU/<br>
 +
''References'': https://github.com/VedantParanjape/simpPRU/wiki#things-to-be-implemented-in-future, https://github.com/VedantParanjape/simpPRU/wiki#known-issues, https://github.com/VedantParanjape/simpPRU/issues/5
 +
 
 +
===Python for PRU===
 +
''Goal'': Use Python to program PRUs
 +
''References'': https://github.com/beagleboard/cloud9-examples/blob/3852ee0a11d5e5428a45576e528337f28a3822ef/PocketBeagle/pru/.work-in-progress/pruspeak.pru0.c
 +
 
 +
=== Patching Beaglebone PRU DMA support to the latest kernel versions  ===
 +
''Goal'':  The BeagleBone PRU DMA project made use of the EDMA controller to transfer data between PRU and main (DDR) memory. Without DMA, the 2nd PRU on the PRUSS is utilized/wasted for data transfer. The project needs to be patched to the latest kernel version as it is currently in a non-working state. It could then also be integrated with PRUSS-Bindings to create a complete PRU API.<br>
 
''Hardware Skills'':  Minimal<br>
 
''Hardware Skills'':  Minimal<br>
''
Software Skills'':  Linux, C and Python programming
<br>
+
''Software Skills'':  Linux, C, kernel modules<br>
''Possible Mentors'': Kumar Abhishek, Zubeen Tolani<br>
+
''Possible Mentors'': Pratim Ugale<br>
''Upstream Repository'': https://github.com/beagleboard/linux, https://github.com/beagleboard/pypruss<br>
+
''Upstream Repository'': https://github.com/beagleboard/linux, https://github.com/pratimugale/PRUSS-Bindings or a fork of https://github.com/maciejjo/beaglebone-pru-dma <br>
''References'':  https://bitbucket.org/intelligentagent/pypruss, https://beagleboard.org/latest-images
+
''References'':  https://gist.github.com/maciejjo/58a0d0213712e67fba9d0061f6b5bead, https://github.com/maciejjo/beaglebone-pru-dma/issues, https://github.com/pratimugale/PRUSS-Bindings/wiki
  
 
===Port am335x_pru_package to remoteproc===
 
===Port am335x_pru_package to remoteproc===
Line 155: Line 216:
 
''Hardware Skills'': N/A<br>
 
''Hardware Skills'': N/A<br>
 
''Software Skills'': C, assembly, Linux kernel<br>
 
''Software Skills'': C, assembly, Linux kernel<br>
''Possible Mentors'': Kumar Abhishek,  Zubeen Tolani<br>
+
''Possible Mentors'': Kumar Abhishek,  Zubeen Tolani, Andrew Henderson<br>
 
''Upstream Repository'': https://github.com/beagleboard/am335x_pru_package<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 ]
 
''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 ]
Line 172: Line 233:
 
''Hardware Skills'': Some understanding of I/O is needed esp if the I2C master is choosen.<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>
 
''Software Skills'': C, assembly, Linux kernel<br>
''Possible Mentors'': Kumar Abhishek, Zubeen Tolani<br>
+
''Possible Mentors'': Kumar Abhishek, Zubeen Tolani, Giulio Moro, Andrew Henderson<br>
 
''Upstream Repository'': N/A<br>
 
''Upstream Repository'': N/A<br>
 
''References'': BeagleLogic & BeagleScope from previous years.
 
''References'': BeagleLogic & BeagleScope from previous years.
  
===Reference Design For A GPIO-based Parallel Bi-Directional Bus===
+
==Security and Privacy==
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.
+
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)
 +
* security appliance (Pangolin, ZeroTier Edge device)
 +
* self-hosted services (Freedombone)
 +
* car hacking (Macchina)
 +
 
 +
Example idea, a portable/plugable security appliance for use anywhere:
  
''Goal'': Create a hardware/software 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. Using the PRU to implement the low-level details of the bus (clock/latch signalling, reading/writing data) is encouraged! 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.<br>   
+
* hardware: beaglebone with ethernet or beaglebone wireless, pocketbone + USB ethernet/wifi
''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>
+
* OS: openwrt
''Software Skills'': C, kernel driver development, kernel device tree, PRU programming, interfacing with kernel drivers using ioctl() calls from user space.<br>
+
* configuration UI: bonescript/other
''Possible Mentors'': Andrew Henderson, Zubeen Tolani<br>
+
* PRU accelerators...
''Upstream Repository'': TBD<br>
+
* privacy and safety tools...
''References'': http://www.ti.com/lit/ds/sdfs071b/sdfs071b.pdf , https://www.arduino.cc/en/Tutorial/ShiftOut
 
  
==PocketBeagle Stepwise Mathematics==
+
=== Make port of Xen on BeagleBoard-x15 ===
Goal: The big picture goal is a stealth Step wise solution prompting Scientific Calculator based on the Pocket Beagle Residing in a Popular Brand Casing.The examinar should not be able to figure out any changes made to the approved exam Calc/Machine.The Calculator takes input from the User in terms of a completely formed mathematical problem and gives the step wise output on the display. Something similar to Sympolab or Wolfgram Alpha.
+
The project idea is to make Xen hypervisor available and easy to use on beagleboard-x15. To achieve this, it is planned to write Xen-supporting code and tutorials for Xen setup on the board. Another project goal is to improve user experience by working on optimizations for Beagleboard's kernel virtualization support code and/or on user-space tools. <br>
   
+
Previously, the problem was discussed in [https://lists.xen.org/archives/html/xen-users/2018-01/msg00119.html xen mailing list] and in [https://groups.google.com/forum/#!msg/beagleboard/HVZ7kpVM_bE/vxsa2SvPCAAJ beagleboard mailing list]. The general solution wasn't provided and it seems that the problem still does exist. <br>
Hardware Skills: Medium. Ability to Interface/Integrate a Membrane/Capacitive Keyboard and
+
The virtualization will make prototyping of virtualization-based security solutions easier in such areas like automotive computing and mobile privacy (BYOD problems).
Matrix display.Ability to Get the Beagle running on a Lithium Ion thin Battery.  
+
<br>
  
Software Skills: Python, C/C++, Linux, Knowledge of Compiler's     
+
''Goal'': to make virtualization available for end-users on Beagleboard-x15.<br>
 +
''Hardware Skills'': basic electronics.<br>
 +
''Software Skills'': C, C++, Linux kernel, Xen.<br>
 +
''Possible Mentors'': Andrew Henderson, Michael Welling. <br>
 +
''Possible Co-mentors'': Stefano Stabellini, Julien Grall, Iain Hunter. <br>
 +
''Upstream Repository'': N/A. <br>
 +
''References'': [https://lists.xen.org/archives/html/xen-users/2018-01/msg00119.html xen mailing list] [https://groups.google.com/forum/#!msg/beagleboard/HVZ7kpVM_bE/vxsa2SvPCAAJ beagleboard mailing list]
  
Possible Mentors:  
+
==Beagle Bone Audio Applications==
 +
===Porting multi-channel sound card drivers to recent kernels ===
 +
Goal: Porting sound card drivers to recent kernels
  
Upstream Repository: N/A
+
Background / References: https://hackaday.io/project/9634-ctag-face-and-beast-multichannel-audio-systems
 
Refrences: N/A
 
  
==Security and Privacy==
+
Software Skills: C/C++, Linux, Kernel
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)
+
Possible Mentors: rma, henrix
* self-hosted services (Freedombone)
 
* car hacking (Macchina)
 
  
==Beagle Bone Audio Network Streaming==
+
=== IP Media Streaming===
Goal: Building on a Beagle GSoC project of 2017, the idea is to extend / add audio network streaming capabilities using the AVB and / or the SMPTE2110/30 (and SMPTE2022/7) standards.
+
Goal: Building on a Beagle GSoC project of 2017 and 2020, the idea is to extend / add audio network streaming capabilities using the AVB and / or the Ravenna / AES67 standards.
  
Background / References: https://elinux.org/BeagleBoard/GSoC/BeagleBoneAVB
+
Background / References: https://niklaswan.github.io/GSoC-Overview https://elinux.org/BeagleBoard/GSoC/BeagleBoneAVB
  
 
Software Skills: C/C++, Linux, Kernel
 
Software Skills: C/C++, Linux, Kernel
  
Possible Mentors: rma
+
Possible Mentors: rma, henrix
 +
 
 +
===Bela support on BeagleBone AI (and/or newer BB boards)===
 +
 
 +
The Bela cape is working on the BB AI using ALSA (although one of the clocks seems to be of the wrong frequency), so we can confirm the pinout and pin settings are OK. We have not tried running the Bela code on the PRU yet. You'll need to know (or learn!) a bit about pinmuxing, uboot, PRU assembly and more in general the Sitara family of SoCs and the McASP audio port.
 +
 
 +
''Goal'': add support for the Bela cape + Xenomai + PRU on the BeagleBone AI.
 +
''Hardware Skills'': reading and understanding datasheet and technical reference manual<br>
 +
''Software Skills'': C, PRU, dtb, uboot, make
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': https://github.com/BelaPlatform/Bela, https://github.com/giuliomoro/bela-cape-no-pru, and more<br>
 +
 
 +
===Bela audio driver for common audio APIs===
 +
 
 +
Bela uses its own custom audio API which bypasses ALSA altogether. When adding support for Supercollider and Csound, we had to add a new audio driver to these pieces of software to call into Bela’s C API. In order to make the process of adding Bela support to more programming languages in the future easier, we could think of simply adding Bela support to some common audio backend libraries, so that a single effort can be reused across several pieces of software that use that same library. Examples of such libraries are: portaudio, rtaudio and jack and there may be more. In this project you’ll write a Bela driver for one or more of these libraries and build at least one application that uses the library (e.g.: ChucK, which uses RtAudio or Pure Data, which uses portaudio). You will need a good knowledge of C and build systems. Upon successful completion, the project will make it easier to add more applications and programming languages to Bela.
 +
 
 +
''Goal'': Improve the portability of Bela code across audio APIs/
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': C / make
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': https://github.com/BelaPlatform/Bela, https://github.com/thestk/rtaudio, https://github.com/PortAudio/portaudio  <br>
 +
 
 +
===Live patching of Pure Data on embedded devices===
 +
 
 +
Pure Data (Pd) is a visual data-flow language for audio applications and it is one of the several languages supported by Bela. Pd ships as a cross-platform software with a C backend and a Tcl/Tk GUI (replaced by HTML5 in the PurrData project). When running Pd on Bela, the user can leverage the analog and digital I/Os of the board to integrate audio processing with the physical connectivity capabilities of the board. Bela provides access to a browser-based IDE for programming the board but, since a desktop environment is not available, the current workflow for using Pure Data on Bela consists in editing the patch on the host computer and then copying it over to Bela where it gets executed.
 +
 
 +
One of the limitations of this two-step workflow is that the immediateness of the live-patching behaviour of Pd is lost. In this project, the student will leverage the fact that Pd communicates with its GUI via a socket to run the GUI on the host computer while running the audio backend on Bela. This requires a number of adaptations to Pd, including:
 +
* managing the GUI startup process to allow GUI and audio backend to be started separately and connect to each other
 +
* allowing access to paths on the remote device
 +
* loading patches through the GUI instead of from the backend
 +
* delegating some of the functionalities currently handled in the backend to the GUI
 +
 
 +
Knowledge of C is required as part of the work will take place in the audio backend, however there will be need to operate on the GUI side as well. A good starting point for the project would be last year's GSoC project which managed to run PurrData entirely in the browser. At the end of a successful project we should be able to submit a pull request in the upstream Pure Data or Purr Data repositories. The benefits of this contribution will not be exclusive to Bela, but can benefit the Pd community at large, making it easier to use Pure Data on embedded devices.
 +
 
 +
''Goal'': Allow live patching of Pd on embedded devices.
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': C (minimal), Javascript/HTML or Tcl/Tk<br>
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': http://github.com/pure-data/pure-data/, https://git.purrdata.net/jwilkes/purr-data/, https://gist.github.com/hugonxc/75e0bb838b1953cfa52fa87045bf5b98#file-gsoc2020_hugocarvalho_purrdata-md <br>
 +
 
 +
==Other Bela applications==
 +
 
 +
Bela is a platform for ultra-low latency audio and sensor applications based on the BeagleBoard family of boards. It uses PRU and Xenomai at its core. https://bela.io
 +
 
 +
===Browser-based workbench===
 +
 
 +
Bela features a browser-based oscilloscope for visualising audio and sensor signals. This project would extend the oscilloscope into a more full-featured laboratory workbench.
 +
 
 +
The oscilloscope itself could be extended in several ways, for example:
 +
* More options for scaling the plot in each axis
 +
* Adjustable cursors for reading off measurements in time or amplitude
 +
* Automatic detection of amplitude or frequency from the plot
 +
* More options for triggering
 +
* XY mode
 +
* Updated visual appearance
 +
On top of that, other workbench tools could be added, including:
 +
* Waveform generator
 +
* Multimeter (RMS amplitude, frequency, DC offset, etc.)
 +
* Browser-based simulation of common analog and digital inputs (buttons, potentiometers etc.) and outputs (e.g. LEDs) This project would be built primarily in JavaScript, with some secondary work in C++ to connect to the Bela core code. We are open to the inclusion of existing open-source libraries to build any of these components.
 +
 
 +
''Goal'': Improve the features of the Bela oscilloscope and turn it into a full-fledged workbench for audio-rate signals.
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': Javascript, HTML, frontend<br>
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': https://github.com/BelaPlatform/Bela/<br>
 +
 
 +
=== Building Bela image ===
 +
 
 +
The image that Bela ships with is built from this repo, which was initially inspired by the upstream image-bulder repo, but it has greatly diverged from it. The purpose of this project is to “rebase” the functionalities of the bela-image-builder repo on top of the image-builder one. This is not simply a matter of git rebase, as the two codebases are drastically different. It is more of a “semantic rebase”: understand the motivations behind the features of the bela-image-builder repo (minimal clutter, custom kernel, custom software, custom systemd configuration) and add those to the image-builder repo in a way that makes it easier to maintain. Wherever possible, the Bela-specific changes should be made conditional so that a pull request can be opened upstream to minimise future development effort. You will need experience with scripting (mostly bash), build systems and Linux management. Upon successful completion of the project, the Bela image will follow more closely the upstream development and as a consequence it will be updated more often and more easily.
 +
 
 +
''Goal'': Improve the maintainability of the Bela image by forking it off the beagleaboard image-builder rep.
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': bash, kernel building<br>
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': https://github.com/BelaPlatform/bela-image-builder, https://github.com/beagleboard/image-builder <br>
 +
 
 +
===Browser-based IDE===
 +
 
 +
Bela’s browser-based IDE is served by a node.js server running home-grown modules and a HTML5 frontend based around jquery, ace.js and scss. The codebase started out in 2015 for internal development purposes, it has since been made public and has gone through two major redesigns during its 6-year lifetime. It allows the user to browse projects and examples, edit files and build and run projects. Over time, the frontend/backend relationship has evolved to support a number of Bela-specific features.The software landscape has changed radically since 2015 and there are now several great web-based IDEs out there. The scope of this project is to evaluate how a Bela-like workflow and appearance could be implemented on top of a more modern and better supported browser-based IDE, such as Cloud9 (or - better - something with a more liberal license). You will start by verifying that the requirements for frontend-backend communication logic can be met on the new platform. Then you will write a proof of concept skin for the new platform that mimics, where possible, the existing Bela one. You will need knowledge of web technologies, both for frontend and backend.
 +
 
 +
''Goal'': Improve the core foundation and maintainability of the Bela IDE.
 +
''Hardware Skills'': Minimal<br>
 +
''Software Skills'': Javascript / HTML / frontend<br>
 +
''Possible Mentors'': Giulio Moro<br>
 +
''Upstream Repository'': https://github.com/BelaPlatform/bela-image-builder, https://github.com/beagleboard/image-builder <br>
 +
 
 +
==FPGA based projects==
 +
===Beaglewire Updates===
 +
Beaglewire is an FPGA cape for the Beaglebone black that was developed to support a project for the 2017 season of GSoC.
 +
This first year of Beaglewire support was very intensive and there some issues were left to be resolved. The most notable known issue is with the SDRAM interface working sporadically. A student interested in Verilog, kernel coding and hardware would be an ideal candidate. Each of the subsystems (SPI, PWM, UART, SDRAM, etc) can be tested, corrected if necessary and improved if desired. Furthermore, it may be interesting to implement nMigen support for flexible python based gateware support as a stretch goal.
 +
 
 +
''Goal'': Improve the Gateware/Firmware support for the Beaglewire cape<br>
 +
''Hardware Skills'': Schematics, Verilog<br>
 +
''Software Skills'': Kernel coding<br>
 +
''Possible Mentors'': Michael Welling<br>
 +
''Upstream Repository'': https://github.com/mwelling/BeagleWire, https://github.com/mwelling/beagle-wire <br>
  
 
=Mentors=
 
=Mentors=
Line 296: Line 461:
 
| EST/EDT (UTC-5)
 
| EST/EDT (UTC-5)
 
| C/C++, PRU, Linux userspace/kernel
 
| C/C++, PRU, Linux userspace/kernel
| Prototyping, Eagle PCB
+
| Prototyping, KiCad PCB
 
| PRU/Kernel projects, Linux userspace multimedia, Security
 
| PRU/Kernel projects, Linux userspace multimedia, Security
 +
|-
 +
| Drew Fustini
 +
| pdp7
 +
| English
 +
| -
 +
| CET and US CDT
 +
| C, Python, Linux
 +
| schematics, PCB layout, KiCad
 +
| Python libraries (Adafruit_BBIO & Blinka), Linux drivers
 
|-
 
|-
 
| Zubeen Tolani
 
| Zubeen Tolani
Line 326: Line 500:
 
| Xen on Beagleboard
 
| Xen on Beagleboard
 
|-
 
|-
| Name
+
| Julien Grall
| IRC nickname
+
| julieng
| Native language
+
| French
| Other languages
+
| English
| Timezone
+
| GMT/BST
| Software help
+
| Xen, C, kernel development
| Hardware help
+
| -
| Focus projects
+
| Xen on Beagleboard
 +
|-
 +
| Iain Hunter
 +
| driain
 +
| English
 +
|
 +
| GMT/BST
 +
| C, kernel,yocto
 +
| Cape design
 +
|
 +
|-
 +
| Steve Arnold
 +
| nerdboy
 +
| English
 +
| Applied Math
 +
| PST8PDT
 +
| Python, toolchains, OS images
 +
| beaglebones, peripherals/sensors
 +
| Networking, security/privacy tools
 +
|-
 +
| Henrik Langer
 +
| henrix
 +
| German
 +
| English
 +
| CET
 +
| C, C++, Linux, PREEMPT_RT, Xenomai
 +
| PCB, mixed mode design
 +
| Audio, media network streaming protocols
 +
|-
 +
| Deepak Khatri
 +
| lorforlinux
 +
| Hindi
 +
| English
 +
| IST
 +
| Python, C, C++, Linux
 +
| PCB, Wiring, Debug, Robotics, BioMedical
 +
| Robotics and BioMedical
 +
|-
 +
| Pratim Ugale
 +
| pratimu
 +
| Hindi
 +
| English
 +
| IST
 +
| Python, PRU Assembly, Java
 +
| Basic debugging
 +
| PRU, Deep Learning
 +
|-
 +
| Vedant Paranjape
 +
| vedant16
 +
| Marathi
 +
| English, Hindi
 +
| IST
 +
| Python, C, C++, Linux, Boost lib, PRU, pru-gcc, flex, bison
 +
| PCB Design (kicad), Robotics, Soldering
 +
| PRU, Kernel Development, PCB design
 +
|-
 +
| Saketha Ramanujam S.S.
 +
| sakethr98
 +
| Telugu
 +
| English, Hindi
 +
| US Mountain Time
 +
| Python, C, a bit of JS and pru-gcc
 +
| Schematics, PCB Design(Eagle), Wiring/Debugging
 +
| PRU, Kernel Development, Signal Processing
 +
|-
 +
| Tim Orling
 +
| moto-timo
 +
| English
 +
| Spanish (non-technical)
 +
| US Pacific
 +
| Python, Yocto Project, Linux OS, system engineering, C, JavaScript
 +
| analog, schematics, PCB layout, Kicad, Eagle
 +
| Yocto Project, Python libraries (Adafruit_BBIO & Blinka), PRU
 +
|-
 +
| Giulio Moro
 +
| giuliomoro
 +
| Italian
 +
| English, Spanish
 +
| Western Europe (London)
 +
| C, PRU, dtb, Xenomai
 +
|
 +
| Bela!
 +
|-
 +
| Anuj Deshpande
 +
| anujdeshpande
 +
| English
 +
| -
 +
| IST (GMT+530)
 +
| C, python, zephyr, greybus, linux
 +
| schematics, kicad, debug
 +
| BeagleConnect
 +
|-
 +
| Arthur Sonzogni
 +
| arthursonzogni
 +
| French
 +
| English
 +
| CEST GMT+2
 +
| C++, JS, Linux, Math
 +
| N/A
 +
| FTXUI (Terminal UI)
 
|}
 
|}
 
[[BeagleBoard/GSoC/Ideas-2018#Mentors|Previous mentors]]
 
[[BeagleBoard/GSoC/Ideas-2018#Mentors|Previous mentors]]

Latest revision as of 09:26, 21 April 2021


Contents

Welcome!

BeagleBoard.org has been accepted to be a mentoring organization in the Google Summer of Code for nine previous years! Below, we're collecting project ideas for the GSoC-2021!

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 2021 student application window is open March 29th to April 13th 2021! But don't wait for then to engage! Come to our IRC chat and share ideas today.

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, TechLab or GamePup, and either a BeagleBone AI, 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 a thousand existing projects listed at http://beagleboard.org/p. 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. Note, however, we are looking for projects that provide a service to the developer community and aren't simply "look what cool thing I made or you can make". The projects should provide a useful software component for other people to utilize.

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.

How to write a successful proposal

BeagleBoard.org has received a large number of GSoC student proposals over the years that we have participated in the program. Some of these proposals are quite good, but many are poor proposals that would not be accepted by any organization participating in GSoC. Unsuccessful proposals often do/have the following:

  1. Try to pass off previous school projects as something to do for GSoC. The work has already done, and the project often has very little to do with BeagleBoard.org hardware.
  2. Roughly a half page of "proposal" that is submitted shortly before the submission deadline. These proposals are usually little more than a name, contact information, and a statement of "I will work hard."
  3. A generic proposal that was sent to every other GSoC org that has very few details on deliverables or schedule.
  4. A project idea that was never talked about to the BeagleBoard.org mentors in IRC or in the Google Group. The proposal was submitted without ever "meeting" the Beagle community.

In order to be successful, a proposal has to be relevant to BeagleBoard.org, a proposal topic that the mentors recognize (either from being proposed on this page or from the topic being discussed on our Google Group or on IRC), and sufficiently detailed that the mentors know exactly what you'll be creating and when it will be done. Successful proposals are also almost always shown to mentors via IRC well before the submission deadline so that the mentors can comment on it and offer suggestions that improve the proposal.

Start your proposal early, speak with the mentors often, and dedicate an appropriate amount of time to both thinking about the deliverables for your project and how you can describe those deliverables in writing.

Idea template

Please place your idea in a suitable section.

Summarizing project name

Longer summary of the project.
Goal: Concise statement that describes completion.
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.

Feel free to look at previous ideas and migrate some here.

Kernel improvements

Improvements to the Linux kernel or kernel related projects in userspace that powers the basic infrastructure on which the BeagleBoard runs.

USB configfs in device tree

To speed up the boot process by configuring USB statically in the device tree instead of it being conventionally done through a script at boot time.
Goal: USB configfs in device tree such that they can be configured statically in device tree ahead of boot and speed the boot process.
Hardware Skills: USB
Software Skills: C, Linux kernel, USB configfs
Possible Mentors: rcn-ee
Upstream Repository: https://github.com/beagleboard/linux/tree/4.19 kernel.org
References: https://events.static.linuxfound.org/sites/events/files/slides/USB%20Gadget%20Configfs%20API_0.pdf

Update Cape compatibility layer

Goal: Update the compatibility layer for BeagleBone Black and AI to support more kernel versions.
Hardware Skills: UART, I2C, SPI, ADC, GPIO and PWM
Software Skills: C, Linux kernel
Possible Mentors: Deepak Khatri, jkridner
Upstream Repository: various
References: Beagleboard:BeagleBone cape interface spec GSoC 2020 project page. lorforlinux's GSoC project documentation website.

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.

YOLO models on the X15/AI

Port the YOLO model(s) to the X15/AI so the accelerator blocks can be leveraged. Currently, running a frame through YOLOv2-tiny takes anywhere from 35 sec to 15 second depending on the how the code is run on the ARM.35 second being a pure brute force compilation for ARM; 15 second utilizing NEON and tweaked algorithms. The goal is to get things down to 1 second or less using the onboard accelerators. Note, there are over 6 different variants of YOLO (YOLOv1, YOLOv2, YOLOv2 and each one has a full size and a tiny version). The main interest is in getting either the YOLOv2 or YOLOv3 versions running. Please discuss with potential mentors on the desired approach as there are many approaches. Just to name a few: Porting the YOLO model into TIDL; OpenCL directly; OpenCL integration with the acceleration library; Integrating TIDL support with an acceleration library.
Goal: Run YOLOv2 or YOLOv3 with the onboard hardware acceleration.
Hardware Skills: None
Software Skills: C, C++, Linux kernel, Understanding of NNs and Convolution.
Possible Mentors: Hunyue Yau
Upstream Repository: Numerous
References: https://pjreddie.com/darknet/yolo/

OpenGLES acceleration for DL

Current acceleration on the X15/AI focuses on using the EVE and DSP hardware blocks. The SoC on those boards also feature an OpenGLES enabled GPU. The goal with this is to utilize shaders to perform computations. A possible frame work to utilize this on is the Darknet CNN framework.
Goal: Accelerate as many layers types as possible using OpenGLES.
Hardware Skills: None
Software Skills: C, C++, Linux kernel, OpenGLES, Understanding of NNs and Convolution.
Possible Mentors: Hunyue Yau
Upstream Repository: Numerous
References: https://pjreddie.com/darknet/

GPGPU with GLES

The BeagleBone and related boards all have a built in GPU that is often unused. It would be useful to create samples showing how it can be used for GPGPU purposes.Since there is no OpenCL drivers, this would need to be done with OpenGLES 2.0. The samples should take data from a C style array and load it onto the GPU. The GPU would then perform the task using sample shader code. The processed data would be retrieved from the GPU back into another C style array. A few processing tasks can be shown - simple do nothing to illustrate moving data between the CPU and the GPU and a real processing task such as running the image against a small kernel (convolution). Sample programs should also have a way of showing the time costs in moving data between GPU and CPU.

BeagleConnect - Low-Power Wide Area Networking

See https://github.com/jadonk/beagleconnect. The BeagleConnect Freedom board runs the Zephyr RTOS has mikroBUS ports along with BLE and Sub-GHz radios on it. The code to enable a Linux gateway for the Sub-GHz radio is in the repository.

Micropython for BeagleConnect Freedom

Goal: Enable Micropython for BeagleConnect Freedom along with basic GPIO, I2C, SPI, PWM, ADC drivers.
Hardware Skills: Basic wiring
Software Skills: C, RTOS
Possible Mentors: jkridner
Upstream Repository: https://github.com/micropython/micropython/tree/master/ports/zephyr
References: https://github.com/zephyrproject-rtos/zephyr, https://github.com/jadonk/beagleconnect

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 making automation easy
  • open source PLC software

librobotcontrol support for BeagleBone AI and Robotics Cape

Goal: Complete implementation of librobotcontrol on BeagleBone AI.
Hardware Skills: Basic wiring
Software Skills: C, Linux
Possible Mentors: jkridner, lorforlinux
Upstream Repository: https://github.com/jadonk/librobotcontrol/tree/bbai
References:http://www.strawsondesign.com/docs/librobotcontrol/index.html

Makecode Arcade for PocketBeagle GamePup

Makecode is a framework for creating special-purpose programming experiences for beginners, especially focused on computer science education. Makecode has a blockly based programming environment served on the browser along with an in-browser board simulator. MakeCode Arcade is a similar environment to MakeCode, but the environment has code blocks that are oriented towards building games. The goal of this project is to support the Makecode Arcade target for the Beaglebone boards and demonstration of example games on the Pocketbeagle Gamepup Cape.

Goal: Makecode target for Beaglebone boards with Breadboard simulator functionality making use of a UF2 daemon running in Beaglebone
Hardware Skills: Basic breadboard prototyping skills
Software Skills: Linux,Javascript,PXT
Possible Mentors: Andrew Henderson
Upstream Repository: TBD
References: https://github.com/microsoft/pxt-arcade , https://github.com/microsoft/uf2-linux , https://beagleboard.org/capes

Blynk support for BeagleBone Boards

Blynk is a hardware-agnostic IoT platform with white-label mobile apps, private clouds, device management, data analytics, and machine learning. There are no good examples of Blynk with BeagleBone boards and there is no option for it in their mobile App right now. This project will change that and provide good visibility for BeagleBone boards with well-documented examples and How-To guides.

Goal: Blynk support for BeagleBone Boards (Black, AI, Blue, and Pocket) with well-documented examples
Hardware Skills: Basic breadboard prototyping skills
Software Skills: Linux and Javascript
Possible Mentors: Deepak Khatri, Vedant Paranjape
Upstream Repository: TBD
References: TBD

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) (see more projects below)
  • LED lighting (Falcon Player, PocketScroller, etc.)

Another approach is to add support for Verilog (or VHDL) to synthesis PRU code for the soft peripherals. This can be based on the open source verilog toolchains.

Add features to simpPRU

Goal: Improve the features of simpPRU, namely implement a better error handler, add support for calling C code directly into simpPRU, also fix the known issues given the docs. If possible also fix the docs website
Hardware Skills: Minimal
Software Skills: C, Linux, Compilers
Possible Mentors: Vedant Paranjape, Andrew Henderson
Upstream Repository: https://github.com/VedantParanjape/simpPRU/
References: https://github.com/VedantParanjape/simpPRU/wiki#things-to-be-implemented-in-future, https://github.com/VedantParanjape/simpPRU/wiki#known-issues, https://github.com/VedantParanjape/simpPRU/issues/5

Python for PRU

Goal: Use Python to program PRUs References: https://github.com/beagleboard/cloud9-examples/blob/3852ee0a11d5e5428a45576e528337f28a3822ef/PocketBeagle/pru/.work-in-progress/pruspeak.pru0.c

Patching Beaglebone PRU DMA support to the latest kernel versions

Goal: The BeagleBone PRU DMA project made use of the EDMA controller to transfer data between PRU and main (DDR) memory. Without DMA, the 2nd PRU on the PRUSS is utilized/wasted for data transfer. The project needs to be patched to the latest kernel version as it is currently in a non-working state. It could then also be integrated with PRUSS-Bindings to create a complete PRU API.
Hardware Skills: Minimal
Software Skills: Linux, C, kernel modules
Possible Mentors: Pratim Ugale
Upstream Repository: https://github.com/beagleboard/linux, https://github.com/pratimugale/PRUSS-Bindings or a fork of https://github.com/maciejjo/beaglebone-pru-dma
References: https://gist.github.com/maciejjo/58a0d0213712e67fba9d0061f6b5bead, https://github.com/maciejjo/beaglebone-pru-dma/issues, https://github.com/pratimugale/PRUSS-Bindings/wiki

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 UIO. The BeagleBoard community mostly desires to migrate PRU development to remoteproc to give the Linux kernel greater knowledge of the cores.

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.
Hardware Skills: N/A
Software Skills: C, assembly, Linux kernel
Possible Mentors: Kumar Abhishek, Zubeen Tolani, Andrew Henderson
Upstream Repository: https://github.com/beagleboard/am335x_pru_package
References: v5 examples TI Training Labs

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.
Hardware Skills: Some understanding of I/O is needed esp if the I2C master is choosen.
Software Skills: C, assembly, Linux kernel
Possible Mentors: Kumar Abhishek, Zubeen Tolani, Giulio Moro, Andrew Henderson
Upstream Repository: N/A
References: BeagleLogic & BeagleScope from previous years.

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)
  • security appliance (Pangolin, ZeroTier Edge device)
  • self-hosted services (Freedombone)
  • car hacking (Macchina)

Example idea, a portable/plugable security appliance for use anywhere:

  • hardware: beaglebone with ethernet or beaglebone wireless, pocketbone + USB ethernet/wifi
  • OS: openwrt
  • configuration UI: bonescript/other
  • PRU accelerators...
  • privacy and safety tools...

Make port of Xen on BeagleBoard-x15

The project idea is to make Xen hypervisor available and easy to use on beagleboard-x15. To achieve this, it is planned to write Xen-supporting code and tutorials for Xen setup on the board. Another project goal is to improve user experience by working on optimizations for Beagleboard's kernel virtualization support code and/or on user-space tools.
Previously, the problem was discussed in xen mailing list and in beagleboard mailing list. The general solution wasn't provided and it seems that the problem still does exist.
The virtualization will make prototyping of virtualization-based security solutions easier in such areas like automotive computing and mobile privacy (BYOD problems).

Goal: to make virtualization available for end-users on Beagleboard-x15.
Hardware Skills: basic electronics.
Software Skills: C, C++, Linux kernel, Xen.
Possible Mentors: Andrew Henderson, Michael Welling.
Possible Co-mentors: Stefano Stabellini, Julien Grall, Iain Hunter.
Upstream Repository: N/A.
References: xen mailing list beagleboard mailing list

Beagle Bone Audio Applications

Porting multi-channel sound card drivers to recent kernels

Goal: Porting sound card drivers to recent kernels

Background / References: https://hackaday.io/project/9634-ctag-face-and-beast-multichannel-audio-systems

Software Skills: C/C++, Linux, Kernel

Possible Mentors: rma, henrix

IP Media Streaming

Goal: Building on a Beagle GSoC project of 2017 and 2020, the idea is to extend / add audio network streaming capabilities using the AVB and / or the Ravenna / AES67 standards.

Background / References: https://niklaswan.github.io/GSoC-Overview https://elinux.org/BeagleBoard/GSoC/BeagleBoneAVB

Software Skills: C/C++, Linux, Kernel

Possible Mentors: rma, henrix

Bela support on BeagleBone AI (and/or newer BB boards)

The Bela cape is working on the BB AI using ALSA (although one of the clocks seems to be of the wrong frequency), so we can confirm the pinout and pin settings are OK. We have not tried running the Bela code on the PRU yet. You'll need to know (or learn!) a bit about pinmuxing, uboot, PRU assembly and more in general the Sitara family of SoCs and the McASP audio port.

Goal: add support for the Bela cape + Xenomai + PRU on the BeagleBone AI. Hardware Skills: reading and understanding datasheet and technical reference manual
Software Skills: C, PRU, dtb, uboot, make Possible Mentors: Giulio Moro
Upstream Repository: https://github.com/BelaPlatform/Bela, https://github.com/giuliomoro/bela-cape-no-pru, and more

Bela audio driver for common audio APIs

Bela uses its own custom audio API which bypasses ALSA altogether. When adding support for Supercollider and Csound, we had to add a new audio driver to these pieces of software to call into Bela’s C API. In order to make the process of adding Bela support to more programming languages in the future easier, we could think of simply adding Bela support to some common audio backend libraries, so that a single effort can be reused across several pieces of software that use that same library. Examples of such libraries are: portaudio, rtaudio and jack and there may be more. In this project you’ll write a Bela driver for one or more of these libraries and build at least one application that uses the library (e.g.: ChucK, which uses RtAudio or Pure Data, which uses portaudio). You will need a good knowledge of C and build systems. Upon successful completion, the project will make it easier to add more applications and programming languages to Bela.

Goal: Improve the portability of Bela code across audio APIs/ Hardware Skills: Minimal
Software Skills: C / make Possible Mentors: Giulio Moro
Upstream Repository: https://github.com/BelaPlatform/Bela, https://github.com/thestk/rtaudio, https://github.com/PortAudio/portaudio

Live patching of Pure Data on embedded devices

Pure Data (Pd) is a visual data-flow language for audio applications and it is one of the several languages supported by Bela. Pd ships as a cross-platform software with a C backend and a Tcl/Tk GUI (replaced by HTML5 in the PurrData project). When running Pd on Bela, the user can leverage the analog and digital I/Os of the board to integrate audio processing with the physical connectivity capabilities of the board. Bela provides access to a browser-based IDE for programming the board but, since a desktop environment is not available, the current workflow for using Pure Data on Bela consists in editing the patch on the host computer and then copying it over to Bela where it gets executed.

One of the limitations of this two-step workflow is that the immediateness of the live-patching behaviour of Pd is lost. In this project, the student will leverage the fact that Pd communicates with its GUI via a socket to run the GUI on the host computer while running the audio backend on Bela. This requires a number of adaptations to Pd, including:

  • managing the GUI startup process to allow GUI and audio backend to be started separately and connect to each other
  • allowing access to paths on the remote device
  • loading patches through the GUI instead of from the backend
  • delegating some of the functionalities currently handled in the backend to the GUI

Knowledge of C is required as part of the work will take place in the audio backend, however there will be need to operate on the GUI side as well. A good starting point for the project would be last year's GSoC project which managed to run PurrData entirely in the browser. At the end of a successful project we should be able to submit a pull request in the upstream Pure Data or Purr Data repositories. The benefits of this contribution will not be exclusive to Bela, but can benefit the Pd community at large, making it easier to use Pure Data on embedded devices.

Goal: Allow live patching of Pd on embedded devices. Hardware Skills: Minimal
Software Skills: C (minimal), Javascript/HTML or Tcl/Tk
Possible Mentors: Giulio Moro
Upstream Repository: http://github.com/pure-data/pure-data/, https://git.purrdata.net/jwilkes/purr-data/, https://gist.github.com/hugonxc/75e0bb838b1953cfa52fa87045bf5b98#file-gsoc2020_hugocarvalho_purrdata-md

Other Bela applications

Bela is a platform for ultra-low latency audio and sensor applications based on the BeagleBoard family of boards. It uses PRU and Xenomai at its core. https://bela.io

Browser-based workbench

Bela features a browser-based oscilloscope for visualising audio and sensor signals. This project would extend the oscilloscope into a more full-featured laboratory workbench.

The oscilloscope itself could be extended in several ways, for example:

  • More options for scaling the plot in each axis
  • Adjustable cursors for reading off measurements in time or amplitude
  • Automatic detection of amplitude or frequency from the plot
  • More options for triggering
  • XY mode
  • Updated visual appearance

On top of that, other workbench tools could be added, including:

  • Waveform generator
  • Multimeter (RMS amplitude, frequency, DC offset, etc.)
  • Browser-based simulation of common analog and digital inputs (buttons, potentiometers etc.) and outputs (e.g. LEDs) This project would be built primarily in JavaScript, with some secondary work in C++ to connect to the Bela core code. We are open to the inclusion of existing open-source libraries to build any of these components.

Goal: Improve the features of the Bela oscilloscope and turn it into a full-fledged workbench for audio-rate signals. Hardware Skills: Minimal
Software Skills: Javascript, HTML, frontend
Possible Mentors: Giulio Moro
Upstream Repository: https://github.com/BelaPlatform/Bela/

Building Bela image

The image that Bela ships with is built from this repo, which was initially inspired by the upstream image-bulder repo, but it has greatly diverged from it. The purpose of this project is to “rebase” the functionalities of the bela-image-builder repo on top of the image-builder one. This is not simply a matter of git rebase, as the two codebases are drastically different. It is more of a “semantic rebase”: understand the motivations behind the features of the bela-image-builder repo (minimal clutter, custom kernel, custom software, custom systemd configuration) and add those to the image-builder repo in a way that makes it easier to maintain. Wherever possible, the Bela-specific changes should be made conditional so that a pull request can be opened upstream to minimise future development effort. You will need experience with scripting (mostly bash), build systems and Linux management. Upon successful completion of the project, the Bela image will follow more closely the upstream development and as a consequence it will be updated more often and more easily.

Goal: Improve the maintainability of the Bela image by forking it off the beagleaboard image-builder rep. Hardware Skills: Minimal
Software Skills: bash, kernel building
Possible Mentors: Giulio Moro
Upstream Repository: https://github.com/BelaPlatform/bela-image-builder, https://github.com/beagleboard/image-builder

Browser-based IDE

Bela’s browser-based IDE is served by a node.js server running home-grown modules and a HTML5 frontend based around jquery, ace.js and scss. The codebase started out in 2015 for internal development purposes, it has since been made public and has gone through two major redesigns during its 6-year lifetime. It allows the user to browse projects and examples, edit files and build and run projects. Over time, the frontend/backend relationship has evolved to support a number of Bela-specific features.The software landscape has changed radically since 2015 and there are now several great web-based IDEs out there. The scope of this project is to evaluate how a Bela-like workflow and appearance could be implemented on top of a more modern and better supported browser-based IDE, such as Cloud9 (or - better - something with a more liberal license). You will start by verifying that the requirements for frontend-backend communication logic can be met on the new platform. Then you will write a proof of concept skin for the new platform that mimics, where possible, the existing Bela one. You will need knowledge of web technologies, both for frontend and backend.

Goal: Improve the core foundation and maintainability of the Bela IDE. Hardware Skills: Minimal
Software Skills: Javascript / HTML / frontend
Possible Mentors: Giulio Moro
Upstream Repository: https://github.com/BelaPlatform/bela-image-builder, https://github.com/beagleboard/image-builder

FPGA based projects

Beaglewire Updates

Beaglewire is an FPGA cape for the Beaglebone black that was developed to support a project for the 2017 season of GSoC. This first year of Beaglewire support was very intensive and there some issues were left to be resolved. The most notable known issue is with the SDRAM interface working sporadically. A student interested in Verilog, kernel coding and hardware would be an ideal candidate. Each of the subsystems (SPI, PWM, UART, SDRAM, etc) can be tested, corrected if necessary and improved if desired. Furthermore, it may be interesting to implement nMigen support for flexible python based gateware support as a stretch goal.

Goal: Improve the Gateware/Firmware support for the Beaglewire cape
Hardware Skills: Schematics, Verilog
Software Skills: Kernel coding
Possible Mentors: Michael Welling
Upstream Repository: https://github.com/mwelling/BeagleWire, https://github.com/mwelling/beagle-wire

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
Hunyue Yau ds2 English Pacific C, PASM Any No specific focus/any
Kumar Abhishek Abhishek_ Hindi English IST C, PRU Assembly, bit of JS Almost everything PRU- or kernel- based projects, but could help with any project
Ravi Kumar Prasad ravikp7 Hindi English IST JavaScript, C Wiring, Basic debugging BeagleBoot
Michael Welling m_w English - US Pacific C, Linux kernel schematics, PCB, FPGA, Robotics kernel development
Patryk Mezydlo pmezydlo Polish English CET C, kernel development datasheets, schematic review, debug, kicad
Cathy Wicks cwicks English - US Central - - GSoC Admin, Organizational
Henderson, Andrew hendersa English - EST/EDT (UTC-5) C/C++, PRU, Linux userspace/kernel Prototyping, KiCad PCB PRU/Kernel projects, Linux userspace multimedia, Security
Drew Fustini pdp7 English - CET and US CDT C, Python, Linux schematics, PCB layout, KiCad Python libraries (Adafruit_BBIO & Blinka), Linux drivers
Zubeen Tolani zeekhuge Hindi English IST C, C++, Java, JS, PRU assembly Basic PRU, Kernel, Deep learning
Robert Manzke rma German English, Spanish CET C, C++ PCB, mixed mode design Audio, media network streaming protocols
Stefano Stabellini sstabellini Italian English PST Xen, C, kernel development - Xen on Beagleboard
Julien Grall julieng French English GMT/BST Xen, C, kernel development - Xen on Beagleboard
Iain Hunter driain English GMT/BST C, kernel,yocto Cape design
Steve Arnold nerdboy English Applied Math PST8PDT Python, toolchains, OS images beaglebones, peripherals/sensors Networking, security/privacy tools
Henrik Langer henrix German English CET C, C++, Linux, PREEMPT_RT, Xenomai PCB, mixed mode design Audio, media network streaming protocols
Deepak Khatri lorforlinux Hindi English IST Python, C, C++, Linux PCB, Wiring, Debug, Robotics, BioMedical Robotics and BioMedical
Pratim Ugale pratimu Hindi English IST Python, PRU Assembly, Java Basic debugging PRU, Deep Learning
Vedant Paranjape vedant16 Marathi English, Hindi IST Python, C, C++, Linux, Boost lib, PRU, pru-gcc, flex, bison PCB Design (kicad), Robotics, Soldering PRU, Kernel Development, PCB design
Saketha Ramanujam S.S. sakethr98 Telugu English, Hindi US Mountain Time Python, C, a bit of JS and pru-gcc Schematics, PCB Design(Eagle), Wiring/Debugging PRU, Kernel Development, Signal Processing
Tim Orling moto-timo English Spanish (non-technical) US Pacific Python, Yocto Project, Linux OS, system engineering, C, JavaScript analog, schematics, PCB layout, Kicad, Eagle Yocto Project, Python libraries (Adafruit_BBIO & Blinka), PRU
Giulio Moro giuliomoro Italian English, Spanish Western Europe (London) C, PRU, dtb, Xenomai Bela!
Anuj Deshpande anujdeshpande English - IST (GMT+530) C, python, zephyr, greybus, linux schematics, kicad, debug BeagleConnect
Arthur Sonzogni arthursonzogni French English CEST GMT+2 C++, JS, Linux, Math N/A FTXUI (Terminal UI)

Previous mentors