Jump to content

recherche CORE V3 fonctionnel


dubphil
 Share

Recommended Posts

Salut à tous,

Je recherche un CORE V3 assemblé et fonctionnel, ça fait depuis 2005 que j'essaye d'en fabriquer un, j'ai essayé avec 2 CORE de SmashTV et 1 CORE de Mike, même erreur :

je mesure 5V en amont de la résistance R9 et 3.8V juste en aval, j'ai bien tenté de débugger le truc avec un beep beep mais ça sonne de partout par exemple en faisant ce schéma : http://migratis.net/find_short.png (les traces noires sont reliées directement à la masse et les traces marrons sont reliées à la masse par l'intermédiaire d'un composant ça me parait logique que ça beep de partout (sauf les traces bleues mai là il y en a pas beaucoup) donc je ne vois pas du tout comment trouver un court circuit avec la méthode beep beep...

Bref pour ne pas avoir à tout jeter à la poubelle (potard, slider etc) vendez moi un CORE siouplait...

Merci d'avance

Philippe

Link to comment
Share on other sites

envoie le moi que je le teste

au fait une personne m'a proposé de me fabriquer un CORE donc j'ai accepté, mais je t'envoie quand même un des CORE de SmashTV car j'aimerai savoir ce qu'il en retourne au final. je te contacte par email pour tes coordonnées...

à mon avis, tu a dû monter un truc à l'envers.

ta chaine DIN/DOUT est elle ok ?

ah peut-être un truc que j'ai pas encore testé, n'oublie pas que tu t'adresses à un néophyte, alors je ne comprend pas trop ce que tu me demandes là.

Merci Julien !

Philippe

Link to comment
Share on other sites

en fait lorsque le CORE est nu (sans PIC et optocoupleur) connecté ni au DIN ni au DOUT ni au AIN j'ai J9:SI à ~4V.

Lorsque je rajoute PIC et optocoupleur et si je relie le J9:SI à la masse j'ai bien les 128 événements midi qui sont envoyés par le CORE.

Lorsque je branche le DIN (sans le DOUT) et que je relie n'importe quel pin de J3, de J4, de J5 ou de J6 à la masse aucun signal n'est émis par le PIC.

J'ai testé les courants sur le module DIN par dessous :

- j'ai bien 5V au Vdd

- si je relie J1:S0 (SI ? c'est écrit S0 sur le module DIN de SmashTV) ) à la masse j'ai bien les 128 évènements envoyés par le PIC

- si je mesure la tension à J1:S0 je retrouve bien mes 4V

- chose incroyable si je mesure les tensions aux pins QH des 74HC165N (dont le premier est relié à J1:S0) je mesure 5V

- par contre voilà ce que je trouve au niveau des bancs de résistances directement "collés" aux 74CH165N :

_________________

|-----|-----|-----|-----|-----|

^

5V 5V 4V 4V 4V 4V

- et pour les 4 autres connectés aux Jn :

_________________

|-----|-----|-----|-----|-----|

^

5V 4V 4V 4V 4V 4V

voilà, en fait j'ai t'on adresse dans un email, je t'envoie ça dès que je peux.

Merci encore !

Philippe

Edited by dubphil
Link to comment
Share on other sites

tu l'alimentes avec quoi ton core ? un pic sans lcd ça bouffe environ 50mA, un lcd peut necessiter jusqu'à 600mA et plus la chaine din est longue, plus y a de led et plus tu as besoin de puissance

un adaptateur 9V / 500mA ce serait donc ça !!??

Link to comment
Share on other sites

je viens de tester ton core v3 : il a l'air de marcher. j'y ai branché une chaine DIN avec des boutons, et ceux ci sont reconnus (appli AIN64DIN128DOUT128 en c)

l'écran marche, la connection midi in out aussi. perso je valide. faut plaquer les composants quand tu les soudes (j'ai fait du "ménage") et les soudures ne doivent pas avoir l'air de boules, mais de cones evasés (risque de soudure seches).

