Click Track to MIDI Clock converter

Update:

Unfortunately the JamMan Stereo looper also sends the looped/overdubbed audio to the Rhythm Output which means that after the first audio data is recorded into an empty loop location the Rhythm output will also be outputting the loop audio and the sync circuit won’t sync properly anymore. So the only other source for a sync signal is the TEMPO/STOP LED. I think I’ll just solder a wire to it and route it to the outside of the case and connect it to the sync circuit. The code will need to be changed/simplified a bit.

End update.

Click track to MIDI clock DIY converter circuit Ver.1.0

This circuit is designed to generate MIDI clock messages from incoming audio pulses from e.g. a click track, in my case it is the rhythm output of a Digitech JamMan Stereo looper. The audio clicks should be shorter than 150 milliseconds, not overlap each other and preferably with a fast attack. The tempo range is 40 to ca. 240 BPM.

The firmware for the 1.0 version was written for a Atmega328p MCU so it should also work with the m168/88/48 chips. The code came out a bit complex since I wanted to build a circuit with the least amount of components. I have another version of the converter which has simpler and shorter code but has more external components. I might make a blog entry about it later on.

Mode of operation:

At startup the converter waits for the first incoming audio click after which is starts counting and waiting for the second click. At the moment of the second click the converter divides the time between the first and second clicks by 24 and starts sending MIDI clock, i.e. goes into “pulsed” mode.

If the second click is not detected within ca. 1.5 seconds (tempo slower than 40BPM) the converter goes back to the beginning.

The MIDI start switch (press and hold)  can be used to send a MIDI start message right before the next audio click, this will set the receiving MIDI device to start playback from the beginning of the sequence therefore syncing the MIDI device with the audio clicks.

If audio clicks stop then the converter goes into “Free Running” mode, i.e. it will continue to send MIDI clock without incoming audio clicks. While in “Free Running” mode the MIDI start switch is not operational.

If audio clicks resume the converter goes back to pulsed mode.

If the tempo changes a reset is needed to re-calculate the tempo.

Bigger size image:

Circuit info:

The circuit diagram does not have all connections shown. You’ll have to connect the common/ground from the audio device to the ground of the MCU, Arduino or whatever board you have, in my case it’s a Arduino Pro Mini with a m328p MCU and a 16MHz crystal. You’ll also have to connect Vcc to a 5V power supply and add a 16MHz crystal oscillator plus the capacitors and maybe a decoupling if you’re building the circuit from scratch.

Components:

D1 and D2 – Clamping diodes,. I used 1n4148.
R1 – Pull Down resistor. 10K but you can try other values
R2 and R3 form a voltage divider.
R2 – 10K Ohms
R3 – 300 Ohms (can be replaced with a potentiometer)
R4 – 220 Ohms, current limiting.
R6 – Current limiting resistor. Value depends from the LED type.
S1 – tactile switch
C1 – debouncing cap, 0.1uF
R5 – safety resistor, can be left out of the circuit.

Get the code here: https://github.com/ambinaut/click-track-to-MIDI-clock-converter

Here’s a video of an almost identical circuit. The difference is the  MCU and that it uses more components. Click track to MIDI clock demonstration

Roland VSR-880 Song Name utility

This small program uses SysEx messages to change the Name of the currently loaded song in a Roland VSR-880 multi-track recorder.

http://www.rolandus.com/products/vsr-880/

Roland VSR-880 Song Name Utility

The program does not use MIDI device/ports, rather serial ports. You’ll need an USB to TTL converter with FTDI or CH340G chip-set.

Download here: http://ge.tt/1mfiudi2

Digitech JamMan Stereo sync circuit with 555 timer

Here is a circuit that generates a pulse that can be used with the JamMans foot-switch input (tempo tap) to set the tempo. It’s simpler than the circuit based on Schmitt triggers from here: https://ambinaut.wordpress.com/2014/01/09/synchronizing-a-digitech-jamman-stereo-to-an-arion-um-70-metronome/

