JohnBuschert

Thanks Giulio. I changed the label on that 5V supply to "Ext/USB" to better reflect the source and the current as "250mA or more depending on the source" as per your information. I've attached the latest version of the diagram in png format. I also corrected the D10 label. I can't seem to upload pdf to this forum, is there a trick to that?

Here is a hover free pin diagram with other useful hardware info on it. LFSaw was working on one back in August but it was the wrong orientation. I wanted one to post on my wall, so I made my own and here it is for anyone to use. I changed the color scheme for many of the pins because the scheme used in the IDE hover diagram is truly bizarre (ground is red!!??). LFSaw had a good idea to put other useful hardware info on the diagram which I have also done. It's hard to find some of this and I'm still unsure of a couple items so here are my questions:
1. The BBB specs say that the 5V supply has 250mA available. Bela info repeats that. But the Bela board draws some current for itself so there can't still be 250mA left. Does anyone know how much is realy available from the regulated 5V line on Bela to power user circuitry?
2. The "weak" 5V line has a resistor in series that is named as 100 ohms in one place and 220 ohms in another. I can see no value listed on the schematic.

Is there any other useful hardware information that should be included? I'd be glad to make further revisions.

Thanks Giulio.

You were enormously helpful! I've been delayed by many other things. But with your fixes I finally got it all working. Now I have a library that can be used to get Bela to talk to most simple 16x2 or 20x4 character LCD displays such as this one I'm using.


This is a Sunfounder 20x4 display I got on Amazon for $12
Here is a link to my github LCD_I2C folder for anyone that wishes to use this library or give me advice.

And here is the header file for quick reference:

/* LCD_I2C.h   version 1.0 2022-10-28
   LCD w I2C writing routines header file
   This library allows Bela to write to a 20x4 LCD display via I2C
   It has been tested and works with the Sunfounder I2C LCD 2004
   It should work with most 16x2 or 20x4 displays that have an I2C backpack
   Specifically those using the HDD44780 and PCF8574T chips which seem to be common.  
   It does the same thing as the LiquidCrystal_I2C library for Arduino and other things but 
   instead of just encapsulating that yet one more time, I rewrote it but included most of 
   the LiquidCrystal_I2C commands for compatibility.
*/
#include <I2c.h>
#include <string>

class LCD_I2C : public I2c
{
	public:
		LCD_I2C (int bus, int address);  // Constructor.  For Bela the usual I2C bus is 1, the I2C address depends on your device

	//  standard commands in common with Liquid_Crystal_I2C library
		void clear();  // clears the display
		void home();   // returns cursor to row 0 col 0
		void setCursor(uint8_t row, uint8_t col);  // sets cursor at row(0-3), col(0-20) or whatever size you have
		void write(std::string text);  // writes text starting at cursor's location
		void noDisplay();
		void display();
		void noBlink();
		void blink();
		void noCursor();
		void cursor();
		void noBacklight();
		void backlight();
		void begin();  // unneeded null function kept only for compatibilty

	//  new commands
		void setCursorWrite(uint8_t row, uint8_t col, std::string text);  // sets cursor to coords and then writes text
		void mode(int backlight, int display, int cursor, int blink); // 1 or 0 sets all these on or off
		
	/*	not yet implemented from LiquidCrystal_I2C library
		scrollDisplayLeft
		scrollDisplayRight
		printLeft
		printRight
		ledftToRight
		RightToLeft
		shiftIncrement
		shiftDecrement
		autoScroll
		noAutoScroll
		createChar
		printRight
		init
		oled_init
	*/

	private:

	//  Lower level commands that differ from LiquidCrystal_I2C
		void sendChar(uint8_t);
		void sendCommand(uint8_t hiNib, uint8_t loNib);
		void sendNibble(uint8_t nib, uint8_t rs);
		void transmit(uint8_t byte);

