Samplerbox mit Novation Launchkey Mini MK2

das kleine MIDI-USB-Keyboard läuft gerade im Ausverkauf, – ich hatte es schon vorher und nicht allzu oft verwendet.
Beim MK2 fehlen einfach sehr viele Controls, die man bei anderen Keyboards erwartet. Pitchbend, Volume und Program-Change sind nicht als Buttons verfügbar.

Um es mit der Samplerbox-Hardware verwenden zu können kann man mit der Version von HansEV ein Mapping der MIDI-CCs zu den Controls durchführen.
Die Dateien liegen auf der SD im Ordner samplerbox oder wenn man sich per SSH auf die Box verbindet dann in /boot/samplerbox/ .
Volume habe ich auf den zweiten Poti gelegt und 2 Buttons sind nun Patch +/- – Buttons.
Button1 und Button2 wollte ich für die Reverb an/aus – das hat aber noch nicht funktioniert.

controllerCCs.csv in
Potentiometer
Controller,CC,Val,
#ModWheel,1,-1,# Standard controller is 1
#Volume,7,-1,# Standard controller is 1
ModWheel,21,-1,# Standard controller is 1
Volume,22,-1,# Standard controller is 1
Sustain,64,127,# Standard controller is 64
ButtonUp,104,127,# Launchkey Mini 2
ButtonDown,105,127,# Launchkey MIni 2
PotCC23,23,-1, # Launchkey Mini 2 Pot3
PotCC24,24,-1, # Launchkey Mini 2 Pot4
PotCC25,25,-1, # Launchkey Mini 2 Pot5
PotCC26,26,-1, # Launchkey Mini 2 Pot6
PotCC27,27,-1, # Launchkey Mini 2 Pot7
PotCC28,28,-1, # Launchkey Mini 2 Pot8
Button1,108,1,# Launchpad Mini
Button2,109,1,# Launchpad Mini

Samplerbox Hardware with Raspberry PI

The Project Samplerbox is still activ. (2020-01-26)
I used the image and instruction from http://homspace.xs4all.nl/homspace/samplerbox/index.html

I have tried to use earlier versions in last years but it does not work as expected with my older Raspi 1.
I bought a Raspberry 3+  to test samplerbox with it. For now it works fine with the last image from Hans!

Samplerbox-rearside,
3 Buttons, 1 LCD, 4 USB-Ports, the ethernet-Port is hidden in the case.
Side-View, with Left Audio Out, Right Audio-Out, MIDI

Bill of material to build a Samplerbox:

  • Raspberry Pi 3+ ( perhaps newer works too)
  • Powersupply, 5V, 2.5 Amps or more
  • SD-Card
  • generic USB-Sound-Card – or DAC-Board PCM5102
  • USB-Stick to store Samples
  • Case for the Raspberry Pi
  • Optional:
    • MIDI-Board (DIN-Socket, 1x10k, 1x1k, 1x 220Ohm Resistor, 6N138 Optocoupler, 1 Diode)
    • USB-MIDI-Keyboard or MIDI-Keyboard with DIN-MIDI if the MIDI-Board is build
    • LCD Display 16×2 HD44780 (16 Pins)
    • 3 Buttons
    • Status-LEDs: 2 LEDs & 220Ohm Resistor

I didn´t buy a lot because I had already most things in stock. I used “Guttagliss” – Hobbycolor plates to build a case and painted it with spray paint. Hobbycolor looks like plastic but is some more flexible and very easy to cut with a knife, could be glued, bend with the heatgun and painted. In the top of the case, I have cutted the holes for the LCD and the 3 Buttons. Finally I used a transparent acrylic-plate to cover to top. Finally, inside the case I used some layers of Hobbycolor-pieces to create some support structures to be able to fix the different circuit with woodscrews.

I created 3 circuit, first circuit to connect to all GPIO-Pins of the Raspberry PI and provides space for the PCM5102-Board.

Second a Circuit to hold the 3 Buttons and which has the width of the LCD. Both, button-board and LCD is mounted with four 3mm Screws and some layers of nuts to get the right distance to the top of the holes in the case.

Third circuit, and the last, is the MIDI-Converter, which transforms classical MIDI into 3.3Volts serial data. This board is the smallest and I have used a small circuit-board which is too small in my case because it has to be mounted very well and fixed with the case. The big DIN-Plug causes some force and this has to be managed with screws between DIN-Plug and the case.

If you would only test the software, the minimum would be Raspberry PI, a USB-Sound-Device which is compliant as Sounddevice for Linux and a USB-Keyboard. There is already one sound on the SD-Image.

My Result, – the view inside with the Circuits ( the MIDI-Circuit was added later)

, the background is the inside the case and is the backside of the top plate. The green Circuit is the LCD-Board. The board at the bottom is the board for the buttons.
The upper board connects to the Raspberry Pi and on its backside, there is the PCM5102-DAC and all the wired. The upper Breadboard is fixed by 4 screws. The 2 jacks on the right-side are the Audio-Output 1/4 inch, 6.3mm – jacks.

Backpanel of the case with some features for aircondition. The white and black stripes at the corner are “inside” and are used to fix the screws from the side.

Wiring of the PCM-, LCD- and MIDI-Board with the Raspberry-Pi-GPIOs