R1, R4: depends on the opto-coupler. I’ve use an LT827 and 180 Ohm resistors.
D1:  1n4148 or just about any kind of diode.
SW1: optional switch for manual tempo tapping.
R2: Value is not critical, I’ve used a 10K resistor.
Rt and Ct values depend on the desired pulse length. You can use the following graph:

A 100mS pulse should be long enough for most JamMan rhythm out sounds. As long as the 555 pulse is longer than the input sound/beep/etc. it should work ok.

You could also use the following online calculator:
http://www.circuitsgallery.com/2012/11/555-monostable-calculator.html

the LED with the resistors Rled, Rbase and NPN transistor Q1 are optional.
Rled value depends from the type of LED used.
Rbase depends on the type of transistor. I’ve used a general purpose 2n3904 with a 1K Rbase resistor if I remember correctly. (I only had the circuit on a breadboard and have taken it  apart a while ago).

You could probably omit the transistor and Rbase and just connect the LED and Rled directly to the 555 timer output, because it can sink up to 200mA (according to the datasheet). So that’s more than enough to drive the LED and the opto-coupler internal LED.

Ccv: 0.1uF
Cdc: optional decoupling cap, 0.1 to 10uF should be ok.
SW2: use to send the pulses to the JamMan
TRS jack diodes: 1n4148

Digitech JamMan stereo MIDI sync

UPDATE: I modified the first circuit to work with the new code that has an interrupt enabled. See the bottom of the page.

---

I’ve previously posted two circuits for synchronizing the JamMan, one based on Schmitt triggers and another one using a 555 timer.

This time the circuit syncs the JamMan to an external MIDI clock. The circuit is based on an Attiny85 MCU running at 8MHz (internal oscillator) using the SoftwareSerial.h library included with the Arduino IDE. The circuit+code seems to work good with just midi clock data coming in, without too many other types of messages being received simultaneously, i.e. I’m not sure how it will handle a big stream of midi data, if it will be able to properly discern between clock and other messages.

When the circuit detects midi clock messages on the input it will blink the tempo LED every 1/4 note, i.e. every 24th clock message. Pressing the tap tempo switch will send the 1/4 pulses to the JamMan.

Here’s the 1.0 version of the circuit:

Digitech JamMan stereo looper synchronization to MIDI clock

And the code:

https://gist.github.com/ambinaut/3dfc054652405e5d1872

or:

/* This sketch listens to incoming midi clock messages on port RX and pulses output tempo_pin each quarter note,
i.e. every 24th clock tick

Written for Attiny85 but can be modified for other Atmega, Attiny MCU’s

IMPORTANT! Don’t use pins RX, TX for anything else othar than the SoftwareSerial library
*/

#include <avr/io.h>     //Include the headers that handles Input/Output function for AVR chips
#include <util/delay.h> //Include the headers that allow for a delay function
#include <SoftwareSerial.h>  //Arduino Software Serial library

#define F_CPU 8000000UL //Define the speed the clock is running at.  Used for the delay.h functions
#define tempo_pin 1 //Physical pin 6, or PB1 on the Attiny85

byte midi_msg = 0; //stores incoming midi messages, only 1 byte needed, real time msgs are one byte long
byte clockpulse = 0; //stores current midi clock tick number
unsigned long last_midi_event_time = 0; //time of the last incoming midi event

SoftwareSerial mySerial(3, 4); // RX, TX Physical pins 2, 3

void init_io(void)
{
DDRB |= _BV(tempo_pin); //sets tempo_pin as outputs
PORTB &= ~(_BV(tempo_pin)); //sets the pin to LOW
}

int main(void)
{
init_io();
init();
mySerial.begin(31250);

while (1) {  //endless loop

if (mySerial.available()) {
midi_msg = mySerial.read();
last_midi_event_time = millis();
midi_clk_to_pulse(); //see below
}
//if there’s no more incoming midi for longer than 1000ms, set tempo_pin LOW
else   {
unsigned long current_time = millis() – last_midi_event_time;
if (current_time > 1000){
midi_msg = 0xFC; //midi stop message
last_midi_event_time = 0;
midi_clk_to_pulse();
}
}
} //END while (1) – endless (main) loop
}

