julienvoirin

So i have dig into "watchdog" and this is certainly that that reset the pic, because the midi in buffer is filled more than 2 sec, which stop the mios loop (clrwdt at the end of loop) i haven't yet tried to modify the code

Bingo ! thanks :flowers: in GM5 app : // ========================================================================== unsigned char EEPROM_CONTENT_Write(void) __wparam { - unsigned char error = 0; - unsigned char addr; - unsigned char *ptr; - unsigned char addr_dscr_interface; - unsigned char addr_dscr_endpoints; - - // determine pointer to interface descriptor - addr_dscr_interface = USBDSC_CFG[0]; - if( USBDSC_CFG[addr_dscr_interface+1] != DSCR_INTRFC ) - return 0x40;// interface descriptor at wrong position - addr_dscr_interface += ((unsigned char)USBDSC_CFG&0xff); - - // determine pointer to endpoint descriptor - addr_dscr_endpoints=0; - for(addr=0; addr<0xff;) { - if( USBDSC_CFG[addr+1] == DSCR_ENDPNT ) { - addr_dscr_endpoints = addr; - break; - } - addr += USBDSC_CFG[addr+0]; - } - - if( !addr_dscr_endpoints ) { - return 0x41; // endpoint descriptor not found - } - addr_dscr_endpoints += ((unsigned char)USBDSC_CFG&0xff); - - - // ensure that verify mode is enabled - MIOS_BOX_CFG1.BS_DIS_VERIFY=0; - - // select CS#0, block0 - MIOS_BOX_CFG1.BS_A=0; - edit : bold in code snippet not possible :getlost: But .. I don't understand the link between the 2 things : it shouldn't have a relationship :twitch: ?!

LOL he looks like me on wake up :rofl: thanks for your tips. I have a scope (20Mhz like at school), but i will access it in few days

euhh :ermm: MacBook-de-Julien-VOIRIN:~ julienvoirin$ sdcc --version SDCC : mcs51/gbz80/z80/avr/ds390/pic16/pic14/TININative/xa51/ds400/hc08 2.8.0 #5117 (Mar 23 2008) (Mac OS X i386) MacBook-de-Julien-VOIRIN:~ julienvoirin$ We both agree that PrintHex2 is OK ? MIOS_LCD_CursorSet(20+11); MIOS_LCD_PrintCString("error"); MIOS_LCD_PrintHex2(error); MIOS_LCD_MessageStart(TMP_MSG); Respectful regards btw : all those code examples and small applications are a delight for newbie programmer like me, a bit like virtual "Lego" bricks

