Big Button gate length

Well sure, it’s waiting! I’m sorry, why does the gate need to be longer, is the gate not long enough for the envelope generator to detect?

1 Like

Yes, that is basically the problem.
Ill post the code this afternoon…

Ok then Caustic and others…,

the reason the pulse is too short is that I am using it to triger events via an LDR, in a setup that is functionally an ‘open DIY vactrol.’ This is for audio-visual performance reasons and I fully get it that a plain ol cable works fine, its just not what I’m doing…

so the code I used is one that uses internal pull-ups instead of hte original with the external pulldowns. It just seemed sensible, except of course now I have a slightly ;‘non-standard’ hardware setup.

I got the code from this conversation, posted by fg Mar 24 2019:

https://modwiggler.com/forum/viewtopic.php?t=215301

So, direct from the archive, this is the code I have right now:

/* 
avrdude -c usbtiny -p m328p 
-U flash:w:code_b_b.hex
-U lfuse:w:0xe2:m  
-U hfuse:w:0xd9:m 
-U efuse:w:0xff:m 
-U lock:w:0xff:m 
*/

// CLOCK IN pin 2
// BANK BUTTON select Pin 8 .... each channel has 2 banks of patterns, so you can record 2 alternative patterns and go between with this button
// CLEAR BUTTON pin 9 .... this clears the whole loop sequence
// FILL BUTTON pin 10, push this and it will continuously play the channel your on, doesnt record, push it and twist the select knob to make a fill!
// RESET BUTTON pin 6 you can add a button or a jack!
// DELETE BUTTON pin 7 This deletes the step your on
// OUTPUT 1 ... pin 3
// OUTPUT 2 ... pin 4
// OUTPUT 3 ... pin 5
// OUTPUT 4 ... pin 11
// OUTPUT 5 ... pin 12
// OUTPUT 6 ... pin 13
// CHANNEL select Analog pin (A0)
// STEP LENGTH analog pin 1 (A1)
// SHIFT KNOB Analog pin (A2)
// LED (big button LED) pin 17 (A3)
// BIG BUTTON is pin 18 (A4)

// LED LOOP is pin 19 (A5) // expe


int buttonPushCounter = 0;   // counter for the number of button presses
volatile int buttonState = LOW;         // current state of the button
int lastButtonState = 0;     // previous state of the button
int RecordButtonState = 0;
int LastRecordButtonState = 0;
int DeleteButtonState = 0;
int LastDeleteButtonState = 0;
int ClearButtonState = 0;

//Clock Reset Keepers
int ClockKeep = 0;
int ResetSteps = 33;

//RESET BUTTON
int ResetButton = 6;
int ResetButtonState = 0;
int LastResetButtonState = 0;

int CHANNELSELECT = 0;

//FILL BUTTON
int FillButton = 10;
int FillButtonState = 0;
int Fill1 = 0;
int Fill2 = 0;
int Fill3 = 0;
int Fill4 = 0;
int Fill5 = 0;
int Fill6 = 0;

//CLEAR
int ClearState = 0;

//Bank Button Latching
long time = 0;
long debounce = 150;
int ButtonBankSelectState[7];
int BankState[7] = {LOW,LOW,LOW,LOW,LOW,LOW,LOW};
int Bankprevious[7] = {HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH};

int BankArrayShift1 = 0;
int BankArrayShift2 = 0;
int BankArrayShift3 = 0;
int BankArrayShift4 = 0;
int BankArrayShift5 = 0;
int BankArrayShift6 = 0;
int BankClear = 0;
int BankRecord = 0;
int BankArrayNumber = 0;
int ButtonBankSelectButton = 0;

//SHIFT KNOB
int KnobValue = 0;
int BankPush1 = 0;
int BankPush2 = 0;
int BankPush3 = 0;
int BankPush4 = 0;
int BankPush5 = 0;
int BankPush6 = 0;
int KnobVal = 0;
int OldKnobValue = 0;
int NewKnobValue = 0;
int NewKnobValue1 = 0;
int NewKnobValue2 = 0;
int NewKnobValue3 = 0;
int NewKnobValue4 = 0;
int NewKnobValue5 = 0;
int NewKnobValue6 = 0;

#define TOLERANCE 0