void midi_clk_to_pulse(){

switch(midi_msg) {

case 0xFC: //midi stop message
clockpulse = 0;
PORTB &= ~(_BV(tempo_pin)); //sets tempo_pin to LOW
break;

case 0xFA: //midi start message
clockpulse = 0;
PORTB &= ~(_BV(tempo_pin)); //sets tempo_pin to LOW
break;

case 0xF8: //midi clock pulse
clockpulse = clockpulse + 1;
switch (clockpulse){
case 1:
PORTB |= (_BV(tempo_pin)); //tempo_pin HIGH
break;

case 8:
PORTB &= ~(_BV(tempo_pin)); //tempo_pin LOW
break;

case 24: // second quarter begin
PORTB |= (_BV(tempo_pin)); //tempo_pin HIGH
break;

case 32:
PORTB &= ~(_BV(tempo_pin)); //tempo_pin LOW
break;

case 48: // third quarter begin, middle of the measure
PORTB |= (_BV(tempo_pin)); //tempo_pin HIGH
break;

case 56:
PORTB &= ~(_BV(tempo_pin)); //tempo_pin LOW
break;

case 72: //fourth quarter begin
PORTB |= (_BV(tempo_pin)); //tempo_pin HIGH
break;

case 80:
PORTB &= ~(_BV(tempo_pin)); //tempo_pin LOW
break;

case 96:
clockpulse = 0; // resets the clock pulse counter, 96 pulses = 1 measure in 4/4
break; //END case 0xF8:
} // END switch (clockpulse)
break;
} // END switch(midi_msg)
} //END midi_clk_to_pulse()

According to the SoftwareSerial library explanation the Attiny has to run at 8MHz for it to function properly so don’t forget to set the right fuses accordingly. The only thing to take in consideration is that the clock could drift with temperature differences and that might affect serial communication, perhaps even stop it from reading incoming data correctly. I might do another circuit with an external crystal but then the circuit will have to be changed since you need two pins to connect the external crystal.

Any comments or suggestions are welcome,
have fun!

---

UPDATE: The new code has a sleep function. If there is no MIDI signal going into the input for longer than one sec the Attiny goes into sleep mode to save power. An interrupt on pin7 disables sleep mode when data starts coming in again.

DigiTech JamMan MIDI sync circuit

The code with the added sleep mode:

 

 

/*

This sketch listens to incoming midi clock messages on port RX and pulses output tempo_pin each quarter note, i.e. every 24th clock tick

 

Written for Attiny85 but can be modified for other Atmega, Attiny MCU’s

 

IMPORTANT! Don’t use pins RX, TX for anything else other than the SoftwareSerial library

*/

 

#include <avr/io.h>     //Include the headers that handles Input/Output function for AVR chips

#include <util/delay.h> //Include the headers that allow for a delay function

#include <SoftwareSerial.h> //Arduino Software Serial library

#include <avr/sleep.h> // Lib for sleep modes

#include <avr/interrupt.h> //Lib for interrupts

 

#define F_CPU 8000000UL //Define the speed the clock is running at.

#define tempo_pin 1 //Physical pin 6, or PB1 on the Attiny85

 

byte midi_msg =0;//stores incoming midi messages, only 1 byte needed, real time msgs are one byte long

byte clockpulse =0;//stores current midi clock tick number

unsignedlong last_midi_event_time =0;//time of the last incoming midi event

 

SoftwareSerial mySerial(3,4);// RX, TX Physical pins 2, 3

 

void init_io(void)

{

     DDRB |= _BV(tempo_pin);//set tempo_pin

     PORTB &=~(_BV(tempo_pin));//set the pin to LOW        

}

 

int main(void)