je te le renverrai des que possible (je déménage)

Link to comment
Share on other sites

salut

as tu vérifié toutes tes soudures sur les modules DIN ? As tu mis les resistances et condos en bout de chaine du module DIN? As tu mesuré la sortie de ton alim une fois tout connecté dessus hustoire de voir si cette derniere se "casse pas la gueule"

Pour infos je fais un tuto sur:

My link

Edited by henri
Link to comment
Share on other sites

Salut Henri,

as tu vérifié toutes tes soudures sur les modules DIN ? As tu mis les resistances et condos en bout de chaine du module DIN?

oui, j'ai fait le rapport de toutes les mesures 10 posts plus haut

As tu mesuré la sortie de ton alim une fois tout connecté dessus hustoire de voir si cette derniere se "casse pas la gueule"

Si je retrouve 5V avant R9, une fois tout connecté, ça peut quand-même dire que l'alim s'effondre ? ou ça veut dire que c'est ok ?

Sinon, à quels points doivent mesurer exactement ? avant le régulateur ?

Pour infos je fais un tuto sur:

My link

impressionnant ta machine, tu as usiné toit même le coffrage en bois ?

Merci

Philippe

Link to comment
Share on other sites

ça maaaaaarche!!!!!!!!!

vous allez me tuer : en fait sur le PCB du DINX4 de SmashTV, il a ajouté une petite astuce qui m'a complètement embrouillé, il a reporté les pins du J8 du CORE RC-SC-S0-Vdd-Vs pour permettre de connecter un DOUTX4 directement sur le DINX4 et moi comme un con je n'avais pas compris ça et connectait mon CORE J9 à ces pins, c'était les seuls ayant une légende faut dire, je pensais que les autres pins servait juste au connecteur. Cette partie là n'était pas très claire tout de même et cette histoire de ~4v mesuré m'a détourné du vrai problème. Merci beaucoup Julien la confirmation que le CORE n'y était pour rien m'a certainement donné le déclic pour trouver l'erreur.

Bon voilà finalement cette histoire de ~4V restera un mystère que je mettrai sur le compte de mon multimètre.

Maintenant un gros morceau m'attend, reprogrammer l'appli MB64 pour que mes 8 boutons lorsqu'ils sont appuyés mutent la piste controlée par le slider correspondant et éteint la LED correspondante.

Je ne manquerai pas de refaire un post si je n'y arrive pas tout seul :)

Merci encore !

Philippe

Link to comment
Share on other sites

Pour programmer c'est archis simple

Tu télécharges sur uccaaps l'aplication: MIOSStudio V2

Içi

Tu télécharges le fichier HEX correspondant a ta midibox64

Içi

Apres tout se passe par midi tu envoie les données au core par l'intermediaire de ta connection midi sur le PC.(Midi IN et OUT du CORE reliées au midi IN et OUT de ton PC)

Evite les interfaces MIDI bon marchées car elle ne laissent pas passer les sysex. perso j'ai un vieux PC avec un port RS232 et la c'est l'ideal.

Au fait quand tu vas allumer la premiere fois ton montage l'ecran n'affichera rien c'est notmal.

Balances les données via MIDI et dans la foulée le programme du core vas scanner tout ce qui est connectés sur les modules.

c'est magique..................

Edited by henri
Link to comment
Share on other sites

Apres tout se passe par midi tu envoie les données au core par l'intermediaire de ta connection midi sur le PC.(Midi IN et OUT du CORE reliées au midi IN et OUT de ton PC)

ok henri, ça je savais déjà, quand je parle de reprogrammer c'est coder un .asm qui réponde à mon besoin ;)

dis moi, me vendrais tu le core que tu m'as envoyé ?

Je te le vend pas, je te le donne, par contre si tu as des boutons en rab (10) qui lorsqu'on presse une fois envoi 0 et lorsqu'on presse une seconde fois envoi 127 je suis preneur ou alors un bouton qui reste enfoncé le courant passe et lorsqu'on re appuie dessus il remonte et le courant ne passe plus.