Hello Boxers ! I am coding an application in C that request a dump of 100 patches from a synth Each patch is sent every 132ms, one after another Patch is 275 bytes. Only 134 bytes are useful to describe the patch, the rest is checksum and sysex tag A sysex parser has been developed and works good with ONE patch the 134 bytes are then written onto Bankstick I've tried an automated algoryhtm to directly write the 100x134 bytes in Bankstick but PIC reset : it goes too fast. So, i'd like to measure the time that does each task According to ucapps website, writing the banksick takes 30 ms (3 pages of 64 bytes) But what about the rest ? ///////////////////////////////////////////////////////////////////////////// // see: http://wolzow.mindworks.ee/analog/m1k-midi-spec.htm // edit buffer received f0 10 06 01 <patch num> <patch data> <checksum> f7 // // xx yy data, sent nybblewise: // a data byte dd is sent as xx=dd&0x0F; yy=(dd>>4)&0x0F // cc checksum: // the sum of the original data bytes dd, masked with 0x7F. ///////////////////////////////////////////////////////////////////////////// // faire une boucle avec k = 0 .. 99 ; à chaq tour de boucle on ecrit le patch // à l'adresse k ///////////////////////////////////////////////////////////////////////////// // this functin doesn't work : Matrix1000 dumps too fast to write // only the 1st patch is saved, 2nd is buggy, the rest is out ///////////////////////////////////////////////////////////////////////////// void MIDI_HandleBankDump(unsigned char byte) { //appelle une sorte de "handle edit buffer" unsigned char program_received; // will be used to write is K static unsigned char editbufferstatus; static unsigned char firstnibble; static unsigned char ebparam; static unsigned char lsb; static unsigned char bytecount; unsigned char error = 0; unsigned char checksum = 0; if(program_received < 99) { switch(editbufferstatus) { case 0: if(byte == 0xf0) //premier byte envoyé par m1000 editbufferstatus = 1; else editbufferstatus = 0; break; case 1: if(byte == 0x10) ///2eme byte envoyé par m1000, mfg editbufferstatus = 2; else editbufferstatus = 0; break; case 2: if(byte == 0x06) ///3eme byte, correspond à "M1000/M6", code machine editbufferstatus = 3; else editbufferstatus = 0; break; case 3: if(byte == 0x01) editbufferstatus = 4; ///single patch data else editbufferstatus = 0; break; case 4: if(byte == program_received) // notice patch number (0-99) { editbufferstatus = 5; lsb = 1; ebparam = 0; program_received = byte; } else{ editbufferstatus = 0; } break; case 5: // voice data if(ebparam < 134) // 134 = number of voice parameter bytes { if(lsb == 1) // first nibble, least significant byte { firstnibble = (byte & 0x0f); lsb = 0; } else // second nibble, most significant byte { EditBuffer[ebparam] = (byte << 4) + firstnibble; EditBufferOrig[ebparam] = (byte << 4) + firstnibble; lsb = 1; // reset ebparam++; } } else // status 6 checksum skip to 7 { editbufferstatus = 7; checksum = byte; } break; case 7: // sysex end if(byte == 0xF7){ editbufferstatus = 0; UpdateDinStates(); Write_Patch_To_BS(uBS_uBank, program_received); // write received patch program_received ++; // ready for next patch } else{ error = byte; editbufferstatus = 0; } break; } } else{ MIDI_ReceivingBank = 0; // tag "end of receiving a bank" #if DEBUG MIOS_LCD_CursorSet(0xc0 +8); MIOS_LCD_PrintCString("finished !"); MIOS_LCD_MessageStart(TMP_MSG); #endif } } //////////////////////////////////////////////////////////////////////////////////////// // Receiving a whole bank, patch one by one : reboot PIC ! too much received data at once ////////////////////////////////////////////////////////////////////////////////////////// void MIDI_RequestPatch_onebyone(unsigned char bank, unsigned char ubank) { unsigned char k; MIDI_SendPatchBank(bank); while( k < 99){ ProgramNumberReq = k; MIDI_SendPatchProgram( k); MIOS_Delay(10); MIDI_RequestEditBuffer(k); MIOS_Delay(60); Write_Patch_To_BS(ubank, k); MIOS_Delay(130); //program_request_1b1++; k++; } #if DEBUG MIOS_LCD_CursorSet(0xc0 +8); MIOS_LCD_PrintCString("finished !"); MIOS_LCD_MessageStart(TMP_MSG); #endif } ///////////////////////////////////////////////////////////////////////////// // This function returns a byte from patch structure in RAM ///////////////////////////////////////////////////////////////////////////// unsigned char PATCH_ReadByte(unsigned char addr) { return patch_structure[addr]; } ///////////////////////////////////////////////////////////////////////////// // This function writes a byte into patch structure in RAM ///////////////////////////////////////////////////////////////////////////// void PATCH_WriteByte(unsigned char addr, unsigned char byte) { patch_structure[addr] = byte; } ///////////////////////////////////////////////////////// // This function read a patch stored into BS // This function loads the patch structure from EEPROM/BankStick // Returns != 0 if Load failed (e.g. BankStick not connected) //////////////////////////////////////////////////////// unsigned char PATCH_Load(unsigned char bank, unsigned char patch) { unsigned char i; #if PATCH_USE_BANKSTICK // determine offset depending on patch number unsigned int offset = (patch << 7) + 7; // default : patch << 8 unsigned char error = 0; // select BankStick MIOS_BANKSTICK_CtrlSet(bank & 0x07); // use 64byte page load functions for faster access for(i=0; i<3; ++i) error = MIOS_BANKSTICK_ReadPage(offset + i*0x40, (char *)(patch_structure + i*0x40)) ; #if DEBUG if (error == 0x02){ MIOS_LCD_CursorSet(20+11); MIOS_LCD_PrintCString("no BS"); MIOS_LCD_PrintHex2(error); MIOS_LCD_MessageStart(TMP_MSG); }else{ MIOS_LCD_CursorSet(20+11); MIOS_LCD_PrintCString("error"); MIOS_LCD_PrintHex2(error); MIOS_LCD_MessageStart(TMP_MSG); } MIOS_LCD_CursorSet(0xc0 +11); MIOS_LCD_PrintCString("_LoadBS"); MIOS_LCD_MessageStart(TMP_MSG); #endif #else // ignore patch and bank // use 64byte page load functions for faster access for(i=0; i<3; ++i) MIOS_EEPROM_ReadPage(i*0x40, (char *)(patch_structure + i*0x40)); #if DEBUG MIOS_LCD_CursorSet(0xc0 +11); MIOS_LCD_PrintCString("_LoadEE"); MIOS_LCD_MessageStart(TMP_MSG); #endif #endif return 0; } ////////////////////////////////////////////////////////////////////////////////////////////////////// // This function stores the patch structure into EEPROM/BankStick // Returns != 0 if Store failed (e.g. BankStick not connected) /////////////////////////////////////////////////////////////////////////////////////////////////////// unsigned char PATCH_Store(unsigned char bank, unsigned char patch) { unsigned char i; #if PATCH_USE_BANKSTICK // determine offset depending on patch number unsigned int offset = (patch << 7) + 7 ; // default : offset = patch << 8 unsigned char error = 0; // select BankStick MIOS_BANKSTICK_CtrlSet(bank & 0x07); // use 64byte page write functions for faster access for(i=0; i<3; ++i) error = MIOS_BANKSTICK_WritePage(offset + i*0x40, (char *)(patch_structure + i*0x40)) ; #if DEBUG if (error == 0x02){ MIOS_LCD_CursorSet(20+11); MIOS_LCD_PrintCString("no BS"); MIOS_LCD_PrintHex2(error); MIOS_LCD_MessageStart(TMP_MSG); }else{ MIOS_LCD_CursorSet(20+11); MIOS_LCD_PrintCString("error"); MIOS_LCD_PrintHex2(error); MIOS_LCD_MessageStart(TMP_MSG); } MIOS_LCD_CursorSet(0xc0 +11); MIOS_LCD_PrintCString("_StoreBS"); MIOS_LCD_MessageStart(TMP_MSG); #endif #else // ignore patch and bank // use 64byte page write functions for faster access for(i=0; i<3; ++i) MIOS_EEPROM_WritePage(i*0x40, (char *)(patch_structure + i*0x40)); #if DEBUG MIOS_LCD_CursorSet(0xc0 +11); MIOS_LCD_PrintCString("_StoreEE"); MIOS_LCD_MessageStart(TMP_MSG); #endif #endif return 0; } ///////////////////////////////////////////////////////////////////////////// /// read a patch from a BS ///////////////////////////////////////////////////////////////////////////// void Read_Patch_From_BS(unsigned char bank, unsigned char patch) { unsigned char j; PATCH_Load(bank, patch); for (j=0; j<134; j++){ EditBuffer[j] = patch_structure[j]; } #if DEBUG MIOS_LCD_CursorSet(0xc0); MIOS_LCD_PrintCString("Read_Patch"); MIOS_LCD_MessageStart(TMP_MSG); #endif } ///////////////////////////////////////////////////////////////////////////// /// write a patch to a BS ///////////////////////////////////////////////////////////////////////////// void Write_Patch_To_BS(unsigned char bank, unsigned char patch) { unsigned char j; for (j=0; j<134; j++){ patch_structure[j] = EditBuffer[j]; // ok ça marche :) } PATCH_Store(bank, patch); #if DEBUG MIOS_LCD_CursorSet(0xc0); MIOS_LCD_PrintCString("Write_Patch"); MIOS_LCD_MessageStart(TMP_MSG); #endif } Thanks in advance if you 've some trick Best regards Julien