{

     init_io();   

     init();

     mySerial.begin(31250);

    

     while(1){//endless loop

 

          if(mySerial.available()){

              midi_msg = mySerial.read();

              last_midi_event_time = millis();

              midi_clk_to_pulse();//see below               

          }        

//if there’s no more incoming midi for longer than 1000ms, set tempo_pin LOW

          else   {

              unsignedlong current_time = millis()–                                                     last_midi_event_time;

              if(current_time >1000){        

                   midi_msg =0xFC;//midi stop message

                   last_midi_event_time =0;

                   midi_clk_to_pulse();

                  sleep();                         

              }

          }   

     }//END while (1) – endless (main) loop

}

 

void midi_clk_to_pulse(){

             

     switch(midi_msg){

 

          case0xFC://midi stop message

              clockpulse =0;

              PORTB &=~(_BV(tempo_pin));//turns tempo_pin off

          break;

                  

          case0xFA://midi start message

              clockpulse =0;

              PORTB &=~(_BV(tempo_pin));//turns tempo_pin off

          break;

                  

          case0xF8://midi clock pulse

              clockpulse = clockpulse +1;

              switch(clockpulse){

                   case1:

                   PORTB |=(_BV(tempo_pin));//tempo_pin HIGH

                   break;

                       

                   case8:

                   PORTB &=~(_BV(tempo_pin));//tempo_pin LOW

                   break;

                       

                   case24:// second quarter begin

                   PORTB |=(_BV(tempo_pin));//tempo_pin HIGH

                   break;

                       

                   case32:

                   PORTB &=~(_BV(tempo_pin));//tempo_pin LOW

                   break;

                       

                   case48:// third quarter begin, middle of the measure

                   PORTB |=(_BV(tempo_pin));//tempo_pin HIGH

                   break;

                       

                   case56:

                   PORTB &=~(_BV(tempo_pin));//tempo_pin LOW

                   break;

                       

                  

                   case72://fourth quarter begin

                   PORTB |=(_BV(tempo_pin));//tempo_pin HIGH

                   break;

                       

                   case80:

                   PORTB &=~(_BV(tempo_pin));//tempo_pin LOW

                   break;

                       

                   case96:

                   clockpulse =0;// resets the clock pulse counter, 96 pulses = 1 measure in 4/4

              break;//END case 0xF8:

          }// END switch (clockpulse)

          break;                 

     }// END switch(midi_msg)

}//END midi_clk_to_pulse()

 

void sleep(){

 

   GIMSK |= _BV(PCIE);                     // Enable Pin Change Interrupts

   PCMSK |= _BV(PCINT2);                   // Use PB2 as interrupt pin

   ADCSRA &=~_BV(ADEN);                   // ADC off

   set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // replaces above statement

 

   sleep_enable();                         // Sets the Sleep Enable bit in the MCUCR Register (SE BIT)

   sei();                                 // Enable interrupts

   sleep_cpu();                           // sleep

 

   cli();                                 // Disable interrupts

   PCMSK &=~_BV(PCINT2);                 // Turn off PB2 as interrupt pin

   sleep_disable();                       // Clear SE bit

   ADCSRA |= _BV(ADEN);                   // ADC on

 

   sei();                                 // Enable interrupts

}// sleep

 

Atmega48-20pu setting (clock speed) fuse low byte

The following is a small tutorial on how to set low fuse byte to modify the clock speed of a factory fresh Atmega48-20pu microprocessor. Be careful because a mistake could disable the reset pin on the chip and you won’t be able to program it anymore unless you have a high voltage programmer to reprogram the reset pin bit.

I’ve used a cheap USBASP programmer clone bought from Chinese eBay.

First check the initial factory fuse settings with avrdude.exe. From the command line use a variation (depends from your setup)  of the following statement, make sure that you are in the directory where avrdude.exe is located before you run it:

avrdude -B 8.0 -c usbasp -P usb -p m48 -v -v -v –v

-B 8.0 the Bitclock setting is used to slow down the programmer. This is needed because the Atmega48 initially runs at 1MHz and is therefore to slow for the programmer. After you increase the Atmega48 operating frequency you won’t need this option anymore. Values other than 8.0 can be used.

