Se connecter
Se connecter
Mot de passe oublié ?
ou
Créer un compte
ou
Se connecter avec Facebook
Notifications
< Retour vers Roland D-10
Agrandir
Ajouter ce produit à
  • Mon ancien matos
  • Mon matos actuel
  • Mon futur matos
Roland D-10
Photos
1/221
Roland D-10

Clavier synthétiseur numérique de la marque Roland

Ce produit n’est plus fabriqué.

9 avis
Acheter
ACHETER D'OCCASION (2) À partir de 150 €
Présentation du produit Présentation
Avis 9 9
Comparateur de prix
Petites annonces Annonces 2 2
Forums 42 42
Tutoriels 3 3

Sujet Commentaires sur le tuto : Les SysEx du D10

  • 4 réponses
  • 3 participants
  • 111 vues
  • 3 followers
Sujet de la discussion Commentaires sur le tuto : Les SysEx du D10
roland-d-10-842.jpg

Ce thread est destiné à discuter du tutoriel "Les SysEx du D10"

Pour découvrir mon boulot : www.aletatbrut.com

2
Travaillant sur un outil pour manipuler les Sysex du D10/110/20 j'ai été confronté à ce souci de données sur 7 bits, et je me suis fait une paire de fonctions de conversion.
Je vous les partage, si ca peut être utile à quelqu'un...
C'est du java, mais ca peut facilement être converti dans d'autres langages, car elle utilisent juste des décalage de bits et des operations logiques (AND et OR) sur les bits.

Je suis parti du principe qu'il était plus simple de travailler avec données sur 8 bits, puis de faire la conversion en 7 bits à la fin.
Ainsi, pour reprendre l'exemple du tuto:
L'adresse de départ est 04 01 76 (adresse en 7 bits utiles) on va d'abord la convertir en version 8 bits utile.
Ainsi 04 01 76 (en hexa) qui s'écrit en binaire 0000_0100 0000_0001 0111_0110 (j'ai mis des _ pour montrer les bits d'un même octet et le 0 inutile en gras, ça facilite la lecture). Et ceci devient 000_0100 000_0001 111_0110 une fois le 8e bit (inutilisé) retiré.
Si on le regroupe ces bits en paquets de 8 bits, ca nous donne les octets suivants: 0_0001 0000_0000 1111_0110 (il manque trois zéros au début, qui correspondent au 3 bits inutilisés retirés
On obtient donc comme adresse de départ "réelle" 01 00 F6 (en hexa) soit 65782 en décimal

Ensuite, on ajoute à cette valeur les offsets d'adresse (0E et 17 dans l'exemple du tuto, soit 14 et 23 en décimal)
On a donc 65782 + 14 +23 = 65819 qui est l'adresse de notre paramètre.
Cette adresse (65819) en binaire est: 0001 0000_0001 0001_1011
Si on applique la conversion en 7 bits utile, en intercalant des 0 (en gras) sur le 8e bit de chaque octet on obtient:
00_0100 0000_0010 0001_1011, soit 04 02 1B, ce qui est bien le résultat de l'addition trouvé dans le tuto.

J'ai donc écrit 2 fonctions, une qui converti 3 octets n'ayant que 7 bits utiles en la version décimale correcte: (converti 04 01 76 en 65782)
 /**
     * Converti une adresse sur 3 octets avec 7 bits utiles en une adresse 8 bits.
     * @param byte1
     * @param byte2
     * @param byte3
     * @return
     */
    int convert7Bit3BytesAddressToInt(byte byte1, byte byte2, byte byte3) {
        return   byte3 & 0xFF |
                (byte2 & 0xFF) << 7 |
                (byte1 & 0xFF) << 14;
    }

et une autre, qui converti une addresse sur 8 bits, en un tableau de 3 octets n'ayant que 7 bits utiles (converti 65819 en 04 02 1B)
La fonction est volontairement limitée à 3 octets (pas besoin de plus pour le D10) et lève une exception si on tente de convertir une adresse plus grande
 /**
     * Converti une adresse en 8 bits en sa representation sur 3 octets avec  7 bits significatifs
     *
     * @param address l'adresse a convertir
     * @return le resultat sur forme d'un tableau de 3 octets
     * @throws Exception si l'adresse est trop grande pour etre convertie sur 3 octets
     */
    public byte[] convertAddressTo7Bit3Bytes(int address) throws Exception {
        if (address>8355711) {
            throw new Exception("Adresse " + address + " trop grande pour tenir sur 3 octets");
        }
        // Decale de 0, 7 ou 14 bits et ne conserve que les 7 derniers
        int byte1 =  address >> 14 & 0x7F;
        int byte2 = address >> 7 & 0x7F;
        int byte3 = address & 0x7F;

        return new byte[] {(byte)byte1, (byte)byte2, (byte)byte3};
    }

En java les byte sont signés, donc vont de -128 à +127, mais comme on travaille sur 7 bits, les valeurs possible ne sont que de 0 à 127, du coup on est pas embeté par le fait que sa soit signé.

Roland D-50, D-20, D-110, JV-1080 - Studiologic SL88 - Yamaha TX802, TQ5 - Akai S2000
Boss SE-50 & SE-50A - MOTU Midi Timepiece AV (x2)
Atari Mega STE & Falcon - PC XP & W10 - Mac

[ Dernière édition du message le 24/01/2024 à 15:24:46 ]

3
Bravo ! Belles compétences !
4
Citation de Jlkas :
Bravo ! Belles compétences !

J'ai pas mal galéré pour convertir d'un mode à l'autre
J'ai commencé par convertir les adresses en une chaine de caractères (avec des 0 et des 1), puis à la découper en bloc de 7 caractères, reconvertis ensuite en nombres. Ca marchait bien, mais c'était un peu usine à gaz
Je suis finalement arrivé a cette solution simple par décalage de bits

Roland D-50, D-20, D-110, JV-1080 - Studiologic SL88 - Yamaha TX802, TQ5 - Akai S2000
Boss SE-50 & SE-50A - MOTU Midi Timepiece AV (x2)
Atari Mega STE & Falcon - PC XP & W10 - Mac

5
Super! Avoir un outil comme ça m'aurait simplifié la vie!
Je crois - si je me souviens bien - que j'avais utilisé la calculatrice de MacOSX, qui me permettait la conversion.
En tout cas quand j'ai fait mon éditeur de D10 pour BCR2000 j'ai bien galéré avec tout ça !
J'ai voulu rempiler avec le DX7 mais ça m'a fatigué... :mdr:

Pour découvrir mon boulot : www.aletatbrut.com