Pour l'instant je n'ai que des bouttons qu'il faut garder pressé pour que le courant passe.

En fait j'ai l'impression que la fonction mute qui parait évidente pour un contrôleur midi n'est pas implémenté dans une appli et que c'est pas évident à faire

exemple de ce que je veux : lorsque j'appuie 1 fois sur le bouton 1 la led 1 s'éteint le son s'arrête. Et d'une part si je re appuie sur le bouton le son reprend mais pas à fond; au niveau définit par le slider, la led se rallume. Et d'autre part si je bouge le slider la piste se "démute" et la led se rallume. Dans l'idéal ce deuxième comportement ne devrait pas se produire, je devrai pouvoir bouger le slider sans réactiver le son, pour le placer à un certain niveau puis seulement appuyer sur le bouton pour réactiver le son au nouveau niveau défini par la nouvelle position du slider. Mais je me doute un peu que ce n'est pas réalisable mais si oui alors comment ?

O LED 1

[_] bouton 1

|

|

|

[_] slider 1

|

|

|

Edited by dubphil
Link to comment
Share on other sites

merci pour le Core, je te renvoie les timbres

regarde la fonction Toggle de la midibox 64


sinon les boutons que tu cherches sont des TOGGLE SWITCH, ou inverseurs. Hong Kong super seller en vend pas cher sur ebay, des modeles qui coute une blinde en france en boutique


autrement, tu peux coder ça de la façon suivante, en partant d'une appli ain64din128dout128 : 

si le bouton mute est appuyé (1ere fois) , l'état mute est ON, j'envoie le msg 0

si le bouton mute est appuyé (2eme fois), l'état mute est OFF, j'envoie le msg 127, je lis la valeur du slider


l'état mute doit etre défini comme un char boolean, il ne peut donc avoir que deux état, 0 ou 1. quand j'appuie mute, j'ajoute +1 à la valeur du char mute ; du coup il oscille entre 0 et un. j'ai coder une appli dans le genre pour une télécommande multicanal


/////////////////////////////////////////////////////////////////////////////

// Variables

/////////////////////////////////////////////////////////////////////////////

unsigned char level;

//signed char level_mute;

unsigned char levelJ5A0;

unsigned char levelJ5A1;


/////////////////////////////////////////////////////////////////////////////

// Global variables

/////////////////////////////////////////////////////////////////////////////


// status of application (see bitfield declaration in main.h) :

app_flags_t app_flags; // display state


button_L_state_t button_L_state;

button_C_state_t button_C_state;

button_R_state_t button_R_state;

button_Ls_state_t button_Ls_state;

button_Sw_state_t button_Sw_state;

button_Rs_state_t button_Rs_state;

button_MUTE_state_t button_MUTE_state;

button_CAL_state_t button_CAL_state;


led_L_pin_state_t led_L_pin_state;

led_C_pin_state_t led_C_pin_state;

led_R_pin_state_t led_R_pin_state;

led_Ls_pin_state_t led_Ls_pin_state;

led_Sw_pin_state_t led_Sw_pin_state;

led_Rs_pin_state_t led_Rs_pin_state;

led_MUTE_pin_state_t led_MUTE_pin_state;

led_CAL_pin_state_t led_CAL_pin_state;


/////////////////////////////////////////////////////////////////////////////

// Gestion des LEDS et Relais

/////////////////////////////////////////////////////////////////////////////

void LED(void)  