-c usbasp specifies programmer type, I’m using a cheap USBASP v2.0 programmer I got on eBay. Note that many of these USBASP programmers are shipped with older firmware and could give clk and perhaps other errors when you try to program the Atmega48, or other MCU’s. I had to upgrade mine, here is a detailed tutorial: http://www.rogerclark.net/?p=702

-P usb is the connection port of the usb programmer

-p m48 indicates the microchip type, m48 stands for Atmega48

-v -v -v –v is for verbal response i.e. avrdude is going to show what it’s doing

If it’s a brand new un-programmed chip from the factory you should get the following values for the low, high and extended fuse bytes:

avrdude: Device signature = 0x1e9205
avrdude: safemode read 1, lfuse value: 62
avrdude: safemode read 2, lfuse value: 62
avrdude: safemode read 3, lfuse value: 62
avrdude: safemode: lfuse reads as 62
avrdude: safemode read 1, hfuse value: df
avrdude: safemode read 2, hfuse value: df
avrdude: safemode read 3, hfuse value: df
avrdude: safemode: hfuse reads as DF
avrdude: safemode read 1, efuse value: 1
avrdude: safemode read 2, efuse value: 1
avrdude: safemode read 3, efuse value: 1
avrdude: safemode: efuse reads as 1

avrdude: safemode read 1, lfuse value: 62
avrdude: safemode read 2, lfuse value: 62
avrdude: safemode read 3, lfuse value: 62
avrdude: safemode: lfuse reads as 62
avrdude: safemode read 1, hfuse value: df
avrdude: safemode read 2, hfuse value: df
avrdude: safemode read 3, hfuse value: df
avrdude: safemode: hfuse reads as DF
avrdude: safemode read 1, efuse value: 1
avrdude: safemode read 2, efuse value: 1
avrdude: safemode read 3, efuse value: 1
avrdude: safemode: efuse reads as 1
avrdude: safemode: Fuses OK

If you get some other values it does not really matter unless there is a fuse setting that won’t allow further fuse programming, e.g. if the SPIEN (Table 28-6, Bit no. 5) fuse has been set to 1*, i.e. un-programmed, which means that you won’t be able to use SPI to program the chip anymore and you’ll need a parallel programmer to reprogram the SPIEN fuse.

* Fuse programming uses inverted logic, i.e. 0 = Yes, programmed and 1 = No, un-programmed.

As you can see the low fuse byte has a hexadecimal value of 62 which in binary is 01100010, this is the initial factory setting as shown in Table 28-7.

Bit no. 7 (CKDIV8) divides the frequency of the currently selected clock source (Bits no. 0 – 3) by 8. The initial clock source ist the internal RC oscillator set at 8.0MHz., so CKDIV8 is reducing the Atmegas speed to 1MHz.

Bit no. 6 (CKOUT) allows the system clock to be output on PORTB0.

Bits 5 and 4 (SUT 1, 0) select the start-up time of the chip. Table 9-9 on page 34 of the datasheet shows us that the initial fuse setting 10 selects the „slowly rising power“ option.

Bits 3- 0 (CKSEL 3 – 0) select the clock source. The initial value of 0010 corresponds to the calibrated internal RC oscillator (see Table 9-1, p. 28 and Table 9-8, p. 34).

Now we’ll use another command line statement to change the values in the low fuse byte. First let’s disable the clock divider, i.e. unprogram Bit no. 7 (CKDIV8), set it to 1. We just need to change the fuse low byte value from 0110 0010 to 1110 0010, or from 0x62 to 0xE2 in hexadecimal. This is the command line statement:

avrdude -c usbasp -p m48 -B 8 -v -v -v -v -U lfuse:w:0xe2:m

-U lfuse:w:0xe2:m tells avrdude to write 0xe2 to the fuse low byte.

When you run this you should get text feedback in the command line window.

Now try to read the fuses again:

avrdude -B 8.0 -c usbasp -P usb -p m48 -v -v -v –v