		uint8_t buf[2] = {0,0};  // buffer for characters pass to I2c write (it wants an array, maybe could have been a pointer)		
		uint8_t nibble =0;
		uint8_t hiNib = 0;
		uint8_t loNib = 0;  
		int gbacklight = 1;  // default value when started
		int gdisplay = 1;  
		int gcursor = 1;
		int gblink = 1; 
		uint8_t homeAddress[4] = {0x00, 0x40, 0x14, 0x54};   // beginning address of each line for 2 or 4 line displays
		
		

};

I've seen a few people wondering about using soundfonts on Bela. I found an easy way to do this that works very well. The key is to use TinySoundFont, a soundfont synthesizer written by Bernhard Schelling. It's a single header file written in C/C++ with zero dependencies! It was easy to incorporate into Bela and it worked almost immediately when I first tried it. The only downside I see is that the he did not implement a few more advanced features and he is no longer working on it. But what he created has worked very well for me.

[TinySoundFont]<https://github.com/schellingb/TinySoundFont>

At the beginning of the tsf.h header file is a long comments section explaining how to use it and giving examples. My code is derived from those examples and I list all the pieces you need to use it with Bela below.

The first part goes at the beginning of the Bela program (before Setup)
You need to set the soundfont filename to whatever soundfont you wish to use and upload that soundfont file into the resources section of your project. Also set the preset to whatever preset you wish to use from the soundfont.

// Setting up Tiny Sound Font synthesizer ---
#define TSF_IMPLEMENTATION
#include "tsf.h"
int max_voices = 32;  //  This affects the number of notes it can keep up with.
int samplerate = 44100;
float tsf_gain_db = 10;  // tsf output gain in dB
float tsf_bufferptr[64];  // buffer for 160 samples
const char *filename = "Piano.sf2";  // soundfont filename
const char *presetNames[25];
int preset = 2; // preset from the soundfont (often 0 if there is only one preset)
tsf* fontptr;

This next part goes in the setup section

// setup section for tsf -----
fontptr = tsf_load_filename(filename);
tsf_reset(fontptr);
tsf_set_max_voices(fontptr, max_voices);
tsf_set_volume(fontptr, 1.0);
tsf_set_output(fontptr, TSF_MONO, samplerate, tsf_gain_db);

Then in the Render section, in response to inputs whenever you decide to start a note you can use the following. There are many other commands available as well, this is just the simplest starting point. You need to understand that this just tells tsf that you want a note to stop or start, so the next time it is called to do rendering is when these changes will take effect.

tsf_note_off_all(fontptr);                       // turn off any previous notes             
tsf_note_on(fontptr, preset, pitch, velocity);  // start a new note: pitch is midi note number, velocity is 0-1.0

Lastly this section goes at the end of the Render section (after the close of the n loop over all the frames but before the close of Render) so it is only executed once per render call. I tried calling tsf_render for each sample but that took too much time and Bela complained of mode switches and it sounded terrible. But doing with one call per block has worked very well.

//  Call tsf to render a block of samples in one call and then write them all to Bela's audio output.
int samples = context->audioFrames;  //  number of audio samples in a block
tsf_render_float(fontptr, tsf_bufferptr, samples, 0);  // tsf outputs block of samples into its buffer
for (int i2 = 0; i2 < context->audioFrames; i2++){  // copy from tsf buffer to Bela output
	float output = tsf_bufferptr[i2];
	audioWrite(context, i2, 0, output);  // 0=left 1=right
	audioWrite(context, i2, 1, output);  // 0=left 1=right
}

This worked for me. I hope it can be useful to someone else.
-John

I'm new to this forum, I've been working on a long term project with Bela for some time with a few students and I have wished for a better diagram of the hardware and software I/O timing on Bela. I keep adding to it as I learn more about the system and think of better arrangements. The main idea is to have time flow from left to right and have hardware at the top and software at the bottom. Attached is my latest version. I'd be glad for corrections, criticisms, suggestions or any comments. It does not show the analog output and I'm aware that the audio output should be shown and described as going through a DAC before the output amp. Apart from that, Is this correct? Is it of any use to any of you?
John