{

      // 7eme LED MUTE reliÈe ‡ SR3-D1 (note midi 0x06 = F-1#)

      // DOUT pin in evnt1, value ON OFF in evnt2

      if (led_MUTE_pin_state.led_MUTE==1)

      {

      // allumage de la LED MUTE :

      MIOS_DOUT_PinSet(0x11, 1); // allumÈ SR3D1

      MIOS_DOUT_PinSet(0x01, 0); // allumÈ SR1D1

      MIOS_DOUT_PinSet(0x09, 1); // Èteint SR2D1 


      // muter TOUS les inter 4066 :

      MIOS_DOUT_PinSet(0x07, 1); // canal L (muted)

      MIOS_DOUT_PinSet(0x0f, 0); 


      MIOS_DOUT_PinSet(0x06, 1); // canal C

      MIOS_DOUT_PinSet(0x0e, 0);


      MIOS_DOUT_PinSet(0x05, 1); // canal R

      MIOS_DOUT_PinSet(0x0d, 0);


      MIOS_DOUT_PinSet(0x04, 1); // canal Ls

      MIOS_DOUT_PinSet(0x0c, 0);


      MIOS_DOUT_PinSet(0x02, 1); // canal Sw

      MIOS_DOUT_PinSet(0x0a, 0);


      MIOS_DOUT_PinSet(0x03, 1); // canal Rs

      MIOS_DOUT_PinSet(0x0b, 0);


      // Gestion des LEDS de canaux :

            // 1ere LED L reliÈe ‡ SR3-D7 (note midi 0x00 = C-1)

            if (led_L_pin_state.led_L==0){ // ALLUMÈ = ACTIVÈ

            MIOS_DOUT_PinSet(0x17, 1); // allumÈe SR3D7

            }else{//if (led_pin_state.led_L==0)

            MIOS_DOUT_PinSet(0x17,0); // Èteint SR3D7

            }

            // 2eme LED C reliÈe ‡ SR3-D6 (note midi 0x01 = C-1#)

            if (led_C_pin_state.led_C==0){

            MIOS_DOUT_PinSet(0x16, 1); // allumÈ SR3D6

            }else{

            MIOS_DOUT_PinSet(0x16,0); // Èteint SR3D6

            }

            // 3eme LED R reliÈe ‡ SR3-D5 (note midi 0x02 = D-1)

            if (led_R_pin_state.led_R==0){

            MIOS_DOUT_PinSet(0x15, 1); // allumÈ SR3D5

            }else{

            MIOS_DOUT_PinSet(0x15,0); // Èteint SR3D5

            }      

            // 4eme LED Ls reliÈe ‡ SR3-D4 (note midi 0x03 = D-1#)

            if (led_Ls_pin_state.led_Ls==0){

            MIOS_DOUT_PinSet(0x14, 1); // allumÈ SR3D4

            }else{

            MIOS_DOUT_PinSet(0x14,0); // Èteint SR3D4

            }          

            // 5eme LED Sw reliÈe ‡ SR3-D3 (note midi 0x04 = E-1)

            if (led_Sw_pin_state.led_Sw==0){

            MIOS_DOUT_PinSet(0x13, 1); // allumÈ SR3D3

            }else{

            MIOS_DOUT_PinSet(0x13,0); // Èteint SR3D3

            }           

            // 6eme LED Rs reliÈe ‡ SR3-D2 (note midi 0x05 = F-1)

            if (led_Rs_pin_state.led_Rs==0){

            MIOS_DOUT_PinSet(0x12, 1); // allumÈ SR3D5

            }else{

            MIOS_DOUT_PinSet(0x12,0); // Èteint SR3D5

            }



      }else{

      // extinction de la LED MUTE :

      MIOS_DOUT_PinSet(0x11,0); // Èteint SR3D6

      MIOS_DOUT_PinSet(0x01,1); // Èteint SR1D6

      MIOS_DOUT_PinSet(0x09,0); // allumÈ SR2D6


      // mise en place du fonctionnement des interrupteurs :

            led_L_pin_state.led_L=button_L_state.L; // retour Ètat prÈcÈdent

            led_C_pin_state.led_C=button_C_state.C;

            led_R_pin_state.led_R=button_R_state.R;

            led_Ls_pin_state.led_Ls=button_Ls_state.Ls;

            led_Sw_pin_state.led_Sw=button_Sw_state.Sw;

            led_Rs_pin_state.led_Rs=button_Rs_state.Rs;


            // 1ere LED L reliÈe ‡ SR3-D7 (note midi 0x00 = C-1) 

            if (led_L_pin_state.led_L==0){

            MIOS_DOUT_PinSet(0x17, 1); // allumÈe SR3D7

            MIOS_DOUT_PinSet(0x07, 0); // allumÈe SR1D6   

            MIOS_DOUT_PinSet(0x0f, 1); // Èteint SR2D6   

            }else{

            MIOS_DOUT_PinSet(0x17, 0); // Èteinte SR3D7

            MIOS_DOUT_PinSet(0x07, 1); // Èteint SR1D6

            MIOS_DOUT_PinSet(0x0f, 0); // allumÈ SR2D6

            }



            // 2eme LED C reliÈe ‡ SR3-D6 (note midi 0x01 = C-1#)

            if (led_C_pin_state.led_C==0){

            MIOS_DOUT_PinSet(0x16, 1); // allumÈ SR3D6

            MIOS_DOUT_PinSet(0x06, 0); // allumÈ SR1D6

            MIOS_DOUT_PinSet(0x0e, 1); // Èteint SR2D6

            }else{

            MIOS_DOUT_PinSet(0x16,0); // Èteint SR1D6

            MIOS_DOUT_PinSet(0x06,1); // Èteint SR3D6

            MIOS_DOUT_PinSet(0x0e,0); // allumÈ SR3D6

            }


            // 3eme LED R reliÈe ‡ SR3-D5 (note midi 0x02 = D-1)

            if (led_R_pin_state.led_R==0){

            MIOS_DOUT_PinSet(0x15, 1); // allumÈ SR3D5

            MIOS_DOUT_PinSet(0x05, 0); // allumÈ SR1D5

            MIOS_DOUT_PinSet(0x0d, 1); // Èteint SR2D5

            }else{

            MIOS_DOUT_PinSet(0x15,0); // Èteint SR3D5

            MIOS_DOUT_PinSet(0x05,1); // Èteint SR1D5

            MIOS_DOUT_PinSet(0x0d,0); // allumÈ SR2D5

            }


            // 4eme LED Ls reliÈe ‡ SR3-D4 (note midi 0x03 = D-1#)

            if (led_Ls_pin_state.led_Ls==0){

            MIOS_DOUT_PinSet(0x14, 1); // allumÈ SR3D4

            MIOS_DOUT_PinSet(0x04, 0); // allumÈ SR1D4

            MIOS_DOUT_PinSet(0x0c, 1); // Èteint SR2D4

            }else{

            MIOS_DOUT_PinSet(0x14,0); // Èteint SR3D4

            MIOS_DOUT_PinSet(0x04,1); // Èteint SR1D4

            MIOS_DOUT_PinSet(0x0c,0); // allumÈ SR2D4

            }


            // 5eme LED Sw reliÈe ‡ SR3-D3 (note midi 0x04 = E-1)

            if (led_Sw_pin_state.led_Sw==0){

            MIOS_DOUT_PinSet(0x13, 1); // allumÈ SR3D3

            MIOS_DOUT_PinSet(0x02, 0); // allumÈ SR1D4

            MIOS_DOUT_PinSet(0x0a, 1); // Èteint SR2D4

            }else{

            MIOS_DOUT_PinSet(0x13,0); // Èteint SR3D3

            MIOS_DOUT_PinSet(0x02,1); // Èteint SR1D4

            MIOS_DOUT_PinSet(0x0a,0); // allumÈ SR2D4

            }


            // 6eme LED Rs reliÈe ‡ SR3-D2 (note midi 0x05 = F-1)

            if (led_Rs_pin_state.led_Rs==0){

            MIOS_DOUT_PinSet(0x12, 1); // allumÈ SR3D5

            MIOS_DOUT_PinSet(0x03, 0); // allumÈ SR1D5

            MIOS_DOUT_PinSet(0x0b, 1); // Èteint SR2D5

            }else{

            MIOS_DOUT_PinSet(0x12,0); // Èteint SR3D5

            MIOS_DOUT_PinSet(0x03,1); // Èteint SR1D5

            MIOS_DOUT_PinSet(0x0b,0); // allumÈ SR2D5

            }



      }

// gestion de CALIBRATE : 

// 8eme LED CAL reliÈe ‡ SR3-D0 (note midi 0x07 = G-1)

      if (led_CAL_pin_state.led_CAL==1){

      MIOS_DOUT_PinSet(0x10, 1); // allumÈ SR3D0

      MIOS_DOUT_PinSet(0x08, 1); // allumÈ SR1D0

      MIOS_DOUT_PinSet(0x00, 0); // Èteint SR2D0

      }else{

      MIOS_DOUT_PinSet(0x10,0); // Èteint SR3D0

      MIOS_DOUT_PinSet(0x08,0); // Èteint SR1D0

      MIOS_DOUT_PinSet(0x00,1); // allumÈ SR2D0

      }

}  