int looper = 0;          
int Channel = 1;         
int ClockState = 0;            //clock state stuff
int StepLength = 0;           //What the pot uses for step length
int steps = 0;              //beginning number of the steps in the sequence adjusted by StepLength

const int clkIn = 2;
int ButtonBankSelect = 8;
int ButtonClear = 9;         //reset button for the moment
int ButtonDelete = 7;
int BigButton = 18;  // A4

int ChannelSelectState1 = 0;
int ChannelSelectState2 = 0;
int ChannelSelectState3 = 0;
int ChannelSelectState4 = 0;
int ChannelSelectState5 = 0;
int ChannelSelectState6 = 0;

int OUT1 = 3;
int OUT2 = 4;
int OUT3 = 5;
int OUT4 = 11;
int OUT5 = 12;
int OUT6 = 13;
int BankLED = 17;
int LedDebut = 19; // expe

int Sequence[14][43] = {
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
};  //sequence array 1

void setup()
{
  pinMode(OUT1,OUTPUT);
  pinMode(OUT2,OUTPUT);
  pinMode(OUT3,OUTPUT);
  pinMode(OUT4,OUTPUT);
  pinMode(OUT5,OUTPUT);
  pinMode(OUT6,OUTPUT);
  pinMode(BankLED, OUTPUT);
  pinMode(LedDebut, OUTPUT); // expe

  pinMode(clkIn,INPUT);
  pinMode(ResetButton,INPUT);
  
  pinMode(ButtonBankSelect,INPUT_PULLUP);
  pinMode(BigButton,INPUT_PULLUP);
  pinMode(ButtonDelete,INPUT_PULLUP);
  pinMode(ButtonClear,INPUT_PULLUP);
  pinMode(FillButton,INPUT_PULLUP);

int StepLength = map (analogRead(1), 0, 1023, 0, 18);

if(StepLength <= 2)
{steps = 8;}
if((StepLength >2) && (StepLength <= 6))
{steps = 12;}
if((StepLength > 6) && (StepLength <=11))
{steps = 16;} 
if((StepLength > 11) && (StepLength <=16))
{steps = 24;} 
if((StepLength > 16) && (StepLength <=18))
{steps = 32;} 
  
//making sure it starts up knowing where the knob is

CHANNELSELECT = analogRead(0); //not 2?
attachInterrupt(0, isr, RISING);
}