you should get:

avrdude: Device signature = 0x1e9205
avrdude: safemode read 1, lfuse value: e2
avrdude: safemode read 2, lfuse value: e2
avrdude: safemode read 3, lfuse value: e2
avrdude: safemode: lfuse reads as E2
avrdude: safemode read 1, hfuse value: df
avrdude: safemode read 2, hfuse value: df
avrdude: safemode read 3, hfuse value: df
avrdude: safemode: hfuse reads as DF
avrdude: safemode read 1, efuse value: 1
avrdude: safemode read 2, efuse value: 1
avrdude: safemode read 3, efuse value: 1
avrdude: safemode: efuse reads as 1

avrdude: safemode read 1, lfuse value: e2
avrdude: safemode read 2, lfuse value: e2
avrdude: safemode read 3, lfuse value: e2
avrdude: safemode: lfuse reads as E2
avrdude: safemode read 1, hfuse value: df
avrdude: safemode read 2, hfuse value: df
avrdude: safemode read 3, hfuse value: df
avrdude: safemode: hfuse reads as DF
avrdude: safemode read 1, efuse value: 1
avrdude: safemode read 2, efuse value: 1
avrdude: safemode read 3, efuse value: 1
avrdude: safemode: efuse reads as 1
avrdude: safemode: Fuses OK

As you can see only the low fuse byte was changed.

Now let’s select an external crystal oscillator as the clock source. As an example lets take a 16MHz crystal, according to Table 9-1, p.28 we can choose between two settings:

1. Low power crystal oscillator
2. Full swing crytal oscillator

In my case I want to use the Atmega48 with an external PSU so I need not worry about power consumption so I will choose the second setting. The frequency range is 0.4 – 20MHz. Note that the Full Swing Crystal Oscillator will only operate for VCC = 2.7V – 5.5V.

According to Table 9-1, there are two settings for the Full Swing Crystal Oscillator, 0111 and 0110, the only difference is in CKSEL0 bit, i.e. Bit no. 0 of the fuse low byte (Table 28-7).

We’ll use slow rise power setting so CKSEL0 to 1 and SUT 1, 0 to 11, as seen in Table 9-6, p.32.

So we’ll need to change the fuse low byte to 0b11110111 or 0xF7 in hexadecimal. The command line statement fort hat is:

avrdude -c usbasp -p m48 -B 8 -v -v -v -v -U lfuse:w:0xF7:m

From now on the Atmega48 will be using the external crystal oscillator to run at 16MHz. If needed you can always reprogram the chip to run at other frequencies.

Binary | Hex (precede with 0x)
0000 | 0
0001 | 1
0010 | 2
0011 | 3
0100 | 4
0101 | 5
0110 | 6
0111 | 7
1000 | 8
1001 | 9
1010 | A
1011 | B
1100 | C
1101 | D
1110 | E
1111 | F Examples:
0110 0100 = 0x64 = 100(in decimal)
1111 1111 = 0xFF = 255(in decimal)
0000 0001 = 0x01 = 1(in decimal)

A test sketch that will blink a led on PORTB5 (physical pin 19). The led should blink in one second intervals, i.e. one second ON, one second OFF.

#define F_CPU 16000000UL //Define the speed the clock is running at. Used for the delay.h functions

#include <avr/io.h> //Include the headers that handles Input/Output function for AVR chips
#include <util/delay.h> //Include the headers that allow for a delay function

//Prototypes

void init_io(void);

void init_io(void) //initialize the chip, like void setup() in Arduino
{
DDRB = (_BV(5)); // PORTB5 (physical pin 19) as output
}

int main(void)
{
init_io();

for (;;) { //Loop forever
PORTB ^= (_BV(5)); //invert PORTB5
_delay_ms(1000); //one second delay
}

}

For this code to work with Arduino IDE you’ll need to have the Atmega48 definition in the boards.txt file in the arduino directory.

##############################################################

atmega48_57KBaud_16MHz.name= ATmega48 – 16Mhz