ahhhhhh OK :thumbsup: the error is 0x40. Do you know where i can find something about Bankstick error definitions ? I didn't find anything relative to 40h ; only 00h, 01h and 02h are mentioned both on website nor MIOS svn sources. There is an error in the SysEx string outputted but as it doesn't affect the sound, it isn't a problem. It seems being a problem relative to the 8 first bytes of EditBuffer[0 .. 7] that code the program name. As the Matrix 1000 firmware doesn't store those patchnames (it stores 134 bytes into 96 bytes if i well remember), it doesn't stress me.

Problem solved !!! thanks Nils for your details, it did help to remember me "if you don't understand this code line, don't use it !!" I am a bit dummy :ike: I removed return error; from if( error = MIOS_BANKSTICK_WritePage(offset + i*0x40, (char *)(patch_structure + i*0x40)) ) return error; and it solved my problem !!! If somebody knows what 'return error' is supposed to do, I would be less dummy :yes:

Dear Boxers, I've got a very strange problem. I've enhanced a custom by JackChaos to control Oberheim Matrix 1000. Jackchaos uses the internal memory of the matrix to store the patch. I did change so that I can store patches into banksticks. Each patch is an SysEx array of 275 bytes. It starts with the classic F0 and end with F7. The data are described in EditBuffer, 134 bytes, then controlled by a checksum. If I compile my code using EEPROM, everything works as expected. The only drawback is that i can only store one patch, internal PIC EEPROM is too small. // 0: use EEPROM, 1: use BankStick as patch storage :: WORK w/ EEPROM :) #define PATCH_USE_BANKSTICK 0 By expected i mean : get the patch from the matrix, store it is PIC memory, power off the hardware, then power on and recall the patch by transmiting a sysex which is complete : F0 10 06 0d 00 <EditBuffer> checksum F7 If I compile using BankStick, it works too so long I haven't power on (reboot) the controller. If I power off/on, then it doesnt do the bitshift by 4 : // transmit the parameter value MIOS_MIDI_TxBufferPut(EditBuffer[i] & 0x0f); MIOS_MIDI_TxBufferPut((EditBuffer[i] >> 4) & 0x0f); the bitshifting is always 00, obvious it shouldn't be :wacko: You will easily understand that it's annoying, as the bankstick are supposed to be ROM, not RAM. Sending EditBuffer : ///////////////////////////////////////////////////////////////////////////// // Send the edit buffer ///////////////////////////////////////////////////////////////////////////// void SendEditBuffer() { unsigned char i; unsigned char checksum = 0; MIOS_MIDI_InterfaceSet(device);// set IIC interface MIOS_MIDI_BeginStream(); MIOS_MIDI_TxBufferPut(0xf0); // begin sysex header MIOS_MIDI_TxBufferPut(0x10); // mfg MIOS_MIDI_TxBufferPut(0x06); // device MIOS_MIDI_TxBufferPut(0x0d); // voice data to edit buffer 0x0d MIOS_MIDI_TxBufferPut(0x00); // zero #if sysex_format_oberheim // 134 patch bytes for(i = 0; i < 134; i++) { // transmit the parameter value MIOS_MIDI_TxBufferPut(EditBuffer[i] & 0x0f); MIOS_MIDI_TxBufferPut((EditBuffer[i] >> 4) & 0x0f); checksum += EditBuffer[i] ; } # else // other checksum version (relative to TK Sysex management two nibbles) // 134 patch bytes for(i = 0; i < 134; i++) { // transmit the parameter value MIOS_MIDI_TxBufferPut(EditBuffer[i] & 0x0f); checksum += EditBuffer[i] & 0x0f; MIOS_MIDI_TxBufferPut(EditBuffer[i] >> 4); checksum += EditBuffer[i] >> 4; } #endif MIOS_MIDI_TxBufferPut(checksum & 0x7f); MIOS_MIDI_TxBufferPut(0xf7); MIOS_MIDI_EndStream(); MIOS_MIDI_InterfaceAutoSet(); // switch back to default interface #if DEBUG // debug MIOS_LCD_CursorSet(20); MIOS_LCD_PrintCString("CSUM:"); MIOS_LCD_PrintHex2(checksum); MIOS_LCD_MessageStart(156); #endif } the memo.h, defining the functins to store into bankstick/eeprom ///////////////////////////////////////////////////////////////////////////// // global definitions ///////////////////////////////////////////////////////////////////////////// // 0: use EEPROM, 1: use BankStick as patch storage :: WORK w/ EEPROM :) #define PATCH_USE_BANKSTICK 0 #define DEBUG 1 // 0: no debug, 1: debug in memo.c (directly inspired by an example of TK for sysex in mios 8bits): ///////////////////////////////////////////////////////// // This function read a patch stored into BS // This function loads the patch structure from EEPROM/BankStick // Returns != 0 if Load failed (e.g. BankStick not connected) //////////////////////////////////////////////////////// unsigned char PATCH_Load(unsigned char bank, unsigned char patch) { unsigned char i; #if PATCH_USE_BANKSTICK // determine offset depending on patch number unsigned int offset = patch << 8; unsigned char error; // select BankStick MIOS_BANKSTICK_CtrlSet(bank & 0x07); // use 64byte page load functions for faster access for(i=0; i<3; ++i) if( error = MIOS_BANKSTICK_ReadPage(offset + i*0x40, (char *)(patch_structure + i*0x40)) ) return error; if (error){ MIOS_LCD_CursorSet(10); MIOS_LCD_PrintCString("error"); MIOS_LCD_MessageStart(128); } #if DEBUG MIOS_LCD_CursorSet(20); MIOS_LCD_PrintCString("Patch_LoadBS"); MIOS_LCD_MessageStart(128); #endif #else // ignore patch and bank // use 64byte page load functions for faster access for(i=0; i<3; ++i) MIOS_EEPROM_ReadPage(i*0x40, (char *)(patch_structure + i*0x40)); #if DEBUG MIOS_LCD_CursorSet(20); MIOS_LCD_PrintCString("Patch_LoadEE"); MIOS_LCD_MessageStart(128); #endif #endif return 0; } ////////////////////////////////////////////////////////////////////////////////////////////////////// // This function stores the patch structure into EEPROM/BankStick // Returns != 0 if Store failed (e.g. BankStick not connected) /////////////////////////////////////////////////////////////////////////////////////////////////////// unsigned char PATCH_Store(unsigned char bank, unsigned char patch) { unsigned char i; #if PATCH_USE_BANKSTICK // determine offset depending on patch number unsigned int offset = patch << 8 ; // default : offset = patch << 8 unsigned char error; // select BankStick MIOS_BANKSTICK_CtrlSet(bank & 0x07); // use 64byte page write functions for faster access for(i=0; i<3; ++i) if( error = MIOS_BANKSTICK_WritePage(offset + i*0x40, (char *)(patch_structure + i*0x40)) ) return error; if (error){ MIOS_LCD_CursorSet(10); MIOS_LCD_PrintCString("error"); MIOS_LCD_MessageStart(128); } #if DEBUG MIOS_LCD_CursorSet(20); MIOS_LCD_PrintCString("Patch_StoreBS"); MIOS_LCD_MessageStart(128); #endif #else // ignore patch and bank // use 64byte page write functions for faster access for(i=0; i<3; ++i) MIOS_EEPROM_WritePage(i*0x40, (char *)(patch_structure + i*0x40)); #if DEBUG MIOS_LCD_CursorSet(20); MIOS_LCD_PrintCString("Patch_StoreEE"); MIOS_LCD_MessageStart(128); #endif #endif return 0; } ///////////////////////////////////////////////////////////////////////////// /// read a patch from a BS ///////////////////////////////////////////////////////////////////////////// void Read_Patch_From_BS(unsigned char bank, unsigned char patch) { unsigned char j; PATCH_Load(bank, patch); for (j=0; j<134; j++){ EditBuffer[j] = patch_structure[j]; } #if DEBUG MIOS_LCD_CursorSet(0xc0); MIOS_LCD_PrintCString("Read_Patch"); MIOS_LCD_MessageStart(128); #endif } ///////////////////////////////////////////////////////////////////////////// /// write a patch to a BS ///////////////////////////////////////////////////////////////////////////// void Write_Patch_To_BS(unsigned char bank, unsigned char patch) { unsigned char j; for (j=0; j<134; j++){ patch_structure[j] = EditBuffer[j]; // ok ça marche :) } PATCH_Store(bank, patch); #if DEBUG MIOS_LCD_CursorSet(0xc0); MIOS_LCD_PrintCString("Write_Patch"); MIOS_LCD_MessageStart(128); #endif } And finally an extract of the UI : switch (SoftPanel.Button) { case DIN_PAGE: SoftPanel.Page = SOFT_PAGE2; break; case SOFT_EDIT_5: // patch set Read_Patch_From_BS(uBS_uBank, uBS_uPatch); // to get EditBuffer[i] //MIDI_SendPatchBank(uBS_uBank); // set bnk and program for 'single patch data' //MIDI_SendPatchProgram(uBS_uPatch); //SendSinglePatchData(uBS_uPatch); // the newly stored sound will be recalled into edit buffer SendEditBuffer(); /// change edit buffer SoftPanel.Selected_MatrixBus = MMOD_BUS1; break; case SOFT_EDIT_4: // save Write_Patch_To_BS(uBS_uBank, uBS_uPatch); break; case SOFT_EDIT_3: // request editbuffer MIDI_SendPatchBank(BankNumber); MIDI_SendPatchProgram(ProgramNumber); MIDI_RequestSinglePatch(ProgramNumber); //MIDI_RequestEditBuffer(ProgramNumber); break; So nothing very exotic, as newbee in Code, i've understood everything. :tongue: The only thing that borrow me is : #if PATCH_USE_BANKSTICK // determine offset depending on patch number unsigned int offset = patch << 8 ; // default : offset = patch << 8 unsigned char error; I don't understand why shifting by 8 ?? I link (at least i've tried but seems to fail) the full sources, but beware, it is a very huge program ! If somebody has an idea , I would be plenty respectful to this personne :sweat: Best regards Julien MatrixBoxSource_JV_beta v0.33.zip