The wiring through the Audio-Jacks is made with plastic jacks which connect the tip- and ring-contact to an outpoing pin if no plug is inserted in the jacks. That way, the upper jack is stereo if nothing is connected to the right-side-jack. The right-side-jack is a mono-jack, the left-side-jack is a stereo jack.

The MIDI-Circuit was tested with an LED, because I had to order the 6N138 and wanted to avoid any mistake.

Test MIDI-Circuit with LED first

Finally after testing, I was able to connect all cables.
Powersupply, Audio, MIDI-Keyboard, USB-Stick with samples, USB-Keyboard,

How does it sound? – exactly as the samples are. On the USB-Stick, for every instrument or “patch”, you need a folder which starts with a number.
Inside each folder, you have to store all needed samples for the patch and a definition.txt which declares the structure, placing of the samples etc.

The wave-files could contain Loop-Points to be able to play an area of the sample in a loop as long as you presses the key on the keyboard.
For short samples – or most string- or drum-instruments, it sounds more realistic to use a long sounding sample which simple fades out. After releasing the key, samplerbox will release these samples in a few milliseconds which mostly sounds natural.

The content of a definition.txt looks a bit like “code” but is very “simple” to declare for “simple” instruments. Lets view the “code”.
To avaid load distorsion, I lower the gain for this instrument to 80% – 0.8.
%%velmode=accurate is more or less a standard which has to be defined.
The last line of my definition is something like a Regular Expression but much more easier. * covers all content in flexible length. %notename has to be something like C4, c4 or c#4 or C#4 but NOT Gb3 or G.
By default, the notation could be used as the notenames but only normal notes or sharp notes. As an alternative, “%notenumber” could be used which is simply the MIDI-Notenumber, C4=60. %velocity could be used to provide a %velocity-Number to define WAV-Files when keys are hitted faster/stronger for loader notes and other WAV-Files for quite notes.
There are a lot more options available for the definition.txt which are described well in the internet.

%%gain=0.8
%%velmode=accurate
* %notename %velocity.wav

The definitions are made mostly for key-ranges without a specified border of the range. If you would like to define something for a specific key, that could be done with specific variables in the code:
kick.wav, %midinote=36

The Options per Sound are:
%notename
%midinote
%velocity

More Details are documented here, but this documents don´t cover the version from HANS by 100%!!
samplerbox.readthedocs.io/en/latest/Sample_Sets/

The Software-Image from Hans covers special files on the SD-Card! – /boot/config.txt and /boot/samplerbox/configuration.txt and some more…
These files provide the ability to define the used GPIO-Ports and are used to enabled the Serial-MIDI-Port. ( BT would be moved to miniuart to make the real UART available for the MIDI-Port via midi-uart0)
(The configuration-files are readable on the SD-Card on MAC and probably windows.)

Raspi3+ in config.txt I changed this:

enable_uart=1
dtoverlay=pi3-miniuart-bt
dtoverlay=midi-uart0

and removed from config.txt
init_uart_clock=2441406,
init_uart_baud=38400 in config.txt and

and remove this in cmdline.txt
bcm2708.uart_clock=3000000

MIDI-Controllers could be used to control all the effects or the select the patches. I am using an older Novation Launchkey MINI MK2 which does not provide Program-Change command. Therefore, I used the Controller-Configuration from HANS to remap 2 buttons on the launchkey to do so and a POT on the Launchkey to control the volume. All Configuration-Files are described here: http://homspace.xs4all.nl/homspace/samplerbox/SBconfig.html

What could You do better than I did?
– Try to push all connections to only 2 sides of the case. I have created connections on the left side for audio and MIDI and the Power-Plug is on the right side and USB-Ports on the top . That way, the Samplerbox takes too much place on my desk.
– create a stiffer case and a bigger circuit-board for the MIDI-Port. A MIDI-Port, shaking loosely inside the case wouldn´t be “pro”,
– Try to use the OLED-SPI-Display-Option, – my 16×2 LCD does not work well and shows agyptian characters when the Raspberry Pi is cold. My LCD is specified for 5 Volts but the data-pins of the Raspi provide 3.3Volts, this could be the problem. – but sometimes it works!?
– Don´t use litz-wires for the connection between the circuits. I had to rethink and rebuild the circuits and the case and had many issues with wires which created shorts or were simply disconnected.
– Test Your setup on a breadboard first
– Connect the LCD only with Data-Pins Data4-Data7, – the 8Bit-Mode is not supported by the version from HANS.

What I would do with the samplerbox?
I already own a Akai MPC2500, – which plays drumsounds well but not keyboard-sounds mapped to a keyboard. I own a Novation-Circuit too which has limited polyphony and I am thinking about to create 2 small samplerboxes to extend the MPC and the Circuit.
I already sampled a few instruments by using the MPC 2.0 Software (version 2.6 with the autosampler) and created samples of my mandolins and mandola by using garageband as the “recorder”.
I would like to use the Samplerbox as a small expander with Samples which I recorded or to provide drum-loops.
A further step would be a Arduino as a MIDI-Merger and Sequencer between the MIDI-Board and the Samplerbox. A Arduino-Nano or ESP32 could do that perhaps.

Things, which are not that good:
The documentation is not covering all different versions of Samplerbox. The Effectsettings are global and are not saved in the definition.txt for a single patch. But to be fair, all these effects are a great step forward for samplerbox.
The forum(s) is not splittet into different subjects. Most forum-posts are asking for help or saying that the sound is crappy – they only need the hint to lower the gain in definition.txt. That way, samplerbox-users are not in a real discussion in the forum.

