Git Product home page Git Product logo

performer's Introduction

Build Status

PER|FORMER

Overview

This repository contains the firmware for the PER|FORMER eurorack sequencer.

For more information on the project go here.

The hardware design files are hosted in a separate repository here.

Development

If you want to do development on the firmware, the following is a quick guide on how to setup the development environment to get you going.

Setup on macOS and Linux

First you have to clone this repository (make sure to add the --recursive option to also clone all the submodules):

git clone --recursive https://github.com/westlicht/performer.git

After cloning, enter the performer directory:

cd performer

Make sure you have a recent version of CMake installed. If you are on Linux, you might also want to install a few other packages. For Debian based systems, use:

sudo apt-get install libtool autoconf cmake libusb-1.0.0-dev libftdi-dev pkg-config

To compile for the hardware and allow flashing firmware you have to install the ARM toolchain and build OpenOCD:

make tools_install

Next, you have to setup the build directories:

make setup_stm32

If you also want to compile/run the simulator use:

make setup_sim

The simulator is great when developing new features. It allows for a faster development cycle and a better debugging experience.

Setup on Windows

Currently, there is no native support for compiling the firmware on Windows. As a workaround, there is a Vagrantfile to allow setting up a Vagrant virtual machine running Linux for compiling the application.

First you have to clone this repository (make sure to add the --recursive option to also clone all the submodules):

git clone --recursive https://github.com/westlicht/performer.git

Next, go to https://www.vagrantup.com/downloads.html and download the latest Vagrant release. Once installed, use the following to setup the Vagrant machine:

cd performer
vagrant up

This will take a while. When finished, you have a virtual machine ready to go. To open a shell, use the following:

vagrant ssh

When logged in, you can follow the development instructions below, everything is now just the same as with a native development environment on macOS or Linux. The only difference is that while you have access to all the source code on your local machine, you use the virtual machine for compiling the source.

To stop the virtual machine, log out of the shell and use:

vagrant halt

You can also remove the virtual machine using:

vagrant destroy

Build directories

After successfully setting up the development environment you should now have a list of build directories found under build/[stm32|sim]/[release|debug]. The release targets are used for compiling releases (more code optimization, smaller binaries) whereas the debug targets are used for compiling debug releases (less code optimization, larger binaries, better debugging support).

Developing for the hardware

You will typically use the release target when building for the hardware. So you first have to enter the release build directory:

cd build/stm32/release

To compile everything, simply use:

make -j

Using the -j option is generally a good idea as it enables parallel building for faster build times.

To compile individual applications, use the following make targets:

  • make -j sequencer - Main sequencer application
  • make -j sequencer_standalone - Main sequencer application running without bootloader
  • make -j bootloader - Bootloader
  • make -j tester - Hardware tester application
  • make -j tester_standalone - Hardware tester application running without bootloader

Building a target generates a list of files. For example, after building the sequencer application you should find the following files in the src/apps/sequencer directory relative to the build directory:

  • sequencer - ELF binary (containing debug symbols)
  • sequencer.bin - Raw binary
  • sequencer.hex - Intel HEX file (for flashing)
  • sequencer.srec - Motorola SREC file (for flashing)
  • sequencer.list - List file containing full disassembly
  • sequencer.map - Map file containing section/offset information of each symbol
  • sequencer.size - Size file containing size of each section

If compiling the sequencer, an additional UPDATE.DAT file is generated which can be used for flashing the firmware using the bootloader.

To simplify flashing an application to the hardware during development, each application has an associated flash target. For example, to flash the bootloader followed by the sequencer application use:

make -j flash_bootloader
make -j flash_sequencer

Flashing to the hardware is done using OpenOCD. By default, this expects an Olimex ARM-USB-OCD-H JTAG to be attached to the USB port. You can easily reconfigure this to use a different JTAG by editing the OPENOCD_INTERFACE variable in the src/platform/stm32/CMakeLists.txt file. Make sure to change both occurrences. A list of available interfaces can be found in the tools/openocd/share/openocd/scripts/interface directory (or /home/vagrant/tools/openocd/share/openocd/scripts/interface when running the virtual machine).

Developing for the simulator

Note that the simulator is only supported on macOS and Linux and does not currently run in the virtual machine required on Windows.

You will typically use the debug target when building for the simulator. So you first have to enter the debug build directory:

cd build/sim/debug

To compile everything, simply use:

make -j

To run the simulator, use the following:

./src/apps/sequencer/sequencer

Note that you have to start the simulator from the build directory in order for it to find all the assets.

Source code directory structure

The following is a quick overview of the source code directory structure:

  • src - Top level source directory
  • src/apps - Applications
  • src/apps/bootloader - Bootloader application
  • src/apps/hwconfig - Hardware configuration files
  • src/apps/sequencer - Main sequencer application
  • src/apps/tester - Hardware tester application
  • src/core - Core library used by both the sequencer and hardware tester application
  • src/libs - Third party libraries
  • src/os - Shared OS helpers
  • src/platform - Platform abstractions
  • src/platform/sim - Simulator platform
  • src/platform/stm32 - STM32 platform
  • src/test - Test infrastructure
  • src/tests - Unit and integration tests

