sketch_apr30a.ino

#define cbi( sfr, bit ) ( _SFR_BYTE( sfr ) &= ~_BV( bit ) )
#define sbi( sfr, bit ) ( _SFR_BYTE( sfr ) |= _BV( bit ) )
 
volatile byte Timewaster;
 
void setup()
{
 
  /* Speed up timer 2 to make pins 3 and 11 output a blistering fast PWM. */
  TCCR2B = TCCR2B & 0b11111000 | 1;
  TCCR2A &= ~B11;
  TCCR2A |=  B011;
  pinMode( 3, OUTPUT );  
  pinMode( 11, OUTPUT );  
 
  /* Do the same for timer 0.  WARNING: Much of the Arduino library relies on timer 0 and you will find some functions output incorrect values.  Look up the full effects and make sure you don't need it. */
  TCCR0B = TCCR0B & 0b11111000 | 1;
  TCCR0A &= ~B11;
  TCCR0A |=  B011;
  pinMode( 5, OUTPUT );  
  pinMode( 6, OUTPUT );      
 
  analogWrite( 3, 0 );
  analogWrite( 11, 0 );    
  analogWrite( 5, 0 );
  analogWrite( 6, 0 );    
 
  /* Set the reference level to 1.1v */
  sbi( ADMUX, REFS0 );
  sbi( ADMUX, REFS1 );  
 
  /* Increase our input speed - prescaler to /8 */  
  cbi( ADCSRA, ADPS2 );
  sbi( ADCSRA, ADPS1 );
  sbi( ADCSRA, ADPS0 );  
 
  /* Select A0. */
  cbi( ADMUX, MUX0 );
  cbi( ADMUX, MUX1 );
  cbi( ADMUX, MUX2 );
  cbi( ADMUX, MUX3 );  
 
  /* Turn on the ADC. */
  sbi( ADCSRA, ADEN );
 
  /* Give it four cycles to sink in. */
  Timewaster++;
  Timewaster--;  
  Timewaster++;
  Timewaster--;  
 
  /* Tell the ADC to get to work! */
  sbi( ADCSRA, ADSC );
 
  /* Our LED. */
  pinMode( 13, OUTPUT );  
 
}
 
unsigned short Buffer[ 256 ];
byte Ringstart = 0;
 
byte LFO = 0;
boolean LFODirection = 0;
 
 
unsigned short UpdateAgo = 0;
boolean UpdateWhich = 0;
byte LFOSpeed = 0;
byte LFOSlow = 0;
byte LFODepth = 0;
 
void loop()
{
 
    /* Wait for the conversion to complete. */
    while( !( ADCSRA & _BV( ADIF ) ) ){}
 
    /* Grab the result. */
    /* We need to grab ADCL first because accessing ADCH will discard ADCL. */
    byte Low = ADCL;
    unsigned short Left = ( ADCH << 8 ) | Low;  
   
    /* Clear the finished bit. */
    cbi( ADCSRA, ADIF );    
   
    if( UpdateAgo ) UpdateAgo--; else
    {
     
        sbi( ADMUX, MUX1 );  
   
        if( UpdateWhich ) sbi( ADMUX, MUX0 );    
     
        /* Give it four cycles to sink in. */
        Timewaster++;
        Timewaster--;  
        Timewaster++;
        Timewaster--;        
     
        /* Tell the ADC to get to work! */
        sbi( ADCSRA, ADSC );      
     
        /* Wait for the conversion to complete. */
        while( !( ADCSRA & _BV( ADIF ) ) ){}
   
        /* Grab the result. */
        /* We need to grab ADCL first because accessing ADCH will discard ADCL. */
        byte Low = ADCL;
       
        if( UpdateWhich )
        {
       
            LFODepth = ( ( ADCH << 8 ) | Low ) >> 2;  
           
            cbi( ADMUX, MUX0 );
           
            UpdateWhich = 0;
           
        }
        else
        {
       
            LFOSpeed = ( ( ADCH << 8 ) | Low ) >> 2;  
           
            UpdateWhich = 1;            
           
        }
       
        /* Clear the finished bit. */
        cbi( ADCSRA, ADIF );    
     
        cbi( ADMUX, MUX1 );
     
        UpdateAgo = 4096;
     
    }
   
    /* Give it four cycles to sink in. */
    Timewaster++;
    Timewaster--;  
    Timewaster++;
    Timewaster--;  
   
    /* Tell the ADC to get to work! */
    sbi( ADCSRA, ADSC );
   
    Buffer[ Ringstart ] = Left;
   
    Ringstart++;
   
    if( LFOSlow ) LFOSlow--; else
    {
   
      if( LFODirection )
      {
       
          LFO++;
         
          if( LFO == 255 ) LFODirection = 0;
       
      }
      else
      {
       
          LFO--;
         
          if( LFO <= LFODepth ) LFODirection = 1;
       
      }    
     
      LFOSlow = LFOSpeed;
     
    }
   
    byte Progress = Ringstart;
    Progress += LFO;
   
    Left += Buffer[ Progress ];
   
    /* Scale it up to full 16-bit. */
    Left <<= 5;
 
    analogWrite( 3, Left >> 8 );
    analogWrite( 11, Left & 255 );    
   
}