PHP mit Curl Export File

Es gibt manchmal das Problem, dass keine direkte Verarbeitung, sondern ein Loggen des Ergebnis von CURL gewünscht ist. Dazu muss man nicht erst eine Verarbeitung des Returnvalues durch PHP starten.

Ausschnitt aus PHP:

$ch = curl_init();
curl_setopt($ch, CURLOPT_FILE, $out);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_URL, $file);

Samplerbox basierend auf Raspberry PI – 2020 lohnt sich das noch?

Samplerbox hatte ich schon mit dem Raspberry-PI, gefühlt 2010 getestet. Es war sicher 2 oder 3 Jahre später aber der Sampleplayer basierend auf Raspberry 2 lief eher mit Fehlern und die Klangqualität ware eher sehr bescheiden.

Samplerbox ist eine Software – oder besser schon “Betriebssystem”, das man als Boot-Image auf eine SD-Karte kopiert und dann diese in den Raspberry-Pi steckt.
In die USB-Ports des Raspberry-PI steckt man noch ein USB-MIDI-Keyboard, eine USB-Soundcard und einen USB-Stick mit Sounds. Nach dem Booten kann man dann die Sounds, die auf dem USB-Stick gespeichert sind auf dem MIDI-KEyboard abspielen.

Technisch war Samplerbox als einfacher mobiler Keyboard-Expander angesetzt. Dank gut gesampelter Piano-Sounds scheint das Projekt aber nun eher bei Usern zum Upgrade von Homepianos eingesetzt zu werden.

Im Vergleich zu einem vollwertigen Sampler, – so wie es sie früher in den 90ern mal gab, fehlen der Samplerbox viele Funktionen:

  • Samplen kann man damit nicht, nur Sounds wiedergeben
  • Es gibt keine ADSR-Hüllkurve, sondern nur eine Releasetime
  • 16Bit, und somit kann es bei vollem “Gain” zu Verzerrungen kommen
  • Kein integrierter Sample-Editor

Auf der Plusseite haben wir aber 2020 mit der Version von Hans ( http://homspace.xs4all.nl/homspace/samplerbox/SBbuild.html ) nun eine stabile Version, die auch schon eine größere Liste von Effekten kennt: Lowpass, Freeverb, Delay, WahWah.
Die Version von Hans läuft auch nach Stunden und wildem Wechsel des USB-Sticks noch stabil!

Die Version von Hans unterstützt auch ein einfaches optionales GUI, mit 2 Buttons, einem Display (16x2LCD oder SPI-OLED), DIN-Midi und 2 LEDs.

Ich habe mir eine einfache PCM5180-Platine bei Amazon bestellt und diese als Hifiberry-Soundcard installiert, ein LCD-Display und 2 Buttons verbaut. Da ich noch keinen 3D-Drucker habe, habe ich ein Gehäuse aus Guttagliss PHoobycolor – Platten gebaut. .. das ging auch in wenigen Minuten.

Anders als angegeben müssen nur die Datenleitungen D4 bis D7 des LCDs mit GPIO-Pins verbunden werden. Die final ausgewählte Belegung wird in einer Configdatei (configuration.txt) auf der SD-Card definiert. Somit können auch vorhandene LCDs und Hifiberry weiter verwendet werden.

Sounds habe ich mit der Akai MPC erstellt und dann auf den USB-Stick rüber kopiert und somit stehen diese nun mit einer Polyphonie von 80 Sounds zur Verfügung.

Spaß machen die A-Piano und E-Piano-Sounds, bei denen man keine besonderen ADSR-Hüllkurven erwartet. Synth-Sounds klingen sehr statisch, denn hier erwartet man eben Sounds, die genau nochmal eine Veränderung zeigen, wenn man länger drückt, fester drückt (Aftertouch) oder los lässt.

Für alle, die einen einfachen MIDI-Expander, – Sampleplayer für Keyboard-Sounds, Drum-Sounds oder Loops suchen und schon einen Raspberry-Pi ab Modell 3 haben, sollten Samplerbox nochmal testen.

Ich werde meinen Raspberry PI noch mit einem DIN-MIDI-Port ausstatten und einen Arduino als Sequencer hinzufügen und zu meinem kleinen Volca-Beat synchronisieren.

Links:

http://homspace.xs4all.nl/homspace/samplerbox/SBbuild.html

Script to sample down the sounds of a SF2-File
https://github.com/adrianhoehne/Sf2_Batch_Recording/blob/master/Sf2_Batch_Recording

Trick zur Sample-Convertierung:
Unter MacOSX gibt e snatürlich viele Tools um vorhandene Sounds in einem Verzeichnis auf die richtige Sample-Frequenz und die richtige Bitgröße zu bringen. Mit dem Tool “SOX” geht das auch in der CLI/Bash:
for file in *.wav; do ./sox “$file” -r 44100 -b 16 44100/”$file” -V; done

Erweiterung zum Samplen gibt es lieder noch nicht fertig. Aber es gibt ein Script, welches die Basics zum Samplen abdeckt: https://www.samplerbox.org/forum/444

import RPi.GPIO as gpio 
from recorder import Recorder 
gpio.setmode(gpio.BCM)  

class ButtonRecorder(object): 
    def __init__(self, filename): 
        self.filename = filename 
        gpio.setup(23, gpio.IN, pull_up_down=gpio.PUD_UP) 
        self.rec = Recorder(channels=2) 

    def start(self): 
        gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10) 

    def rising(self, channel): 
        gpio.remove_event_detect(23) 
        print 'Button up' 
        gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10) 
        self.recfile.stop_recording() 
        self.recfile.close() 

    def falling(self, channel): 
        gpio.remove_event_detect(23) 
        print 'Button down' 
        gpio.add_event_detect(23, gpio.RISING, callback=self.rising, bouncetime=10) 
        self.recfile = self.rec.open(self.filename, 'wb')    
        self.recfile.start_recording() 