yesss you need to configure it inside code source and recompile it there is a line which specify what AOUT module you want to use

It tooks me 4 days, but I DID IT !!! now it reads and writes into bankstick :thumbsup: Some enhancements need to be done, but here is what you can do with it : - get single patch from matrix 1000 and store them inside bankstick (8 BS, each having 100 patches) - load a patch from bankstick, update EditBuffer (so that the LFO leds blink at the good rate for example), tweak it and resave it into bankstick Then the Matrix1000 is only a sound player, all is managed by the Chaos Matrix :rolleyes: still a beta code, UI needs to be improved. I 've added several pages to Patch management. If somebody see a good manner to dump a whole bank (100 patches) directly into Bankstick , i am interested. It can be done into void MIDI_HandleEditBuffer(unsigned char byte) of midi.c but it is a little bit hardcore for my poor experience of selfmade coder EDIT : v0.31 et v0.32 are buggy for bankstick save. beta v0.33 is OK MatrixBoxSource_JV_beta v0.33.zip

I well understand. So just consider I need 100 pieces of P300-S-096-D6-N It is very kind of you to help me to get those desired knobs. Tell me when you need me to pay them

Wilba : DEAL ! :thumbsup: reference is P300-S-096-D6-N thanks a lot PS : some extra samples of P300-S-096-D6-S and P300-S-068-D6-N would be cool it is the colour of Oberheim Matrix6, as i am enhancing the controller developed by JackChaos