The two platforms both have a common subdirectories:

  • drivers - Device drivers
  • libs - Third party libraries
  • os - OS abstraction layer
  • test - Test runners

The main sequencer application has the following structure:

  • asteroids - Asteroids game
  • engine - Engine responsible for running the sequencer core
  • model - Data model storing the live state of the sequencer and many methods to change that state
  • python - Python bindings for running tests using python
  • tests - Python based tests
  • ui - User interface

Third Party Libraries

The following third party libraries are used in this project.

License

License: MIT

This work is licensed under a MIT License.

performer's People

Contributors

av500 avatar jmsole avatar sloblolabs avatar westlicht avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

performer's Issues

Step recording from cv input (implementation request)

Would be possible use one cv input to enter note value in step recording? Would be super useful, as not everyone use midi keyboard\controller within modular.
Something like cv output from cv\gate keyboard into cv input 1 for note value, and trigger\gate out from keyboard into cv input 2 to determine when pass to the next step.

Supervisor - ic or firmware

On power up of my rack (doepfer psu3), performer fails to start until power cycled. I am at less than 50% rated current for the psu. Lots of other digital modules. On other psus it starts first time. I suspect this is an in-rush current/timing event.

Suggestion: if you are updating the hardware - any chance of a supervisor ic on the rst pin? Or using the firmware supervisor? (But I know nothing about the stm32 built in supervisor other than it exists). Thanks for the consideration....

key change in a song

Would love to have octave&transpose to patterns to be applied at song level so at a stage in the song the key can change.

User scales loaded from SD card have default name

Steps to reproduce:

  1. Create a chromatic user scale with a new name (ex: DORIAN)
  2. Save this scale to the SD card on an empty slot
  3. Load it back from the SD card on any user scale slot
  4. The scale structure will be preserved, but the name is not (always INIT)

Expected result: Both name and structure are preserved
Version: 0.1.13

Delayed Gates (feat. request)

Would be great if we could make sure the CV output value is available before gates are triggered. I encountered this not to be ensured when programming a certain pattern for BIA.
Current workaround: CV Update Mode = Always and programming the desired CV value in the note slot before (!).

(Enhancement) Mute/solo with curve track

It would be nice to be able to mute/solo tracks from curve tracks.
The interface could look exactly as any other routable parameter where you can pick a track to be affected (via checkbox). On Performer page we also could show that mute/solo is controlled by curve track (similar to the arrow sign)

Launchpad Integration: Show "base note" of octave

It would help a lot if the "base note" of each octave was permanently shown in some way on each note "page" on the Launchpad.

Scales do not always contain exactly 8 notes so the first note in an octave often isn’t on the bottom row of pads.

Because of this, it would be useful to have a visual cue on the Launchpad itself of where the base note of each octave lies.

grades A,B

hi

any objections to (eventually) adding or pulling 16 bit support into your main repo? i'm not 100% but it looks as if that's all there is to it (minus the OFFSET_0995 switch of course, which obviously is tangential / irrelevant).

Slide Behaviour MIDI Output

What's the current behaviour for slides with MIDI output? It doesn't currently seem to have any effect.

Suggested Behaviour Options:

  • Overlap incoming note and previous step note. This would work with MIDI synthesisers with a "mono legato" mode or similar.
  • Transmit standard MIDI CC for Portamento (CC65), and possibly also CC5 (Portamento Time)

Each method has advantages and disadvantages.

Negatives for Method 1:

  • Gate-length of previous step would be ignored.
  • Previous triggered note may not be on previous step, so last note may have to be extended over several steps, which might be confusing.

Negatives for Method 2:

  • Envelopes on receiving MIDI device will be re-triggered with slid notes, so not possible to emulate classic "acid-style" note-slides.

Maybe there could be an option on the MIDI output page to choose one of the above slide behaviours.

Auto-Increment To Next Step When Entering Notes Via MIDI

To aid fast note-entry, when using an attached MIDI keyboard to enter notes, automatically increment the active step after entering a note.

I'd envisage starting entering notes in this way by holding a step button, and hitting a key on the keyboard (as it operates currently). After that, though, active step would automatically increment so the next key-press would set the note for the next step, etc.

One of the step buttons could be held in the normal way, to edit the note at that step, and auto-incrementing would continue from that step.

Auto-incrementing would continue until the either the last step pf the pattern had been reached (either the Last Step set on the Sequence page, or step 64), or could wrap around to the beginning of the pattern.

Curve Track Probability

Some form of randomisation of Curve track steps.

The most obvious thing to randomise would be segment type.

Another possibility (maybe in addition to the above), would be some equivalent of the gate probability control for a Note track. In this case, how about a set-able probability to determine if the selected curve plays, or the value at the end of the previously-played segment is held for the duration of the current step?

Implement micro timing for note tracks

Allow shifting steps left/right in time. This is a little tricky to implement as we now have to do look ahead when playing back the sequences. This would also allow unquantized live recording.

Front panel

There seems to be an issue with the front panel. The v-cut line is missing.

Allow curves to span multiple steps