rec = ButtonRecorder('36.wav')
rec.start() 

try: 
    raw_input() 

except KeyboardInterrupt: 
    pass 

gpio.cleanup()

Akai MPC2500 – April 2018

nun habe ich mir eine AKAI MPC2500 über ebay gekauft. Sicher wird es weiterhin Musik mit der Mandoline geben, – aber ich habe immer etwas mit Elektronik und Musik gemacht.
Die MPC2500 ist ein “Midi Production Center”, also eine Steuerzentrale zum “Musikmachen”, – aber ohne Computer.

Die MPC2500 war ca.2005 ein Nachfolger der MPC60 oder MPC3000.
Der Brand “Akai” gehört heute zu einer anderen Firma und ab der “MPC5000” steckt sogar Hardware eines anderen Herstellers drin.

Hier gibt es eine sehr schöne Einführung in das Thema “Akai MPC”
https://www.youtube.com/watch?v=SENzTt3ftiU

Wer Interesse hat, kann sich mal nach “J Dilla Instrumental” umsehen und in das Instrument reinhören.
Hier ein Beispiel:
https://www.youtube.com/watch?v=SENzTt3ftiU

Was ist MIDI?, – es sind einfache Steuerinformationen zwischen Musikinstrumenten, wie “Start des Songs”, “Taste A1 auf dem Keyboard gedrückt” oder “Taste A1 losgelassen” – aber eigentlich keine Känge. Diese werden von einem MIDI-Expander erzeugt oder Sampler wiedergegeben… getriggert durch MIDI-Befehle. Wenn man nun viele Musikinstrumente steuern will, dann werden das eben viele MIDI-Nachrichten, die zum richtigen Zeitpunkt ausgegeben werden sollen und von den Geräten in Töne umgesetzt werden sollen.
Vergleichen kann man das auch gut mit diesen Papierrollen mit Löchern zur Steuerung von Glockenspielen(“Musicbox”) oder automatischen Pianos.

Leider war/ist MIDI so ca. 1986 etwas schlecht implementiert worden und manchmal eiern die Spuren eher als “tight” zu bleiben. Das liegt daran, dass die MIDI-Befehle oft nicht zeitnah übertragen werden können, – das “leckt” dann eben manchmal wenn zu viele Noten über die gleiche Leitung müssen.
Die MPC2500 hat daher 4 MIDI-Ausgänge, theoretisch wären das bis zu 64 unabhängige Musikinstrumente. Praktisch geht es aber darum, dass beim parallelen Verschicken der Nachrichten die Töne präziser verschickt und abgespielt werden können.

Im Gegensatz zur reinen Musikaufnahme mit Mehrspur-Tonbandgerät kann man MIDI-Nachrichten nachträglich veränderen, – Tonhöhe, Start- und Endzeitpunkt oder Anschlaglautstärke und sogar einen anderen Sound wählen.

Technisch handelt es sich bei MIDI-Nachrichten ja nur um eine Abfolge oder Sequenz von Steuerinformationen. Die MIDI-Tools nennt man daher auch “Sequencer”.

Falls man sich fragt, warum man dazu eine “MPC” und keinen Computer nimmt? – Das ist eine eher philosophische Frage. Klar kann man heute auch einen Computer als Steuerzentrale des Musikstudios verwenden, z.B. einen MAC oder Windows-PC mit Sequencer wie Logic Pro, Cubase oder “Fruity Loops” (FL) oder Linux mit LMMS etc.
Wenn man einen Computer einsetzt, dann besteht aber immer die Gefahr, dass man dann eher wieder im Internet Surft und Emails/Facebook-Nachrichten schreibt.

Was war/ist ein Sampler?
Ein Gerät, welches Töne aufnimmt, digital speichert und wiedergeben kann. .. oder eben diese berühmten WAV-Dateien wiedergeben kann. Der Sampler kann meist über eine Tastatur, Drumpads oder eben über MIDI gesteuert werden. Heutige Studiosampler sind meist nur noch Software in einem MAC oder Windows-PC.

Die alte MPC “kann kein Internet” und war eine Kombination aus Sequencer, Drumcomputer und Sampler, … alles in einer Box.

Früher (so 1995) hatte ich einen Atari Falcon, – ohne Internet, nur zum Musikmachen. Der funktionierte tadellos. Der Umstieg auf das gleiche Programm auf einem 486er funktionierte nicht, denn die gleiche Musik-Software ist dort immer wieder abgestürzt. .. der Atari lief mit 16Mhz, und der 486er mit 133MHz und dennoch “Sch…e” und viel hat sich da bei Windows nicht geändert. Da habe ich dann irgendwann mit Musik am Computer aufgehört.

Ntürlich verwende ich auch schonmal meinen Mac mit Garageband zum “Computer-Musikmachen”, das funktioniert auch ganz gut, kann aber kein MIDI-Equipment ansteuern.