atmega48_57KBaud_16MHz.upload.protocol=avrisp
atmega48_57KBaud_16MHz.upload.maximum_size=4094
atmega48_57KBaud_16MHz.upload.speed=57600
atmega48_57KBaud_16MHz.upload.using=USBasp

atmega48_57KBaud_16MHz.build.mcu=atmega48
atmega48_57KBaud_16MHz.build.f_cpu=16000000L
atmega48_57KBaud_16MHz.build.core=arduino
atmega48_57KBaud_16MHz.build.variant=standard

##############################################################

Hopefully this tutorial has been helpful for you. Suggestions welcomed.

Logitech LS21 stereo sub-woofer combo 50 hz mains hum in audio signal

50 hz mains hum in the speaker output of a Logitech LS21 LS 21 stereo sub-woofer combo.

The amplification circuit of this combo has the following problems:

-poor transformer placement (induces hum into the sub-woofer speaker)
-no voltage regulator in the circuit (mains 50 hz ripple goes amplified to the output of the amplifier circuit)
-case is glued together (had to use an oscillation tool to cut open the case).

 

the underside of the sub-woofer:

removing the sub speaker shows how close the transformer is placed to the speaker, inducing the 50hz mains hum.

the amplifier PCB. No voltage regulator included.

I un-soldered the rectifier diodes in order to attach my DIY voltage regulator + capacitor PCB.

This is what the audio output of the amplifier looks like when it is off.

When turned on. As you can see the 50hz mains hum is not smoothed out by the capacitors on the amplifier PCB.

So I decided to insert a (7809) 9V voltage regulator and a 25V 2200µF capacitor between the rectifying diodes and the rest of the amplifiers circuit.

The voltage regulator was getting a bit warm so I added an improvised heat sink.

The finished regulator/cap combo.

The backside of the sub-woofer was glued to the case, so I had to use force and an oscillation tool to open it.

The transformer was removed.

The regulator/cap combo attached to the rectifier diodes.

A DC power-in jack attached to the backside. I had to drill a hole in it and use hot glue to fixate the DC jack.

The transformer was mounted to a little piece of ply wood and latter fixated with 2 screws to the underside of my PC table.

Synchronizing a Digitech JamMan Stereo to an Arion UM-70 metronome

Ok, here is the final version of the circuit. I’ve used a lower value capacitor with a higher value resistor, this way the lag between input and output is reduced.

The final circuit:

Parts:
Opto-C = LTV827
R1 = 180 Ω
R2 = 10K Ω
R3 = 47K Ω
R4 = 180 Ω
R5 = 300 Ω
All diodes = 1N4148
Cap C1= 1 µF
1 LED
and 4 Schmitt trigger gates, the 2 unused gate inputs are tied to ground.

SW1 is for the UNDO/REDO function of the JamMan
SW2 is for sending/stopping the pulses

I omitted a switch for the reverse function since I don’t use it.

The white RCA connector is used for the UNDO/REDO function, the red for the signal from the metronome.
The USB connector is used only for power. The 1/4″ stereo socket is the output.

In action:

Here is a more detailed image of the circuit:

the values of the resistors and the capacitor depend on the input signal wave shape and voltage.

Important! Use optical isolation between the output of the circuit and the tap tempo input of the JamMan.

I’ve used the following values:

Opto-C = LTV827
R0 = 180 Ohm
R1 = 10K
R2 = 4.7K
D1 Diode (reverse voltage protection) = 1N4007
Diode = 1N4148
Cap = 22µF
and 3 Schmitt trigger gates

The following are scope shots of input, output waves and samples from other points in the circuit:

Sample1 is the output of the metronome. As you can see it’s an AC square wave.

and zoomed in:

and scope shots of samples from other points in the circuit:

and here is the output signal:

input and output superimposed:

metronome pulse to tap tempo on Digitech Jamman Stereo

This is  circuit for setting the tempo on a Digitech JamMan Stereo.  The opto-coupler input is connected to a beeping metronome.

More info coming l8r.