Currently a curve is always one step in duration.
It would be useful to allow curves to span multiple steps i.e. Have a duration.
Perhaps holding both the start and the end step simultaneously whilst dialing in the curve could set a duration greater than one?

finer percentage on Gate offset?

Hey first of all I want to say you doing great work with the performer. I am enjoying it a lot.
the gate offset is great, but it would be much more useful for me if I could set finer percentage like 3% 6% or so.

Glitchy Encoder

I'm finding the encoder glitchy. If turned too fast, it can reverse direction.

I'm using the specified encoder part.

I thought initially it was a hardware issue with my build (I've experienced similar behaviour with other builds, when I've forgotten to solder a capacitor related to the encoder), but a more experienced DIY builder friend noticed the same behaviour with their build.

Set Full-Range of Min/Max Step Values In Curve Track from Launchpad

Currently, the Min and Max values can only be set for steps in Curve mode in 0>63 range from an attached Launchpad, where the true range of these values is 0>255.

This limits the usefulness of Launchpad integration when editing Curve tracks (though segment curve-selection is excellent!).

possible solution:

Remap LP values to 0>255 range, so each pad represents 4 values.

MIDI Out

  1. There is few drum machines that respond only to midi channel #10.
    Currently it's possible to work only with channes 1-8.
  2. There is no sign at the midi monitor page.

Generate random or algoritmic population of gates with encoder

I used to own a delptronics triggerman and it has this wonderful function to fill or populate the gates in a sequence. You just turn the knob and it has an algorithm which populates the sequence at the turn of the knob making it more and more complex until it fills it up This would be amazing for live performance without having to go into the generator menu.

Explanation video:
https://youtu.be/vP50CgGeuhk?t=46
(second 46 shows how the complexity knob works)

Root note error.

I´m having an issue when setting a scale (even user scales) and then changing the root note. For example if i choose "minor" scale and then choose D it will make make the note in my oscilator go to D# and then if i choose D# as my root note the oscilator will output G. It will quantize to wrong scale notes when changing the root note.

Improve solo behaviour

When soloing a track the currently active mutes are not remembered. This means than when unsoloing the the same track, all tracks are now unmuted. It might make sense to switch to a solo mode when soloing the first track, and restore the mutes when solo mode is left.

Clock swing

Add the option to output the analog clock with swing. This would allow to output the same swing to external sequencers that is also used internally.

Akai APC Mini Support

Add support for Akai APC Mini pad controller.

Things to consider:

Extra non-illuminated button could be used instead of Launchpad button 8.

Round buttons under and to right of 64-pad matrix are single-colour (red/green). Maybe buttons down side could light constantly to indicate selected track, flash to indicate gate activity of non-selected tracks.

9x sliders. Maybe 9th slider could be used as value slider, and other sliders could be assignable on Routing page.

MIDI Output Octave Source

Option in MIDI Output page to have Note and Octave from different tracks, or have one track as transpose source for notes from another track.

Add more retriggers? (enhancement)

Lately I'm thinking about more kind of retriggers. As for now we can set it to 1,2,3 or 4 retriggers for step. Would be cool\useful to add more retriggers per step or different distribution of retriggers...sort of burst generation!
Also actually 3 and 4 retriggers seems to be unequally distributed along the step, is this right?

MIDI Bank-Select and Program-Change For MIDI Output

How about implementing MIDI Bank-Select and Program-Change for MIDI outputs?

I guess the module would sent out the messages when first playing a Project.

To make it even more useful, bank and program-change messages could be set on a per-pattern basis, so patches could be changed on MIDI devices when changing patterns on the Performer.

Select Bus control (feat request)

There's a growing number of eurorack modules that can store states and respond to preset recall via the 'select bus' spec. Malekko modules can, some WMD, some Make Noise, Expert Sleepers Distings and Mungo modules

This is really just a MIDI CC to indicate save or recall, followed by a midi program change message to indicate the slot.

Here is a short video of a Teletype implementation im working on
https://www.youtube.com/watch?v=45sEcgE0N6Q

Here is a video from Make Noise
https://www.youtube.com/watch?v=W5mx6kuHgQU

These MIDI messages need to make there way onto the CV bus pin. Obviously that would mean a huge redesign, however in the mean time expert sleepers make a cheap DIY module that has MIDI input jack onto the bus.

I think the feature to send select bus control would be great to implement onto the Performer! Required MIDI messages are:

MIDI instruction on Project load:
CC 16 Val 64 (Load)
PRG change [Performer Project Number]

MIDI instruction on Project save:
CC 16 Val 127 (Save)
PRG change [Performer Project Number]

Those few lines enable save and recall of many modules states synced with the performer projects!

VCVRack port for simulator

Hi Simon,
Have you considered adding a build/port of the simulator for VCVRack? there are already many sequencers available there but people love skeuomorphic interfaces and i think per|former would be a hugely popular module there.
Cheers,
southpole

Dual Drum Track Mode To Use Both CV and Gate Outputs

How about a new Dual track mode, that could use both CV and Gate outputs as drum triggers?

It would have two Gate layers, on for the Gate output, the other would use the CV output of the gate/CV pair as gate/trigger.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.