Hier noch ein Bild der MPC nach der Grundreinigung.

AKAI MPC2500

AKAI MPC2500

Elektor – ESP32-PICO-D4 Developmentboard

Ein normales ESP32-Devboard ist leider so breit, so dass auf einem Breadboard eine Pinseite nicht verwendet werden kann. Man braucht dann immer 2 Boards oder ein breiteres Board um überhaupt Experimente mit dem ESP32 machen zu können.

Genau hier ist diese Board das richtige. Im Rahmen des ESP32-Contest konnte man ein kostenloses Board erhalten.
Wie man erkennen kann, sind auf meinem Breadboard auf jeder Seite je 2 Pins frei.

Somit eignet sich dieses Board viel besser für Experimente als die anderen ESP32-Boards.
Dank der eingebauten Funktionen und der breiten Verfügbarkeit von Boards ist dieses Board ein weiterer Schritt zur Ablösung der ersten Arduino-Boards. Bei dem Preis darf bei einem Experiment auf mal etwas “abrauchen”.

ESP32_Devboard_PICO

 

 

 

 

 

 

 

Mein gemeldetes Projekt ist die digitale Stompbox bzw. der Sampleplayer basierend auf dem ESP32.

Weitere Details zum Design-Contest:

https://www.espressif.com/en/media_overview/news/esp32-pico-kit-design-contest-elektor-and-espressif

.. Kommentare zu den Transistoren auf dem Bild kann man sich sparen, die waren hier nur “geparkt”.

ESP32 Stomper – mehr als SPD:Kick oder Horsekick

Ich hatte mir eigentlich nur einen Stomper mit einem ESP8266 bauen wollen. Den Gitarristen im Freundeskreis gefiel der Stomper auch, wenngleich einige Kommentare zu Latenz und Soundauswahl vielen. .. ok, nochmal Anforderungen sammeln.

Es gab viel Diskussion und neue Wünsche …

(more…)

ESP8266 Stompbox ( Horsekick oder Finhol oder SPD::KICK ) Nachbau

Als Gitarrist und Elektroniker will man doch mal den Beat mittrampeln. Also hatte ich mir schon einige Projekte im Web angeschaut und dann Ende Oktober eine Audio-Library zum ESP8266 gefunden. Alternativen nur mit einem Piezo oder MIkrofon in einer Pappschachtel sollen auch funktionieren, – gefielen mir aber nicht.
Ein ESP8266-Development-Board gibt es für unter 10 €, der Adafruit DAC mit 3 Watt Amp hatte ich schon gekauft, – liegt auch bei 10 €.
Das OLED-Display, weitere Kleinteile wie Piezo, Taster und ein paar kleine Bauteile machen nochmal 15€. Das Holzgehäuse  bauen, bearbeiten und die Auswahl der Sounds dauert auch  länger. Als Powersupply dient eine ältere USB-Powerbank.
Wenn man alle Teile extra kaufen muss, dann rechnet sich das Projekt auf Grund von den Kosten und dem Aufwand aus meiner Sicht nicht. Ich hatte aber alle Teile herumliegen und wollte es einfach mal ausprobieren.

So sah die erste Version aus, die dann aber später in 2 Teile durchgetrennt wurde. Somit konnten dann die Bewegungen der Ferse und somit die Geräusche und Fehltrigger minimiert werden.
Die Basis bildet ein 3-Schicht Holz ca. 28 x 14cm. Unter der Unterlegscheibe befindet sich ein Hohlraum für den ESP8266 und den Piezo. Das OLED-Display ist leicht versetzt eingebaut. Rechts bzw. hier dann oben befindet sich in einer Einbuchtung ein Taster zur Soundwahl und links in der gegenüberliegenden Einbuchtung die Klinkenbuchse.

Hman-Stompbox

Halbfertige Alternativen zum ESP8266 könnten auch Raspi-Projekte wie Samplerbox oder fertige Platinen wie Wavetrigger von Robertronics sein. Beide bieten aber keinen Anschluss eines Piezos!
Raspi-Projekte könnten final noch teurer werden, denn der Zeitaufwand zur Einrichtung von Linux könnte größer ausfallen.

Als fertige Lösung gefiel mir das Ortega Horsekick Pro  ca. 170€ und vom Datenblatt und den Sounds her das Roland Boss SDP::Kick oder SDP::Wave für über 200€.

Zurück zum “selbermachen”.

Zur Ausgabe der Sounds verwende ich die fertige Audio-Library von Earle F. Philhower, III
https://github.com/earlephilhower/ESP8266Audio

Das ZIP muss entpackt werden und dann nach /Arduino/libraries/ verschoben werden.

Die Anschaltung des DACs and den ESP8266 erfolgte wie in https://github.com/bbx10/SFX-web-trigger. Der DAC ist das “Adafruit I2S 3W Class D Amplifier Breakout – MAX98357A”.

Der Lautsprecher-Ausgang des DAC geht bei mir auf die beiden äußeren Enden eines 50kOhm-Trimmer, an dem dann der Mittelpin eines 6.3mm Klinkenbuchse über einen weiteren Widerstand hängt. Die Masse der Buchse ist auf einen “Aussenpin” des Trimmers gelegt. Nachträglich habe ich zwischen den Mittelabgriff des Trimmer und “+” der Klinkenbuchse noch einen Widerstand eingebaut … ca. 10kOhm und einen Kondensator zur Entkopplung von Gleichspannungen, – also in Reihe mit dem Widerstand.