Patrick, your code is just amazing ! everything so well documented and clevery thought ! i :heart: you i've just understood the trick with MIDI_ReceivingEditBuffer=1, inserted into ProgramChange function, relating to MProc_ReceivedEvnt into MIDI_HandleEditBuffer() : whahahah :ike: excellent !

thnaks guys for your help :thumbsup: reference of the Re'an : P300-S-096-D6-N a quote is always good to know i've found an ebay auction where the guy says it should work for D shaft, obvious designed for rounded :geek: i will try as it costs only 11 euros I haven't found flexifit ; a picture ?

thanks for your help i've asked to Neutrik France some help (a dealer in fact) i can't find back the ebay seller ; do you remember his nickname ? And yes there has been a group buy some years ago, but for encoder knobs. Now i need Potentiometer knob :P

of course it works ! the edit buffer is working as it is the one you've developped ! :whistle: i test each stuff with one matrix for audio, and analyse every internal and i2c out for MIDI it is based on ultracore (a core+ 8bankstick+4 IIC modules, all on one PCB)

DONE ! i2c out only as the programmer will manage patches data DONE ! tonight it reads and writes into eeprom, writes into bankstick ; tomorrow i will implement read from bankstick the programmer can ask a patch dump from the matrix1000, then you choose in what bankstick memory it goes (8x100 patches, later 2x8x100 patches) DONE ! using a sort of router algorithm (event of 1st channel routed to 1st i2c and so on ..) 4 buttons allow you to edit 4 matrix 1000 independantly next enhancement will be 4 EditBuffers for each matrix :thumbsup: thanks again to jackchaos :heart: for his so well structured code ! lots of useful functions are implemented and useful for enhancement and thanks to the genius who created "SysEx Dump Demonstration (and template)" :ahappy: very useful to read/write into BS

Dear Boxers I am heavily looking for a very specific soft touch knob part : it must fit D Shaft (North oriented) potentiometers It is manufactured by Re'an under reference P300. It's the blue one on the pic attached below. Your help in finding a supplier is very welcome ; I need 23 pieces minimum (some extra are always good), ideally 100 pieces. Best regards Julien

a ready to go ethernet module for less than 15€, just rearrange the cable between core32 and eth not tested but i bought a similar model some years ago, and it works very well today :thumbsup: eth module

I also had this problem months ago ... not yet updated since

CV panel offered to a parisian. still the Seq backpanel to get, for free

I'd like to exchange a Smash TV DOUTX4 module, soldered, ready to go against an unsoldered Smash TV module DOUTx4 on Paris (even just the PCB) In fact i bought it to someone who had already soldered the resistors (220 ohms) but i need 1K or 2K cause I am using ultrabright LEDs My module is perfect for somebody who use standard diffused LEDs Exchange is less boring for me than desoldering and is a manner to discuss with another midiboxer about his projects :geek:

those on x0xb0x are good, but mono. maybe a stereo model exists ..

did you have a look to a monome app called "soyuz" (like satellite) ?