/////////////////////////////////////////////////////////////////////////////

// Fonction LEVEL

/////////////////////////////////////////////////////////////////////////////

void LEVEL(void)

{

levelJ5A0 = (MIOS_AIN_Pin7bitGet(0)); // lecture des potard au dÈmarrage (Èvite "0")

levelJ5A1 = (MIOS_AIN_Pin7bitGet(1)); // lecture des potard au dÈmarrage (Èvite "0")


// remettre les lignes suivantes de code pour proto avec 2 potards :

// level = ((levelJ5A0)+((128+levelJ5A1+1)>>1)+128)+0; // ancienne formule OK pour proto julien


//  level = potard 0 - potard1

level = ((levelJ5A0)-(levelJ5A1)+15); // nlle formule OK pour proto julien


// rules return to zero s: 

if (level>(127+15))

level=0;

}  


/////////////////////////////////////////////////////////////////////////////

// This function is called by MIOS when an button has been toggled

// pin_value is 1 when button released, and 0 when button pressed

/////////////////////////////////////////////////////////////////////////////

void DIN_NotifyToggle(unsigned char pin, unsigned char pin_value) __wparam

{

// send pin number and value as Note On Event

    MIOS_MIDI_BeginStream(); // Bit start

switch( pin ) 

  {


    case 5: // 1ere touche L reliÈ ‡ SR1-D5

      if (pin_value==0 ){

      (button_L_state.L ++);

      (led_L_pin_state.led_L++);

      // MIOS_DOUT_PinSet(0x01, 1); 

      }

      // RxTx command

      MIOS_MIDI_TxBufferPut(0x90);

      MIOS_MIDI_TxBufferPut(0x00);

      MIOS_MIDI_TxBufferPut(pin_value ? 0x00 : 0x7f);


      break;



    case 4: // 2eme touche C reliÈ ‡ SR1-D4

      if (pin_value==0 ){

      (button_C_state.C ++);

      (led_C_pin_state.led_C++);

      // MIOS_DOUT_PinSet(0x01, 1); 


      }


      MIOS_MIDI_TxBufferPut(0x90);

      MIOS_MIDI_TxBufferPut(0x01);

      MIOS_MIDI_TxBufferPut(pin_value ? 0x00 : 0x7f);


      break;


 etc ...

Edited by julienvoirin
Link to comment
Share on other sites

ok cool ça ça va bien m'aider, merci Julien.

en fait en faisant des recherches sur toggle switch et inverseurs je suis tombé sur mes boutons :

boutons DIGITAST

donc ça va faire l'affaire il va falloir que je trouve comment les souder pour les rendre "push-push"

je vous tient au courant !

A+

Philippe

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
 Share

×
×
  • Create New...