Nach dem Zusammenbau von DAC, ESP8266, einigen Kondensatoren zur Spannungsstabilisierung und dem PIEZO fehlte nur noch die Abstimmung der Empfindlichkeit, denn der Beat soll sowohl mit sehr festen Fußwerk als auch Sportschuhen oder auch ohne Schuhe nur mit Socken funktionieren.

Nach zwei frustrierenden Abenden mit Tests verschiedener Einstellungen hatte ich dann ein einfaches Testscript gefunden und dieses funktionierte auf Anhieb ausreichend gut. Es  bildet nun die Grundlage für das eigene Stompbox-Script. Statt einen MIDI-Sound zu triggern, wird ein Sample aus dem “ProgMem” des ESP8266 ausgegeben.

Vorlage für das Testscript:

https://github.com/RyoKosaka/drums/blob/master/arduino/piezo_peak_test_MIDI/piezo_peak_test_MIDI.ino

Die Samples, die im “ProgMem” abgelegt werden, sollten unterschiedlich sein, so dass ich bei den nächsten Sessions die besten Sounds auswählen und die “schlechten” gegen andere tauschen kann.
Also habe ich in meiner Sample-Sammlung und Synths nach Percussion und Kickdrum-Samples gesucht. Diese gekürzt, auf Mono und 16 Bit gesetzt, – 44.1kHz.

Earle Philhower erklärt ausreichend gut, wie man die 16Bit-Wav-Files einfach in HEX-Files konvertrieren kann, um sie in seinen Libraries als “Audio-Source-ProgMem” zu verwenden. Ich hatte dazu aber eine eigene Javascript-Webpage gebaut, die mir die Sounds in h-Files convertiert. Die WAV-Files müssen als HEX-Files vorliegen.
Die Sound-hex-Files sehen dann etwas so aus:

const unsigned char cajonbass[] PROGMEM = {0x52,0x49,0x46,0x46,0x1a,0x6c,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6d,0x74,0x20
,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x44,0xac,0x00,0x00,0x88,0x58,0x01,0x00....
};

Ein OLED128x64Pixel (grüne Fahne) (von Amazon) wurde an den ESP8266-Pins “D1” / “D2” angeschaltet., an “D3” liegt ein Taster, wenn er geschlossen ist, zieht er den Pin D3 dann gegen Masse um die Sounds zu wechseln.

Final passen 1 MByte in das System. Ich konnte damit ca. 20 sehr kurze Sounds laden.

Die Library für das OLED-Display:
https://github.com/squix78/esp8266-oled-ssd1306
Diese wird aber innerhalb der Arduino IDE zur Installation angeboten und nennt sich dort:
“ESP8266 and ESP32 OLED Driver for SSD1306 Display by Daniel Eichhorn, Fabrive Weinberg..:”

Urspünglich war statt des Tasters ein Rotary Encoder und ein kompelexeres Menü geplant. Auch die Darstellung von kleinen Icons zu den Instrumenten habe ich wieder verworfen, denn diese verbrauchten auch zusätzlichen RAM.

Eine Idee wäre die Auslagerung der Samples in externen Storage.
Die Umwandlung der Samples in andere komprimierte Formate würden zusätzliche Zeit zur Dekodierung und somit zu Latenzen beim Triggern führen.

Das Holzgehäuse besteht nun aus 2 Teilen, einem Teil mit der Elektronik und dem Piezo und einem Stück Holz. Beide Teile sind miteinander über Gummistücke verbunden und ergeben die Auflagefläche für einen Fuß. Der passive Teil liegt unter der Ferse und der aktive Teil mit dem Piezo kann sicher mit dem Fuß getrigggert werden.

Unten drunter gibt es jeweils Gummifüße gegen das Verrutschen. (Bilder folgen)
In einer ersten Version hatte ich nur eine große Holzplatte  eingeplant, musste diese Version aber verwerfen, denn schon die Bewegung des Fußes auf der Platte sorgte für Fehltrigger oder Doppeltrigger beim Runtertreten und beim Abheben des Fußes.

Technisch machen es sich die Hersteller einfach und liefern nur das aktive Teil, auf das man treten soll. Ergonomisch ist das aber nicht, denn man muss zum niedertreten den Fuß weit anheben.

Hier das vorläufige Arduino-Script:

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include "AudioFileSourcePROGMEM.h"
#include "AudioGeneratorWAV.h"
#include "AudioOutputI2SDAC.h"

#include <Wire.h>  
#include "SSD1306.h"

// WAV-Files
// WAV-Files, MONO 44.1 KBIT/s 16Bit
#include "fatbass.h"
#include "softkick.h"
#include "espkik03.h"
// #include "espkik04.h"
#include "cajonbass.h"
#include "espkik06.h"
#include "espkik07.h"
#include "espkik08.h"
#include "espkik09.h"
#include "espkik10.h"
#include "espkik11.h"
#include "espkik12.h"
#include "espkik13.h"
#include "espkik14.h"
#include "espkik15.h"
// #include "espkik16.h"
#include "espkik17.h"
#include "espkik18.h"
#include "espkik19.h"
#include "espkik20.h" 
#include "espkik22.h"
#include "ride1.h"
// #include "espkik28.h"

