BeagleBoard/GSoC/Ideas-2021

=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 2019 student application window is open March 25th 2019!

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 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:
 * 9) what was accomplished that week,
 * 10) any issues that prevented that week's goals from being completed and
 * 11) your goals for the next week.
 * 12) 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
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

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.

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.

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.

Greybus over 802.15.4
802.15.4-based Greybus (instead of Unipro as used by Project Ara), where every 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: 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. Hardware Skills: I2C, SPI, UART, PWM, ADC, GPIO basic wiring Software Skills: C, Linux, BeagleBone, Launchpad Possible Mentors: jkridner Upstream Repository: TBD 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

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

click board support under Greybus
Today, support for click boards on PocketBeagle is accomplished via device tree overlays via the bb.org-overlays repository*. 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 Greybus simulator opens up a different possibility. Greybus already provides most of the interfaces used on click boards and utilizes 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. Goal: Greybus drivers, userspace simulator and example manifests for several MikroElectronkia click boards using PocketBeagle. Hardware Skills: Some preliminary understanding of some basic interface protocols like UART, I2C, and SPI Software Skills: Linux kernel modules Possible Mentors: Jason Kridner Upstream Repository: https://github.com/beagleboard/linux, https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc (1) References: https://lwn.net/Articles/715955/

Makecode Target for BeagleBone
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. Goal: Makecode target for Beaglebone boards with Breadboard simulator functionality making use of Bonescript RPC. Hardware Skills: Basic breadboard prototyping skills Software Skills: Javascript,PXT,BoneScript Possible Mentors: TBD Upstream Repository: TBD References: https://www.microsoft.com/en-us/makecode, https://github.com/Microsoft/pxt-maker

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.)

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
Goal: Provide a simple API across multiple programming languages to use with the PRUs to load binaries, and communicate with the PRUs from userspace. Hardware Skills: Minimal '' Software Skills'': Linux, C and Python programming Possible Mentors: Kumar Abhishek, Zubeen Tolani Upstream Repository: https://github.com/beagleboard/linux, https://github.com/beagleboard/pypruss References: https://bitbucket.org/intelligentagent/pypruss, https://beagleboard.org/latest-images

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 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 Upstream Repository: N/A References: BeagleLogic & BeagleScope from previous years.

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/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. 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. Software Skills: C, kernel driver development, kernel device tree, PRU programming, interfacing with kernel drivers using ioctl calls from user space. Possible Mentors: Andrew Henderson, Zubeen Tolani Upstream Repository: TBD References: http://www.ti.com/lit/ds/sdfs071b/sdfs071b.pdf, https://www.arduino.cc/en/Tutorial/ShiftOut

PocketBeagle Stepwise Mathematics
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. Hardware Skills: Medium. Ability to Interface/Integrate a Membrane/Capacitive Keyboard and a Matrix display.Ability to Get the Beagle running on a Lithium Ion thin Battery.

Software Skills: Python, C/C++, Linux, Knowledge of Compiler's

Possible Mentors:

Upstream Repository: N/A Refrences: N/A

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)

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 Network 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.

Background / References: https://elinux.org/BeagleBoard/GSoC/BeagleBoneAVB

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

Possible Mentors: rma

=Mentors= Previous mentors