Difference between revisions of "BeagleBoard/GSoC/2021 Proposal/bela on bbai"

From eLinux.org
Jump to: navigation, search
(Proposed method of Implementation and Timeline)
(Description)
Line 35: Line 35:
 
As given on the [https://learn.bela.io/get-started-guide/say-hello-to-bela/#what-is-bela official website], Bela is a hardware and software system for creating beautiful interaction with sensors and sound. Bela consists of a Bela cape on top of a BeagleBone Black computer (uptil now).  
 
As given on the [https://learn.bela.io/get-started-guide/say-hello-to-bela/#what-is-bela official website], Bela is a hardware and software system for creating beautiful interaction with sensors and sound. Bela consists of a Bela cape on top of a BeagleBone Black computer (uptil now).  
 
Bela has a lot of analog and digital inputs and outputs for hooking up sensors and controlling other devices, and most importantly Bela has '''stereo audio i/o'''  allowing you to interact with the world of sound. <br>
 
Bela has a lot of analog and digital inputs and outputs for hooking up sensors and controlling other devices, and most importantly Bela has '''stereo audio i/o'''  allowing you to interact with the world of sound. <br>
Both Bela systems use the same Bela software. It uses a customised Debian distribution which - most notably - uses a '''Xenomai kernel''' instead of a stock kernel. ''Xenomai'' is ''co-kernel'' for Linux which allows to achieve hard '''real-time performance''' on Linux machines (http://xenomai.org/). It thus takes advantage of features of the BeagleBone computers and can achieve extremely fast audio and sensor processing times.  
+
Both Bela systems use the same Bela software. It uses a customised Debian distribution which - most notably - uses a '''Xenomai kernel''' instead of a stock kernel. ''Xenomai'' is ''co-kernel'' for Linux which allows to achieve hard '''real-time performance''' on Linux machines (http://xenomai.org/). It thus takes advantage of features of the BeagleBone computers and can achieve extremely fast audio and sensor processing times.
 +
Although the proposal Title mentions support for AI, I will try to develop a standardized setup that allows an easy jump across all TI chips.  
 
;Applications of Bela:  
 
;Applications of Bela:  
 
Bela is ideal for creating anything interactive that uses sensors and sound. So far, Bela has been used to create:
 
Bela is ideal for creating anything interactive that uses sensors and sound. So far, Bela has been used to create:
Line 44: Line 45:
 
and many more applications that are listed [https://learn.bela.io/get-started-guide/say-hello-to-bela/#what-is-bela here]
 
and many more applications that are listed [https://learn.bela.io/get-started-guide/say-hello-to-bela/#what-is-bela here]
 
;Why add support for BBAI?  
 
;Why add support for BBAI?  
The Beagle Black and PocketBeagle are getting outdated by the day and also it would be better to have a more standardised setup that allows to more easily jump across TI chips, soon newer boards with different and more efficient chips like the AM5X in the BBAI are coming up that need compatiblity with the Bela Software and Hardware. Delegating peripheral initialisation to the mcasp and spi drivers instead of doing it all by setting registers manually should hopefully make it more portable for porting to other boards in the family, present or future.  
+
The Beagle Black and PocketBeagle are getting outdated by the day and also it would be better to have a more standardised setup that allows to more easily jump across TI chips, soon newer boards with different and more efficient chips like the AM5X and the TI C66x digital-signal-processor (DSP) cores in the BBAI are coming up that will need compatiblity with the Bela Software and Hardware. Delegating peripheral initialisation to the mcasp and spi drivers instead of doing it all by setting registers manually should hopefully make it more portable for porting to other boards in the family, present or future.  
 
;Programming languages and tools to be used:  
 
;Programming languages and tools to be used:  
 
C, PRU, dtb, uboot, make
 
C, PRU, dtb, uboot, make

Revision as of 11:32, 11 April 2021


ProposalTemplate

{{#ev:youtube|https://www.youtube.com/watch?v=aVLRUyPBBJk}} About Student: Dhruva Gole
Mentors: Giulio Moro
Code: https://github.com/BelaPlatform/Bela
Wiki: https://learn.bela.io/get-started-guide/say-hello-to-bela/#what-is-bela
GSoC: GSoC entry

Status

This project is currently just a proposal.

Proposal

Please complete the requirements listed on the ideas page and fill out this template.

About you

IRC: dhruvag2000
Github: https://github.com/DhruvaG2000
School: Veermata Jijabai Technological Inst.
Country: India
Primary language : English, Marathi, Hindi
Typical work hours: 10AM - 7PM Indian Standard Time
Previous GSoC participation: I find embedded and IOT pretty interesting, given I have experience with ESP32, SIMCOM, ESP8266, Atmega, and many other microcontroller devices and I think I will be able to excel in this project. This is the first time i am participating in GSoC.

About your project

Project name: Bela support for the BeagleBone AI

Description

What is Bela?

As given on the official website, Bela is a hardware and software system for creating beautiful interaction with sensors and sound. Bela consists of a Bela cape on top of a BeagleBone Black computer (uptil now). Bela has a lot of analog and digital inputs and outputs for hooking up sensors and controlling other devices, and most importantly Bela has stereo audio i/o allowing you to interact with the world of sound.
Both Bela systems use the same Bela software. It uses a customised Debian distribution which - most notably - uses a Xenomai kernel instead of a stock kernel. Xenomai is co-kernel for Linux which allows to achieve hard real-time performance on Linux machines (http://xenomai.org/). It thus takes advantage of features of the BeagleBone computers and can achieve extremely fast audio and sensor processing times. Although the proposal Title mentions support for AI, I will try to develop a standardized setup that allows an easy jump across all TI chips.

Applications of Bela

Bela is ideal for creating anything interactive that uses sensors and sound. So far, Bela has been used to create:

  1. musical instruments and audio effects
  2. kinetic sculptures
  3. wearable devices
  4. interactive sound installations

and many more applications that are listed here

Why add support for BBAI?

The Beagle Black and PocketBeagle are getting outdated by the day and also it would be better to have a more standardised setup that allows to more easily jump across TI chips, soon newer boards with different and more efficient chips like the AM5X and the TI C66x digital-signal-processor (DSP) cores in the BBAI are coming up that will need compatiblity with the Bela Software and Hardware. Delegating peripheral initialisation to the mcasp and spi drivers instead of doing it all by setting registers manually should hopefully make it more portable for porting to other boards in the family, present or future.

Programming languages and tools to be used

C, PRU, dtb, uboot, make

Proposed method of Implementation and Timeline

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. I will be learning and using pinmuxing, uboot, PRU assembly and reading about the Sitara family of SoCs and the McASP audio port. (ref. here)

Syntax Analysis

It can be seen from the syntax here that we are ennumerating the hardware the code is running on as follows:

typedef enum
{
	BelaHw_NoHw = -1,
	BelaHw_Bela,
	BelaHw_BelaMini,
	BelaHw_Salt,
	BelaHw_CtagFace,
	BelaHw_CtagBeast,
	BelaHw_CtagFaceBela,
	BelaHw_CtagBeastBela,
} BelaHw;

Compatibility is checked here in the form of

bool Bela_checkHwCompatibility(BelaHw userHw, BelaHw detectedHw);

Come the BBAI, as seen here

int cs_pin = 2 * 32 + 12; // P9.15a on BB AI

these lines have been commented out for the older BB boards, which means this code won't really work for BB Black or Blue.
To explain In the form of pseudo code how I aim to establish a common code base for supporting all boards, is by using:

typedef enum
 {
 	bb_ai,
 	bb_black
 }

So, once we detect which board it is that we are running on start-up, the constants will be set accordingly and the rest of the code base will become much easier to use without needing to hard code the pins specific to the beagle board the user is currently using.

PRU
  1. It is better to minimise PRU code changes
  2. Preferably changing the PRU code will not be changed in such a way that it stops working on current Bela images (which currently use pasm / uio). In particular, we do not want to force Bela on BBB/PB to move to using clpru / rproc.

The Solution to run the current PRU assembly (designed for pasm/uio) using clpru/rproc (as for the AI) is:

  1. No PRU code changes (at least not yet, we'll need to change the MCASP addresses at the very least, but at least there is no massive rewrite to do just to be able to run the code)
  2. The same code that is built with pasm to run with uio can be translated automatically into code that builds with clpru and runs with rproc. So any changes made to that code can be back/fwd ported between BBB and BBAI.
Workflow for building the PRU existing PRU code with clpru
  1. Build the .p file as is with pasm with `-V2 -b`. This generates a .bin file that contains the assembled program
  2. use the disassembler I put together hacking the one that was inside prudebug. Find it here https://github.com/giuliomoro/prudebug/tree/disassembler (built with `gcc da.c -o prudis`
  3. Process the bin through the disassembelr and make it ready to be included inside an __asm__ directive (i.e.: add quotes and prepend a space at the beginning of each line):
   prudis file.bin | sed 's/^\(.*\)$/" \1\\n"/' > included_assembly.h
  1. have the following in main.c:
void main()
{
     __asm__ __volatile__
     (
#include "included_assembly.h"
     );
}
  1. build main.c with the regular clpru toolchain

The above seems to work, but it would need some extra testing.

I will need to change the MCASP addresses:

#define MCASP0_BASE 0x48038000
#define MCASP1_BASE 0x4803C000
#define MCASP0_DATAPORT 0x46000000
#define MCASP1_DATAPORT 0x46400000
#define MCASP_BASE  MCASP0_BASE
#define MCASP_DATAPORT  MCASP0_DATAPORT
PINMUXING

I am yet to figure out pinmuxing to make sure the relevant pins are set to the correct function (they are NOT by default). I will see here https://elinux.org/BeagleBoard/GSoC/2020_Projects/Cape_Compatibility and/or ask on the BB slack about for the best way to go about it.

PRU->ARM INTERRUPTS

Bela can work with a PRU->ARM interrupt, which is default these days, but requires an rtdm driver, which is another layer of complications. To start off, I will try to run it without the PRU->ARM interrupt by adding BELA_USE_DEFINE=BELA_USE_POLL to my make command line.

PRU transitioning from libprussdrv to rproc

I will need to change the initialisation code in PRU.cpp that is currently relying on libprussdrv and move to using rproc . Not sure if rproc provides some functionalities to access the PRU's RAM the way `prussdrv_map_prumem()` used to, but that essentially gives access to a previously mmap'ed area of memory https://github.com/beagleboard/am335x_pru_package/blob/master/pru_sw/app_loader/interface/prussdrv.c , so it should be easy to replace, as long as I am able to find the correct addresses in the TRM. On the latest Bela code there's a `Mmap` class which can make this somehow simpler http://docs.bela.io/classMmap.html.


XENOMAI kernel

I would need to install a xenomai kernel through whatever the default procedure to update kernel is on the BBAI. I will also need to install the user-space Xenomai library as well. That MAY be available through apt-get (Xenomai >= 3.0), or it can be easily built from source.

Timeline
Mar 29 Applications open Students register with GSoC, work on proposal with mentors.
Apr 13 Proposal complete Submitted to https://summerofcode.withgoogle.com
May 17 Proposal accepted or rejected
  1. Community Bonding Period and discussion on the project and resources available.
  2. Setting up beaglebone-ai i.e flashing up to date Linux image and connect to local area network (LAN) via either Ethernet or WiFi and try to run bare_minimum code from this repository to test basic stuff is working.
Jun 07 Pre-work complete, Coding officially begins!
  1. All the boards and additional hardware will be available to me at this period of time and I should have set up my BeagleBone Black and Ai boards i.e flashing up to date Linux image and Testing user-led blink code :)
  2. Initial checks for hardware like audio ports and other peripheral devices will be completed and all the soldering related work will be done.
  3. A detailed spreadsheet will be created if not already available for cape pin mapping and referencing for further use during BeagleBone AI software development ease.

(above ref. from here )

Jun 17 Milestone #1,
  1. Introductory YouTube video
  2. Setting pinmux values appropriately and fix the dtb to get the correct clock on the McASP MCLK pin.
  3. verify it works running with ALSA using the BB-BONE-AUDI overlay.
June 24 Milestone #2
  1. test running Bela's PRU code on BBAI
  2. Try to run Bela without Xenomai (This requires changing a few calls to `__wrap_pthread_...()` in the Bela core code to `pthread_...()` and minor changes.)
June 30 Milestone #3
  1. run Bela with Xenomai, without rtdm_ (PRU->ARM interrupts)
  2. run Bela with Xenomai, with (PRU->ARM interrupts)
July 12 18:00 UTC Milestone #4, Mentors and students can begin submitting Phase 1 evaluations
July 16 18:00 UTC Phase 1 Evaluation deadline
July 23 Milestone #5
July 30 Milestone #6
Aug 06 Milestone #7
August 10 Milestone #8, Completion YouTube video
August 16 - 26 18:00 UTC Final week: Students submit their final work product and their final mentor evaluation
August 23 - 30 18:00 UTC Mentors submit final student evaluations

Experience and approach

  1. I have used C++, C and Python programming languages over the past 3 years in a variety of projects involving embedded systems using the ESP32, Arduino UNO, ESP8266 and am also well-versed with freeRTOS.
  2. I have an aptitude for writing good reports and blogs, and have written a small blog on how to use a debugger.
  3. I recently did a project using ESP32, in which I used the DHT11 sensor to display humidity and temperature on a local HTML server . Other than that I have worked on developing hardware and making documentation for a 3 DOF arm based on an ESP32 custom board.
  4. I also interned at an embedded device startup where I
    1. Interfaced ADS1115 ADC with the ESP32 and used it to read battery voltage.
    2. Used UART for ESP32 and SIMCOM SIM 7600IE communication to gain LTE support.
    3. Published local sensor data to the cloud via LTE.
  5. I actively contribute to open source (most recently, I contributed to the ADS1115 library for ESP32 on the unclerus repo and can be seen here).
  6. Currently I am working on designing a Development board for the Raspberry Pico (RP2040) using KiCAD.
  7. I also do a lot of mini projects throughout the year, you can find my several more interesting projects at my github page

Contingency

I believe that if I get stuck on my project and my mentor isn’t around, I will use the resources that are available to me. Some of those information portals are listed below.

  1. Derek Molly's beagle bone guide provides all the information needed for getting up and running with my beagle.
  2. Content on e-ALE.org is very useful for information that ranges from tutorials and walkthroughs to the level of very advanced stuff.
  3. https://credentiality2.blogspot.com/2015/09/beaglebone-pru-gpio-example.html

Benefit

If successfully completed, this project will add support for the Bela cape + Xenomai + PRU on the BeagleBone AI.

as far as the porting to BBAI project is concerned, it's mostly a matter of getting the right pins enabled, running the PRU code with rproc, probably modify some constants in the PRU code accounting for any difference in SPI, MCASP and GPIO between AM3358 and AM5729 and testing that it all runs with a Xenomai kernel. 

-giuliomoro

Misc

Completed all the requirements listed on the ideas page.
The code for the cross-compilation task can be found here submitted through pull request #149.