AudioGeneratorWAV *wav;
AudioFileSourcePROGMEM *file;
AudioOutputI2SDAC *out;

unsigned short buttonState = 0; // Selectbutton for the sounds
unsigned short oldButtonState = 1;
boolean piezo = false;
int maxPiezo = 400;
int gaindevider = 380;

unsigned short s = 0;
unsigned short s_old = 20; // Sample-ID


const char *samplenames1[] ={"0 Fat",
     " 1 Soft    " , " 2 Cajon  "
   , " 3 Rock   " , " 4 Ride  "
   , " 5 Cajon  " , " 6 Arabic"
   , " 7 Acoust " , " 8 Acoust"
   , " 9 R908   " , "10 R809  "
   
   , "11 Tambo- ", "12 Christ."
   , "13 Cabasa ", "14 Guiro  "
   , "15 Rattle ", "16 Rattle",
   , "16 Cow    ", "17 Claves "
   , "18 Clap   ", "19 Side   "
   , "20 Hihat  ", "21 Ride   "
   
  };

const char *samplenames2[] ={"Drum",
     "    Kick",  "    Bass"
   , "    Kick",  "    Cymbal"
   , "    Bass",  "    Bass"
   , "    Stomp", "    Stomp"
   , "    Synth", "    Synth"
   , "    Latin",  "    Latin"
   , "rine Man",  "    Bells"
   , "    Latin", "    Latin" 

   , "    Bell",  "         "
   , "    Clap",  "    Stick"
   , "   Closed","    Cymbal"

  };  


unsigned short samplecount = 21; // Anzahl der Samples für den Select-Button
SSD1306  display(0x3c, 5, 4); //Labeled D1, D2
const int buttonPin = 0; // Labeled D3, Pin is high by default, button between this pin and GND to switch the sounds


void setup() {
  WiFi.forceSleepBegin();
  display.init();
  // display.flipScreenVertically();
  display.setContrast(255);

  display.setTextAlignment(TEXT_ALIGN_LEFT);
  display.setFont(ArialMT_Plain_24);
  display.drawStringMaxWidth(0 , 0 , 128, " Heinemann");
  display.drawStringMaxWidth(0 , 24 , 128,"  Stomper");
  // display.drawXbm(20, 30, bassdrum_width, bassdrum_height, bassdrum_bits);
  display.display();

  
  // pinMode(BUILTIN_LED, OUTPUT);
  Serial.begin(115200);
  delay(3000);
  
  file = new AudioFileSourcePROGMEM( fatbass, sizeof(fatbass) ); // Short Demosound after Booting
  out = new AudioOutputI2SDAC();
  out->SetGain(0.02);
  wav = new AudioGeneratorWAV();
  wav->begin(file, out);
  
  pinMode( buttonPin, INPUT); // GPIO 0 == D03 on ESP8266 !!

}


void loop() {
  
  if ( s != s_old ) {
    if (s >= samplecount) {
      s=1;
    }
    s_old = s;
    display.clear();
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.setFont(ArialMT_Plain_24);
    display.drawStringMaxWidth(0 , 0 , 128, samplenames1[s]);
    display.drawStringMaxWidth(0 , 24 , 128, samplenames2[s] ); // + (String) s);
    display.display();
  } 
  
  int sensorValue = analogRead(A0);
  int MAX;

  if (sensorValue > 20 &&  piezo == false) {
    int peak1 = analogRead(A0);
    MAX = peak1;
    delay(1);
    int peak2 = analogRead(A0);
    if (peak2 > MAX) {
      MAX = peak2;
    }
    // delay(1); // absichtlich deaktiviert!!
    int peak3 = analogRead(A0);
    if (peak3 > MAX) {
      MAX = peak3;
    }
    delay(1);
    int peak4 = analogRead(A0);
    if (peak4 > MAX) {
      MAX = peak4;
    }
   
    delay(1);
    int peak5 = analogRead(A0);
    if (peak5 > MAX) {
      MAX = peak5;
    }
    // delay(1); // absichtlich deaktiviert !!
    int peak6 = analogRead(A0);
    if (peak6 > MAX) {
      MAX = peak6;
    }
    if(MAX >= maxPiezo){
      MAX = maxPiezo;
    }

//     MAX = map(MAX, 10, maxPiezo, 1, 127); // entfaellt bei mir

    if(MAX <= 1){
      MAX = 1;
    }

    midiNoteOn( MAX );
    Serial.println( MAX);
    piezo = true;

    // teh next block could be replaced by delay(30); or anything similar...
    delay(1); //mask time
    Serial.println( 0);
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
    Serial.println( 0 );
    delay(1); //mask time
  }
  if (sensorValue <= 0 && piezo == true) {
    piezo = false;
  }

  
  buttonState = digitalRead(buttonPin);
  if ( buttonState == LOW &&  oldButtonState == HIGH ) {
    oldButtonState = buttonState;  
    s = s +1;    
    oldButtonState = buttonState;  
    delay(50); // debounce
  } else {
    oldButtonState = buttonState;  
  }

  if (wav->isRunning()) {
    if (!wav->loop()) { 
      wav->stop(); // wenn nicht mehr richtig looped dann stoppen
    }
  }  
}