void loop()
{
RecordButtonState = digitalRead(BigButton);
DeleteButtonState = digitalRead(ButtonDelete);
ClearButtonState = digitalRead(ButtonClear); 
ResetButtonState = digitalRead(ResetButton);
FillButtonState = digitalRead(FillButton);
ButtonBankSelectState[BankArrayNumber] = digitalRead(ButtonBankSelect);//These setup the states of the buttons

  {if(buttonState == HIGH) {

    looper    = (looper+1);
    BankPush1 = (BankPush1+1);
    BankPush2 = (BankPush2+1);
    BankPush3 = (BankPush3+1);
    BankPush4 = (BankPush4+1);
    BankPush5 = (BankPush5+1);
    BankPush6 = (BankPush6+1);
    ClockKeep = (ClockKeep+1);
    
    digitalWrite(OUT1,Sequence       [1+BankArrayShift1][BankPush1 + NewKnobValue1] || (Fill1));
    digitalWrite(OUT2,Sequence       [2+BankArrayShift2][BankPush2 + NewKnobValue2] || (Fill2));
    digitalWrite(OUT3,Sequence       [3+BankArrayShift3][BankPush3 + NewKnobValue3] || (Fill3));
    digitalWrite(OUT4,Sequence       [7+BankArrayShift4][BankPush4 + NewKnobValue4] || (Fill4));
    digitalWrite(OUT5,Sequence       [8+BankArrayShift5][BankPush5 + NewKnobValue5] || (Fill5));
    digitalWrite(OUT6,Sequence       [9+BankArrayShift6][BankPush6 + NewKnobValue6] || (Fill6));
    delay(1); // 10 ?
    digitalWrite(OUT1,LOW);
    digitalWrite(OUT2,LOW);
    digitalWrite(OUT3,LOW);
    digitalWrite(OUT4,LOW);
    digitalWrite(OUT5,LOW);
    digitalWrite(OUT6,LOW);
    buttonState = LOW;
  } 
  else 
  {
    looper = looper;
    ClockKeep = ClockKeep;
  }
}

if(RecordButtonState != LastRecordButtonState)
{
     if((RecordButtonState == LOW) && (Channel == 1)) {
                                                         Sequence[Channel+BankRecord][BankPush1+1+NewKnobValue1] = 1;}
else if((RecordButtonState == LOW) && (Channel == 2)) {
                                                         Sequence[Channel+BankRecord][BankPush2+1+NewKnobValue2] = 1;}
else if((RecordButtonState == LOW) && (Channel == 3)) {
                                                         Sequence[Channel+BankRecord][BankPush3+1+NewKnobValue3] = 1;}
else if((RecordButtonState == LOW) && (Channel == 7)) {
                                                         Sequence[Channel+BankRecord][BankPush4+1+NewKnobValue4] = 1;}
else if((RecordButtonState == LOW) && (Channel == 8)) {
                                                         Sequence[Channel+BankRecord][BankPush5+1+NewKnobValue5] = 1;}
else if((RecordButtonState == LOW) && (Channel == 9)) {
                                                         Sequence[Channel+BankRecord][BankPush6+1+NewKnobValue6] = 1;}                                                                                                                  



  delay (1); // 5 ?
}                                                                   //RECORD BUTTON

                                        //This bit is the clock in and step advance stuff

 {
  if((ClockKeep == 1)  || (ClockKeep == 5) || (ClockKeep == 9)  || (ClockKeep == 13) ||  (ClockKeep == 17)  || (ClockKeep == 21) || (ClockKeep == 25) || (ClockKeep == 29) && (BankRecord == 0)) 
       {
     digitalWrite(BankLED,HIGH);
     } 
   }
 {
   if((ClockKeep == 1)  || (ClockKeep == 5) || (ClockKeep == 9)  || (ClockKeep == 13) ||  (ClockKeep == 17)  || (ClockKeep == 21) || (ClockKeep == 25) || (ClockKeep == 29) && (BankRecord == 3)) {digitalWrite(BankLED,LOW);}
 else {
   digitalWrite(BankLED, BankState[BankArrayNumber]);
   }
   }

if(ButtonBankSelectState[BankArrayNumber] == LOW && Bankprevious[BankArrayNumber] == HIGH && millis() - time > debounce)
{
if(BankState[BankArrayNumber] == HIGH) 
{
BankState[BankArrayNumber] = LOW;
}
else 
{
BankState[BankArrayNumber] = HIGH;
time = millis();
}
}                                                                                               
    //Bank button state making it latch and stuff
KnobVal = analogRead(2);
if (0<KnobVal)   { KnobValue = 0;}
if (127<KnobVal) { KnobValue = 1;}
if (254<KnobVal) { KnobValue = 2;}
if (383<KnobVal) { KnobValue = 3;}
if (511<KnobVal) { KnobValue = 4;}
if (638<KnobVal) { KnobValue = 5;}
if (767<KnobVal) { KnobValue = 6;}
if (895<KnobVal) { KnobValue = 7;}
if (1000<KnobVal){ KnobValue = 8;}

int diff = abs(KnobValue - OldKnobValue);

if((diff > TOLERANCE) && (ChannelSelectState1 == HIGH))
{ NewKnobValue1 = KnobValue;
  OldKnobValue = KnobValue;
  }     
if((diff > TOLERANCE) && (ChannelSelectState2 == HIGH))
{ NewKnobValue2 = KnobValue;
  OldKnobValue = KnobValue;
  }  
if((diff > TOLERANCE) && (ChannelSelectState3  == HIGH))
{ NewKnobValue3 = KnobValue;
  OldKnobValue = KnobValue;
  }
if((diff > TOLERANCE) && (ChannelSelectState4  == HIGH))
{ NewKnobValue4 = KnobValue;
  OldKnobValue = KnobValue;
  }
if((diff > TOLERANCE) && (ChannelSelectState5  == HIGH))
{ NewKnobValue5 = KnobValue;
  OldKnobValue = KnobValue;
  }
if((diff > TOLERANCE) && (ChannelSelectState6  == HIGH))
{ NewKnobValue6 = KnobValue;
  OldKnobValue = KnobValue;
  } //lots of the shit with that shift knob!!!! MEMORY STUFF
   

{CHANNELSELECT = analogRead(0);
if(20>CHANNELSELECT)   {(ChannelSelectState1 = HIGH); (ChannelSelectState2 = LOW); (ChannelSelectState3 = LOW); (ChannelSelectState4 = LOW); (ChannelSelectState5 = LOW);  (ChannelSelectState6 = LOW);}
if(170<CHANNELSELECT) {(ChannelSelectState1 = LOW); (ChannelSelectState2 = HIGH); (ChannelSelectState3 = LOW); (ChannelSelectState4 = LOW); (ChannelSelectState5 = LOW);  (ChannelSelectState6 = LOW);}
if(240<CHANNELSELECT) {(ChannelSelectState1 = LOW); (ChannelSelectState2 = LOW); (ChannelSelectState3 = HIGH); (ChannelSelectState4 = LOW); (ChannelSelectState5 = LOW);  (ChannelSelectState6 = LOW);}
if(420<CHANNELSELECT) {(ChannelSelectState1 = LOW); (ChannelSelectState2 = LOW); (ChannelSelectState3 = LOW);  (ChannelSelectState4 = HIGH);(ChannelSelectState5 = LOW);  (ChannelSelectState6 = LOW);}
if(750<CHANNELSELECT) {(ChannelSelectState1 = LOW); (ChannelSelectState2 = LOW); (ChannelSelectState3 = LOW);  (ChannelSelectState4 = LOW); (ChannelSelectState5 = HIGH); (ChannelSelectState6 = LOW);}
if(1000<CHANNELSELECT){(ChannelSelectState1 = LOW); (ChannelSelectState2 = LOW); (ChannelSelectState3 = LOW);  (ChannelSelectState4 = LOW); (ChannelSelectState5 = LOW);  (ChannelSelectState6 = HIGH);}
}

       if((BankState [1] == LOW) && (ChannelSelectState1  == HIGH))                                  {Channel = 1; BankArrayNumber = 1;  BankArrayShift1 = 0;     BankRecord = 0;  ClearState = 1;}
  else if((BankState [2] == LOW) && (ChannelSelectState2  == HIGH))                                  {Channel = 2; BankArrayNumber = 2;  BankArrayShift2 = 0;     BankRecord = 0;  ClearState = 2;}
  else if((BankState [3] == LOW) && (ChannelSelectState3  == HIGH))                                  {Channel = 3; BankArrayNumber = 3;  BankArrayShift3 = 0;     BankRecord = 0;  ClearState = 3;} 
  else if((BankState [4] == LOW) && (ChannelSelectState4  == HIGH))                                  {Channel = 7; BankArrayNumber = 4;  BankArrayShift4 = 0;     BankRecord = 0;  ClearState = 7;} 
  else if((BankState [5] == LOW) && (ChannelSelectState5  == HIGH))                                  {Channel = 8; BankArrayNumber = 5;  BankArrayShift5 = 0;     BankRecord = 0;  ClearState = 8;} 
  else if((BankState [6] == LOW) && (ChannelSelectState6  == HIGH))                                  {Channel = 9; BankArrayNumber = 6;  BankArrayShift6 = 0;     BankRecord = 0;  ClearState = 9;} 
  
  else if((BankState [1] == HIGH) && (ChannelSelectState1  == HIGH))                                 {Channel = 1; BankArrayNumber = 1;  BankArrayShift1 = 3;     BankRecord = 3;  ClearState = 1;}
  else if((BankState [2] == HIGH) && (ChannelSelectState2  == HIGH))                                 {Channel = 2; BankArrayNumber = 2;  BankArrayShift2 = 3;     BankRecord = 3;  ClearState = 2;}
  else if((BankState [3] == HIGH) && (ChannelSelectState3  == HIGH))                                 {Channel = 3; BankArrayNumber = 3;  BankArrayShift3 = 3;     BankRecord = 3;  ClearState = 3;} 
  else if((BankState [4] == HIGH) && (ChannelSelectState4  == HIGH))                                 {Channel = 7; BankArrayNumber = 4;  BankArrayShift4 = 3;     BankRecord = 3;  ClearState = 7;} 
  else if((BankState [5] == HIGH) && (ChannelSelectState5  == HIGH))                                 {Channel = 8; BankArrayNumber = 5;  BankArrayShift5 = 3;     BankRecord = 3;  ClearState = 8;}
  else if((BankState [6] == HIGH) && (ChannelSelectState6  == HIGH))                                 {Channel = 9; BankArrayNumber = 6;  BankArrayShift6 = 3;     BankRecord = 3;  ClearState = 9;}

//switch for selecting between both channels and banks

if(ClearButtonState == LOW)
{ 
for(int i = 1; i<42; i++)
{
Sequence[ClearState+BankRecord][i] = 0;
}
}                                                 //This is the clear button

     if((FillButtonState == LOW) && (Channel == 1)) {Fill1 = 1; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;} 
else if((FillButtonState == LOW) && (Channel == 2)) {Fill1 = 0; Fill2 = 1; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;}
else if((FillButtonState == LOW) && (Channel == 3)) {Fill1 = 0; Fill2 = 0; Fill3 = 1; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;}
else if((FillButtonState == LOW) && (Channel == 7)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 1;  Fill5 = 0;  Fill6 = 0;}
else if((FillButtonState == LOW) && (Channel == 8)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 1;  Fill6 = 0;}
else if((FillButtonState == LOW) && (Channel == 9)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 1;}

else if((FillButtonState == HIGH)  && (Channel == 1)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;} 
else if((FillButtonState == HIGH)  && (Channel == 2)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;}
else if((FillButtonState == HIGH)  && (Channel == 3)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;}
else if((FillButtonState == HIGH)  && (Channel == 7)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;} 
else if((FillButtonState == HIGH)  && (Channel == 8)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;} 
else if((FillButtonState == HIGH)  && (Channel == 9)) {Fill1 = 0; Fill2 = 0; Fill3 = 0; Fill4 = 0;  Fill5 = 0;  Fill6 = 0;} 

      //This is the FILL button

if(DeleteButtonState == LOW)
{
Sequence[Channel+BankRecord][looper+1] = 0;
}                             //This is the delete button


if(ResetButtonState != LastResetButtonState)
{
if(ResetButtonState == HIGH) 
{
  looper = 0;  
  ClockKeep = 0;
  BankPush1 = 0;
  BankPush2 = 0;
  BankPush3 = 0;
  BankPush4 = 0;
  BankPush5 = 0;
  BankPush6 = 0;
  }
  } 
int StepLength = map (analogRead(1), 0, 1023, 0, 18);

if(StepLength <= 2)
{steps = 8;}
if((StepLength >2) && (StepLength <= 6))
{steps = 12;}
if((StepLength > 6) && (StepLength <=11))
{steps = 16;} 
if((StepLength > 11) && (StepLength <=16))
{steps = 24;} 
if((StepLength > 16) && (StepLength <=18))
{steps = 32;} 

 if(looper >= steps) {looper = 0;}   //this bit starts the sequence over again
 if(ClockKeep >= 32) {looper = 0; ClockKeep = 0;}
 if((BankPush1  + NewKnobValue1) >= steps) {BankPush1 = 0;}
 if((BankPush2  + NewKnobValue2) >= steps) {BankPush2 = 0;}
 if((BankPush3  + NewKnobValue3) >= steps) {BankPush3 = 0;}
 if((BankPush4  + NewKnobValue4) >= steps) {BankPush4 = 0;}
 if((BankPush5  + NewKnobValue5) >= steps) {BankPush5 = 0;}
 if((BankPush6  + NewKnobValue6) >= steps) {BankPush6 = 0;}
 
 lastButtonState = buttonState;
 LastRecordButtonState = RecordButtonState;
 LastResetButtonState = ResetButtonState;//section is for the state change detections
 Bankprevious[BankArrayNumber] = ButtonBankSelectState[BankArrayNumber]; 
  }
 //  =================== convenience routines ===================

//  isr() - quickly handle interrupts from the clock input
//  ------------------------------------------------------
void isr()
{
  buttonState = HIGH;
}

the archive also contains a hardware schematic and other stuff if you douwload it

In a totally ideal world I’d get some sort of adjustable pulse width, but I would also be stoked with just a generally longer pulse…

cheers

Lance / cyclic

oh, BTW,

if you skip to about 2:30 on the video above, Pete moves out the way and you can see how the drum is triggered by one of the divided clocks on the right, while the BigButton on the left is relatively dim.

just for completeness as well, I am going to get some opto-transistors which might be fast enough to trigger off the quick pulses, but it still wont LOOK as good as a brighter, longer pulse…

Cyclic