SDK¶
Le SDK propose les informations nécessaires pour créer des logiciels utilisant le module OR1, ou adapter les fonctionnalités du logiciel existant.
Organisation logicielle générale¶
La partie logicielle du module OR1 comprends les éléments suivants:
un système linux avec les différents drivers matériels
un interpreteur micropython, compilé spécifiquement pour cette plateforme
une bibliothèque libmidiplayer, exposée sur l’interpreteur micropython
Cette organisation est représentée comme ci dessous :
La partie logicielle est au centre du fonctionnement du module, cette partie implémentée en C/C++/rust fourni l’ensemble des fonctions nécessaires à la création d’écran et la partie sonore.
Cette partie est exposée à l’interpreteur python pour l’orchestration.
Plusieurs composants sont présents dans le logiciel : le module trigger réalisant la synthèse sonore à partir des fichiers wav, permettant de mixer au rythme souhaité, les différentes voies, avec les registres et récalages sonores. Un composant player prenant en charge la lecture des fichiers, l’envoi des notes au trigger, la gestion du temps et tempo.
Utilisation l’API micropython¶
Micropython est un interpreteur python spécialisé pour les petites plateformes, certains points sont à noter sur cette version, si le lecteur est familié avec le développement en python :
l’allocation de mémoire est réalisé différemment (on ne passe pas par le système, et est alloué dans une arena)
la bibliothèque de fonction est la même pour le noyau, cependant les modules sont spécifique à micropython (en fonction de la plateforme)
La documentation complète du language est disponible sur internet à cette adresse : https://docs.micropython.org/en/latest/
Gestion de l’écran¶
Le module python LGVL est intégré à l’interpreteur, il vient avec un grand nombre de fonctionnalités et bibliotheques de widgets, permettant la construction d’écrans.
La documentation complète de la librairie LGVL est disponible sur internet à cette adresse : https://docs.lvgl.io/latest/en/html/index.html
La librairie est accessible via le module lvgl, il est possible de l’importer dans un script python et l’initialiser pour le module OR1, avec le script suivant :
import usys as sys
sys.path.append('') # See: https://github.com/micropython/micropython/issues/6419
import lvgl as lv
lv.init()
import fb # Frame buffer driver
disp_buf1 = lv.disp_draw_buf_t()
buf1_1 = bytearray(WIDTH_SCREEN*10)
buf1_2 = bytearray(WIDTH_SCREEN*10)
disp_buf1.init(buf1_1, buf1_2, len(buf1_1)//4)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.draw_buf = disp_buf1
disp_drv.flush_cb = conf.cb
disp_drv.hor_res = WIDTH_SCREEN
disp_drv.ver_res = HEIGHT_SCREEN
disp = disp_drv.register() # Register the driver and save the created display object
import ev # Event interface (touchpad, encoder, keyboard, mouse)
fb.init() # Initialize the frame buffer device
ev.init() # Initialize the input device driver
def timercb(timer): # Timer callback
lv.tick_inc(5)
lv.task_handler()
player_state_task = lv.timer_create(timercb, 20, None) # every 20ms
if __name__ == '__main__':
while True:
utime.sleep(1)
Utilisation de la manivelle¶
Un module manivelle permet de se connecter à la manivelle et lire la position absolue de l’axe. Ci dessous un exemple d’utilisation de cette librairie pour afficher en continue la position de l’axe.
import manivelle
manivelle.init()
while True:
print(manivelle.get_pos())
Fonctions de référence de la librairie midiplayer¶
Le module midiplayer contient les fonctions nécessaires à l’utilisation de OR1. il contient les fonctions suivantes :
Fonctions d’initialisation de la bibliothèque¶
"""
Module contenant les fonctionnalités du module OR1
"""
def init():
"""
initialise la librairie midiplayer
"""
pass
def feature_set(feature_name, feature_value):
"""
définit la valeur d'une feature
"""
pass
def property_set(property_name, property_value):
"""
définit la valeur d'une propriété de paramétrage
"""
pass
L’initialisation de la librairie est nécessaire au démarrage, pour pouvoir utiliser les fonctions associée.
Fonctions d’utilisation des instruments¶
Les fonction ci dessous proposent une gestion des bank de sons et instruments.
def loadsoundbank(filename):
"""
charge une bank de sons, filename contient le nom de l'instrument
cette fonction monte en mémoire la connaissance de la bank de son
pour l'utiliser dans le module il est nécessaire d'utiliser "definesoundbank"
"""
pass*
def definesoundbank():
"""
applique la bank de sons chargée précédemment
"""
pass
def activebank(bank):
"""
active le jeu de registre "bank"
@exception une exception est levée en cas d'erreur
"""
pass
def deactivatebank():
"""
desactive le jeu de registre "bank"
@exception une exception est levée en cas d'erreur
"""
pass
def instruments():
"""
@return retourne une liste de noms d'instrument disponibles pour le jeu
"""
pass
def get_current_instrument_registers():
"""
pour l'instrument en cours, donne la liste des registres
"""
pass
def current_instrument_name():
"""
donne le nom de l'instrument actif actuellement
"""
pass
Gestion du jeu du fichier, et interaction avec le player¶
Une fois initialisée, le player peut être piloté avec les quelques fonctions proposées ci dessous.
def play(filename):
"""
Démarrage du jeu en lisant le fichier dont le nom est passé en paramètres
@exception une exception est retournée en cas d'erreur (lecture de fichier)
"""
pass
def stop():
"""
Arrête le player et le jeu du fichier courant
"""
pass
def isplaying():
"""
@return un booleen indiquant si le player est en cours de jeu
"""
pass
def pauseresume():
"""
effectue une pause / reprise du jeu en cours
"""
pass
Ci dessous les fonctions permettant d’interragir avec le player, et le jeu. On retourne un nombre de fonction permettant de savoir où en est le jeu.
def playstreamlength():
"""
retourne la longueur du fichier en cours de jeu
"""
pass
def playstreamposition():
"""
retourne la position actuelle de jeu dans le fichier
"""
pass
def changetempofactor(tempofactor):
"""
change le tempo de jeu
@param tempofactor : un nombre définissant le facteur de temp (1.0 -> vitesse originale, 0.5 -> vitesse doublée)
"""
pass
def change_pitch(pitch_int):
"""
@param pitch_int
nombre de demi ton pour la transposition
(ce nombre peut être négatif)
"""
pass
def current_pitch():
"""
@return integer
retourne le pitch positionné
"""
pass
def stopallvoices():
"""
arrete le jeu de toutes les voix (faire silence)
en cas de mise en pause du player, certaines voix peuvent
rester active.
Cette fonction permet d'arreter les voix en cours
"""
pass
def lyrics_clock():
"""
@return retourne l'horloge de changement associée aux paroles.
lorsque les paroles change (associée au morceau),
le nombre detrourné est
"""
pass
def lyrics_current():
"""
@return recupère les paroles affichée en ce moment
"""
pass
Encryption¶
def encrypt(filename):
"""
encrypte le fichier donné en paramètre, en utilisant la clef cryptée
"""
pass
Gestion de l’autorisation et de la license¶
def license_serial():
"""
retourne l'identifiant de license
"""
pass
def license_query():
"""
retourne l'état d'autorisation de la license, pour pouvoir utiliser les fonctions
"""
pass
Utilisation des API C¶
L’api C propose un accès directe aux fonctionnalités du player, sans interpreteur. Cette librairie est utilisable dans des languages natifs ou autres contexte que le micropython.
libmidiplayer.so.1¶
Cette librairie expose les différentes fonctionnalités principales du module.
/**
* init the runtime
*/
void midiplayerlibcinit()
/**
* init the library
*/
int midiplayerlib_init(void)
// properties
static const char *LICENSE_PROPERTY = "lic";
static const char *DISABLE_PERCUSSIONS = "mute_percussions";
static const char *INTEGRATED_MANIVELLE = "integrated_manivelle";
static const char *INTEGRATED_MANIVELLE_MODE = "integrated_auto_manivelle";
static const char *INTEGRATED_MANIVELLE_FACTEUR = "integrated_auto_manivelle_decifacteur";
static const char *OUTPUT_SERIAL_DEVICE = "output_serial_device";
static const char *SOUND_PATH_PROPERTY = "sound_path";
static const char *PLAY_COMMAND_LINE_TEMPLATE = "play_command_line_template";
int midiplayerlib_defineproperty(const char *property, const char *value)
/**
* load a sound bank / instrument
*/
void *midiplayerlib_loadsoundbank(const char *filename)
/**
* encrypt file using the public internal key
*/
int encrypt_file(const char *filepath)
/**
* play file, using it's filename
*/
int midiplayerlib_play(const char *filename)
int midiplayerlib_pauseresume(void) // return -1, 0: false, 1:true
int midiplayerlib_stop(void)
int midiplayerlib_stopallvoices(void)
///////////////////////////////////////////////////////////////
int midiplayerlib_definesoundbank(const void *soundbank)
int midiplayerlib_activatebank(const char *bank)
int midiplayerlib_deactivatebank(const char *bank)
int midiplayerlib_changetempofactor(const double f)
int midiplayerlib_changepitchfactor(const double f)
int midiplayerlib_change_pitch(const int pitch)
int midiplayerlib_current_pitch(int *pitch)
float midiplayerlib_play_currentstreamposition()
float midiplayerlib_play_currentstreamlength()
int midiplayerlib_isplaying() // 1 true , 0 false
int midiplayerlib_activatefeature(const char *feature, int activated)
int midiplayerlib_instrument_count()
int midiplayerlib_instrument_name(int index, char *buffer, int *maxchars)
int midiplayerlib_instrument_current(char *buffer, int *maxchars)
int midiplayerlib_instrument_register_count()
int midiplayerlib_instrument_register_name(int index, char *buffer, int *maxchars)
int midiplayerlib_lyrics_simple_get_lamport(int *clock)
int midiplayerlib_lyrics_simple_get_content(char *buffer, int *maxchar)
int midiplayerlib_encrypt_file(const char *filename)
int midiplayerlib_serial(char *outserial, int *outchars, int *valid)