void midiNoteOn( int midiVelocity){
  if (midiVelocity > 0) {
  switch (s) {
      case 0:
        file = new AudioFileSourcePROGMEM( fatbass, sizeof(fatbass) ); 
        break;
      case 1:
        file = new AudioFileSourcePROGMEM( softkick, sizeof(softkick) );
        break;
      case 2:
        file = new AudioFileSourcePROGMEM( softkick, sizeof(softkick) );
        break;
      case 3:
        file = new AudioFileSourcePROGMEM( espkik03, sizeof(espkik03) );
        break;

       case 4:
         file = new AudioFileSourcePROGMEM( ride1, sizeof(ride1) );
         break;
      case 5:
        file = new AudioFileSourcePROGMEM( cajonbass, sizeof(cajonbass) );
        break;
      case 6:
        file = new AudioFileSourcePROGMEM( espkik06, sizeof(espkik06) );
        break;

      case 7:
        file = new AudioFileSourcePROGMEM( espkik07, sizeof(espkik07) );
        break;
      case 8:
        file = new AudioFileSourcePROGMEM( espkik08, sizeof(espkik08) );
        break;
      case 9:
        file = new AudioFileSourcePROGMEM( espkik09, sizeof(espkik09) );
        break;
      case 10:
        file = new AudioFileSourcePROGMEM( espkik10, sizeof(espkik10) );
        break;
      case 11:
        file = new AudioFileSourcePROGMEM( espkik11, sizeof(espkik11) );
        break;
      case 12:
        file = new AudioFileSourcePROGMEM( espkik12, sizeof(espkik12) );
        break;
      case 13:
        file = new AudioFileSourcePROGMEM( espkik13, sizeof(espkik13) );
        break;
      case 14:
        file = new AudioFileSourcePROGMEM( espkik14, sizeof(espkik14) );
        break;
      case 15:
        file = new AudioFileSourcePROGMEM( espkik15, sizeof(espkik15) );
        break;
     case 16: // the same as 15
        file = new AudioFileSourcePROGMEM( espkik15, sizeof(espkik15) );
        break;

       case 17:
        file = new AudioFileSourcePROGMEM( espkik17, sizeof(espkik17) );
        break;
      case 18:
        file = new AudioFileSourcePROGMEM( espkik18, sizeof(espkik18) );
        break;
      case 19:
        file = new AudioFileSourcePROGMEM( espkik19, sizeof(espkik19) );
        break;
      case 20:
        file = new AudioFileSourcePROGMEM( espkik20, sizeof(espkik20) );
        break;
      case 21:
        file = new AudioFileSourcePROGMEM( espkik22, sizeof(espkik22) );
        break;

      default:
        file = new AudioFileSourcePROGMEM( fatbass, sizeof(fatbass) ); 
        s = 1;  
      }
        
    // file = new AudioFileSourcePROGMEM(  );
    // out = new AudioOutputI2SDAC();

    // eigentlich p statt oldPiezoVal
    out->SetGain( 0.05 +  (float) midiVelocity/gaindevider ); // 0.8(float) p/130
    
    if (wav->isRunning()) {
      wav->stop(); // wenn nicht mehr richtig looped dann stoppen
    }
    wav->begin(file, out);
  }
}

Die lange Kette von Seriel.println ist ganz praktisch um die Ausgabe per Serial-Plotter zu ermöglichen. Die Sounds hatte ich Anfangs nur durchnumeriert, werde das aber ändern und sprechende Namen verwenden.

Die hex-files liegen im Ardino-Projektordner und nicht in Unterverzeichnissen. Man muss hier auch keinen Tricks zum Upload der Files anwenden.

Mit der Fuktion “out->SetGain und der Variablen “gaindevider” kann man experimentieren und somit die “Velocity” oder Anschlagempfindlichkeit verändern.

Bootstrap 4 … still alpha

Nach einigen Jahren in denen ich Bootstrap 3.0 verwende, muss ich mich langsam mal an Bootrap 4.0 gewöhnen. Es ist immer noch alpha und die von mir bisher verwendeten Plugins in Bootstrap 3.0 wie Boostrap-Table muss ich erstmal mit Bootstrap 4.0 testen.

Einige Bereiche wurden in Bootstrap 4.0 geändert und so werde ich z.B. meine entwickelten Applikationen mit “wells” umändern, so dass sie mit “cards” funktionieren.

Hier gibt es eine schöne Webseite, die die Unterschiede schnell aufzeigt:

http://bootstrap4.guide/

Dashboards mit Gridstack

Gridsatck liefert eine einfache Funktion um mit Bootstrap auch Dashboards oder ein Grid von Widgets zu gestalten.

Gridstack finde ich persönlcih sehr praktisch, denn es gibt nicht zu viele Funktionen vor, sprich, man kann sehr viel selbst implementieren ohne schon ein großes Admin-Template oder sonstige visuelle Dinge berücksichtigen zu müssen.

Hier ein einfaches Beispiel, welches zu 95% dem Original entspricht und ich nur die Referenzierung der DIVs durch IDs in Javascript hinzugefügt habe. Somit ließe sich über die Serialisierung als JSON-String das Grid sichern und laden und je nach Widget-ID oder DIV-ID wird der passende Content asynchron geladen.

Beipiel unter: http://hman-projects.de/extraSite/fake/gridstack_serialization.html

Neue Demo mit kleinem DropDown-Menü vom 23.07.2017

http://hman-projects.de/extraSite/gridstack/demo/

Hier die offzielle Gridstack-Seite:

https://troolee.github.io/gridstack.js/

 

 

1 2 3 4