comment démultiplier une clock ?

[krikorola]

si je dois passer par un micro contrôleur ça va vite se compliquer (je vais devoir créer un programmer, non?), j'ai des notions très basique...

[ACX]

Oui, car les MIDI Ticks ne sont pas des "pulse" analogiques mais une suite de nombres (F8 en héxadécimal). Ce n'est pas très difficile à faire (je le fais bien dans mes modules), mais si tu n'as aucune notion de programmation ça va te prendre un peu de temps ....

[krikorola]

ok merci, en meme temps je veux vraiment pas faire un truc compliqué, juste /2 et /4, pas besoin de plus.
Peux tu m'aiguiller vers un micro contrôleur qui suffirait?

[ACX]

La question n'est pas là. Que tu divises ton tempo par 2, ou par racine de 2 c'est exactement pareil au niveau du programme.
Il faut que tu cales ton proc sur la fréquence MIDI (31250) que tu récupères les données MIDI, que tu les analyses pour ne garder que les fameux 0xF8. A ce niveau le plus dur est fait car il ne te restes plus qu'à les compter pour calculer ton tempo. La fréquence est en principe de 24 Ticks par noire donc si tu veux aller plus lentement tu en comptes 48 ou 96.
Maintenant comme je te l'ai dit, si tu n'as aucune notion de programmation ce n'est pas impossible à réaliser, il faut bien commencer un jour et chez moi ce n'était pas inné non plus, mais cela va te prendre tout de même pas mal de temps.
Je ne cherche pas à te décourager, bien au contraire, je veux simplement te dire que ça ne se fera pas en quelques jours. Maintenant, si tu t'en sens le courage n'hésite pas !

[yusynth]

Je dirais que la meilleure technique pour démultiplier une cloque c'est de se fouetter avec des orties.


OK je sors...

[O-live]

fraîches de préférences

[krikorola]

Ok
merci ACX je vais y' coller on verra bien!

[ACX]

Excellente résolution ! Le choix du µContrôleur n'est pas critique, choisis en un avec une UART, ça te simplifiera la tâche.

[vanille69]

Hé hé, ça la être la valse des Timers pour les Pics

Sinon tu peux attendre que je finisse ce truc (oui, je sais, si j`avais fini tous mes projets je pense que je serais entrain de me griller la pillule au bord de l`eau un Jack à la main):



Toute l`électronique fonctionne mais dois faire des modifs/ rajouts: je vire l`entree CV et la remplace par un entree clk ext, rajout d`un Tap control qui se trouve sur la pedale que j`ai présenté, sur les conseils de Mr Choucroute rajouter des compteurs BPM sur l`entree et les sorties Clk, virer la fonction step (car bof une fois que je l`ai testée; ce n`est pas un séquenceur)plus des petits trucs....

[krikorola]

j'ai trouvé des infos intéressantes sur ce blog:

http://little-scale.blogspot.fr/2008/05 ... ls-in.html" onclick="window.open(this.href);return false;

en fait il faut que je filtre les bit de midi clock suivant 3 règles, normal, un sur deux, un sur quatre.
un switch trois positions comme contrôleur physique.
et laisser passer les reste des commande start, stop, continue, note on/off

[vanille69]

effectivement, tu prends par exemple un pic 16f628a pas cher, fiable, largement suffisant pour l`application et tu peux lui coller un midi in, un midi out + le switch. Ce que je fais dans le montage que j`ai présenté est un peu different: je fais "sortir" le midi clk décodé, je le divise grace à des compteurs et je réinjecte la sortie des compteurs dans le pic pour avoir un signal midi clk divisé.
La programmation de ce pic en assembleur est basique avec l`environnement de mplab. N`oublis pas de "commencer le pas de division" en relation avec le midi Start sinon par moment tu risques d`etre décalé

[krikorola]

j'ai commencé mes recherches:

avec le 16f628a, la logique serai:

RA0/RA1/RA2/RA3 connecté à un sélecteur 4 position pour 1/2 mesure (pas de modification, 1 mesure (1 octet sur deux), 2 mesures (1 octet sur 4) et 4 mesures (1 octet sur 8).

les données start, stop, continue, note on note off, vélocité et cc midi passent au travers et sont directement transmise au midi out.

Si les octets de clock tic 0xf8 sont reçu le logiciel regarde l'état de RA0-RA3

si RA0=1 (et RA1 à 3=0) sélecteur en position 1/2 mesure, alors les données sont transmises directement au midi out
Si RA1=1 (RA0/2/3 = 0) sélecteur en position 1 mesure, alors les données sont filtré tel que 1 sur 2 octet soit transmits.
Si RA2=1 (RA0/1/3 = 0) sélecteur en position 2 mesures, alors les données sont filtré tel que 1 sur 4 octet soit transmits.
Si RA3=1 (RA0/1//2 = 0) sélecteur en position 4 mesure, alors les données sont filtré tel que 1 sur 8 octet soit transmits.

d'après ces données j'aurai quelque chose comme çela au niveau variables et constantes:

var
bDataReceived: boolean;
RxData: byte;
In_Filter_clock: sbit at RA0_bit; // filter midi clock 1/2mes ($0XF8)
In_Filter_clock: sbit at RA1_bit; // filter midi clock 1mes ($0XF8)
In_Filter_clock: sbit at RA2_bit; // filter midi clock 2mes ($0XF8)
In_Filter_clock: sbit at RA3_bit; // filter midi clock 4mes ($0XF8)

const
cMIDI_Note_On = $90; // Note On on channel 1
cMIDI_Note_Off = $80; // Note Off on channel 1
cMIDI_Note_On = $99; // Note On on channel 10
cMIDI_Note_Off = $89; // Note Off on channel 10
cMIDI_Pitch_base = $3C; // "base" pitch / note - fixed here at C3 (Do3)
cMIDI_Vel_On = $64; // velocity, 100 on the 0..127 scale
cMIDI_Vel_Off = $00; // velocity, value $00
cMIDI_controller = $B0; // controller on channel 1
cMIDI_Start = $0XFA; // clock start
cMIDI_Stop = $0XFC; // clock stop
cMIDI_continue = $0XFB; // clock continue
cMIDI_clock = $0XF8; // clock pulse

quel fonction puis je utiliser pour filtrer les octets?

[vanille69]

Pour tester il te suffit d`employer un Xor. Voci en expemple le test de mon interruption de l`uart:

"BufferMidi" est juste une variable qui sert de tampon définie en entête de programme par, par ex.: BufferMidi equ 0x070 pour adresser la case $70 à Buffermidi.

Code : Tout sélectionner

;*********************************Routine Interruprion************************************                            
;*****************************************************************************************

;***************sauvegarder registres*************
		ORG 	0x0004			;adresse d'interruption
		movwf	WTmp  			;sauver registre W
		swapf	STATUS,w		;swap status avec résultat dans w
		movwf	StatusTmp		;sauver status swappé

		Bank0

;*************Midi Irq**************
       btfsc	PIR1,RCIE		;test Midi Irq: Irq Uart validée?
	btfss	PIR1,RCIF         ;flag de l`Irq Uart positionné?
		goto	DinIrqTest		;non-> irq non de l`uart test autre Irq
	
		movf	RCREG,W		;buffer Rxd dans W
	movf	BufferMidi,w	;test midi clk: sauvegarder W dans BufferMidi
		xorlw	 0xF8			;W XOR F8  (w=F8?)	
		btfsc	STATUS,Z		;test si resultat nul (Z=1)
		goto	MidiClk			;si oui aller au traitement du Midi CLk

	
		movf	BufferMidi,W            ;sinon envoyer la donnée reçue dans le midi: BufferMidi dans W
		movwf	TXREG		;envoyer W (W contient Midi) sur Txd
		goto	RestoreReg		;aller a fin Irq////////////////////////

.../....

;*************restaurer registres**************
RestoreReg	swapf	StatusTmp,w		;swap ancien status, résultat dans w
		movwf   STATUS			;restaurer status
		swapf   WTmp,f			;Inversion L&H de l'ancien W sans modifier Z
		swapf   WTmp,w  		;Réinversion dans W. W restauré sans modif status
		retfie  			;return from interrupt

J`espère que ça pourra t`aider.

[ACX]

Si tu préfères programmer en C, tu peux reprendre les fonctions sur mon site.

[krikorola]

je continue mes recherches d'info quand j'ai un peu de temps
j'aimerai donc faire ceçi:

compter les bytes midiclocks

suivant la position d'un sélecteur

en position 1: laisser passer le flux
en position 2: Retirer 1 byte tout les 2 bytes
en position 3: retirer 3 bytes tout les 4 bytes
en position 4: retirer 7 bytes tout les 8 bytes

passer les bytes à la sortie

pour l'instant j'ai ça en m'inspirant de divers source et lisant des docs sur le PIC, il n'y a rien sur le count et les filtrage:

Code : Tout sélectionner

var
  bDataReceived: boolean;
  RxData: byte;
  In_Filter_clock1: sbit at RA0_bit;  // filter midi clock 1/2mes ($0XF8)
  In_Filter_clock2: sbit at RA1_bit;  // filter midi clock 1mes ($0XF8)
  In_Filter_clock3: sbit at RA2_bit; // filter midi clock 2mes ($0XF8)
  In_Filter_clock4: sbit at RA3_bit;  // filter midi clock 4mes ($0XF8)

const
  cMIDI_Note_On    = $90;  // Note On on channel 1
  cMIDI_Note_Off   = $80;  // Note Off on channel 1
  cMIDI_Note_On    = $99;  // Note On on channel 10
  cMIDI_Note_Off   = $89;  // Note Off on channel 10
  cMIDI_Pitch_base = $3C;  // "base" pitch / note - fixed here at C3 (Do3)
  cMIDI_Vel_On     = $64;  // velocity, 100 on the 0..127 scale
  cMIDI_Vel_Off    = $00;  // velocity, value $00
  cMIDI_controller = $B0; // controller on channel 1
  cMIDI_Start      = $0XFA; // clock start
  cMIDI_Stop       = $0XFC; // clock stop
  cMIDI_continue   = $0XFB; // clock continue
  cMIDI_clock      = $0XF8; // clock pulse

procedure Main_Init;
begin
  CMCON := 7;            // disable comparators
  OPTION_REG := 0;
  INTCON.GIE := 1;       // |- enable interrupt
  INTCON.PEIE := 1;      // |
  TRISA      := %10111111;
  TRISB      := %00000010;
  PORTA      := 0;  // clear porta
  PORTB      := 0;  // clear portb
  T1CON.T1CKPS1 := 1;
  // init USART
  //TXSTA.BRGH := 1;    // high speed baud rate
  TXSTA.SYNC := 0;    // asynchronous mode
  TXSTA.TX9 := 0;     // 8-bits transmission
  TXSTA.TXEN := 1;    // Tx enabled
  RCSTA.CREN := 1;    // enable receiving / accept continuous mode
  RCSTA.SPEN := 1;    // Rx enabled;
  RCSTA.RX9 := 0;     // 8-bits transmission
  PIE1.RCIE := 1;     // enable interrupt for UART Rx
  //PIR1.RCIF := 0;   // RCIF is read-only, can't reset it directly
  UART1_Init(31250);  // speed for MIDI communication
end;

procedure Interrupt;

begin
  if TestBit(PIR1, RCIF) then
  begin
    // always read RCREG register, even if event will be not used
    RxData := RCREG;
    // don't take account of note received during prog procedure

while (Rxdata = cMidi_clock)
{switch (clockspeed) 
{
case 1: RxData = cMIDI_clock && In_Filter_clock1 RA0;
break; 
case 2: RxData = cMIDI_clock && In_Filter_clock2 RA1;
break; 
case 3: RxData = cMIDI_clock && In_Filter_clock3 RA2;
break; 
case 4: RxData = cMIDI_clock && In_Filter_clock4 RA3;
break;
}
}
if TestBit(RCSTA, OERR) then
    begin
      ClearBit(RCSTA, CREN);
      SetBit(RCSTA, CREN);
    end;
    //ClearBit(PIR1, RCIF); // RCIF is read-only, can't reset it directly
  end;
end;

while (clockspeed case 1)
{
laisser passer data midi clock?
}

while (clockspeed case 2)
{
diviser par deux data midi clock?
}

while (clockspeed case 3)
{
diviser par 4 data midi clock?
}

while (clockspeed case 3)
{
diviser par 8 data midi clock?
}

cela a t il du sens?

[ACX]

C'est vrai, mais c'est insuffisant. La majorité des modules MIDI actuels n'envoient pas 0x80 comme Note Off mais une valeur de vélocité égale à 0.

[krikorola]

après plein de recherches j'ai finalement demandé conseil a Rémy du site de sonelec-musique.com, car je m'étais inspirer d'un de ses montages.
il a eu la gentillesse d'écrire le programme et de rajouter plusieurs division d'horloge, ce qui était assez simple pour lui vu le contenu de son site!

http://www.sonelec-musique.com/electron ... i_013.html" onclick="window.open(this.href);return false;

je vais tester cela cette semaine

[kkmalevitch]

Je relance le sujet car je me pose la question de savoir si il existe des boitiers clock divider déjà tout faits hors modulaire.
Il y a bien ça:



Mais je trouve le prix un peu élevé pour ce dont j'ai besoin (400€ ).

Je cherche en fait à synchroniser le séquenceur de mon Schlagzwerg à d'autres séquenceurs comme celui du Volca Bass.
Sur le Schlagzwerg il y a un choix de résolution de 96 ou 16 mais même en mettant celle-ci à 16 le tempo du Volca est quand même deux fois trop élevé.

J'ai essayé de mettre le Schlagzwerg en esclave mais son séquenceur ne démarre pas, il doit falloir aussi lui envoyer un signal start/stop pour que cela fonctionne.

J'aimerai savoir si il y a une solution peu couteuse pour remédier à ça sans passer par l'option fer à souder.

Merci pour vos avis.

[krikorola]

Tous les systèmes en vente sont chers, celui ci est même le moins cher je crois. le top pour cela est le ACME mais le prix est exorbitant.
Pour info le cicruit de sonelec music ne fonctionne pas.
j'ai un ami qui bosse sur un projet de ce type. l'idée etant de proposer une boite assez compacte et que l'on pourra faire evoluer un peu comme le midipal (ce dernier par contre ne peux pas modifier une clock entrante).

[kkmalevitch]

Merci pour la réponse, en effet le ACME n'est vraiment pas donné.
J'essaierai de me débrouiller autrement.
C'est quand même étrange que peu de constructeurs proposent ce genre de produits, il doit y avoir de la demande pour ça non?

En tout cas si ton ami arrive à finaliser son projet et le commercialise fais le nous savoir.