MCV876 Controller Update: Source Code

Aus Synthesizer Wiki
Wechseln zu: Navigation, Suche

Übersetzen

Der Code für den ATMega 88 wird mit dem AVR-Studio 4 erstellt. Das kann man auf der Atmel Webseite (kostenlos) runter laden. Im Studio ein neues, leeres Projekt mit Standard-Einstellungen, einem sinnvollen Namen und an einem Ort, wo man es wiederfindet erstellen. In den Projekteinstellungen die passenden CPU wählen und die Taktfrequenz einstellen. Project->Configuration-Options:

ProjectSettings.gif

Dann Quelltext in das (automatisch erzeugte, leere) C-File kopieren, auf Build->Build klicken, fertig.


Das resultierende HEX File kann man mit einem üblichen Programmieradapter in der Chip flashen, für uns zweckmäßiger ist allerdings, das in ein Sys-Ex File zu Konvertieren ( MCV876_Controller_Update:_File_Converter), und das über Midi an den Controller zu schicken. Dann programmiert der sich selber um. Dazu muss er allerdings einmalig mit dem Bootlader (MCV876_Controller_Update:_Bootloader) programmiert worden sein.


Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, http://www.mikrocontroller.net kommt häufig vor, und hat ein ergiebiges Forum und gute Artikel. Auf der Atmel Webseite gibt es auch einige Info, das ATMega 88 Datenblatt ist spätestens dann nötig, wenn es um die Hardware geht.

Quelltext

/*
	MCV876 with ATMega 88 

	Midi to 4 Channel Control Voltage and six Gates Interface 

	Preliminary 
	Version 0.22 2011-06-26 


    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
			
*/

 
#include <avr/io.h>			// yes, we want to talk to the port pins by name
#include <avr/eeprom.h>		// ... oh.. and some eeprom access would be nice
#include <avr/interrupt.h>	// ... and w/o the interupts it wouldn't do anything... 
#include <util/delay.h>



/*	===================ZERO LINE=================================
	WARNING: everthing below the zero line counts from zero! 
	e.g. whats Gate 6 in manual is GATE5 here, CVs are CV0 to 3 
*/


/*
	where should the LED output be 
*/
#define LEDLED   6  // LED at Reset-Pin, standard for series, but no debugging possible. 
#define LEDGATE0 0	// Led at Gate 0, no LED (Test I: no LED ) 
#define LEDGATE4 4	// LED at Gate 5, Test II: no Gate 5 Function (Midi Start/Stop) 


 #define LEDOUT LEDLED // select your evil... 


#define ACTIVE_SENSE_TICKS 160 // 2ms Timer Ticks for active sense time out 

#define BUTTON (!(PIND & (1<<4))) // True if Button pressed 

#define NUM_CV 4

#define PARAMETEROFFSET 0x23 // First paramter has adress 0x23
#define NUM_PARAMTERS 17	 // and there are 17 parameters 

#define MODE_MONO 	0x00	// monophon, all assigned to last note on a single channel 
#define MODE_MULTI2	0x40	// two channel, 1/2 for midiChannel, 2/3 for midiChannel+1 
#define MODE_MULTI4	0x60	// for channel midiChannel to midiChannel+3 
#define MODE_POLY2	0x80	// not supported 
#define MODE_POLY4	0xA0	// not supported

struct CONFIG {
	unsigned char midiChannel;
	unsigned char noteOffset;

	unsigned char cvMidiCC[NUM_CV];
	unsigned char gateMidiCC[NUM_CV];
	
	unsigned char gateTreshhold;
	unsigned char clockDivider;
	unsigned char clockTime; 
	unsigned char ifMode0; 	// 	bit 0 ... bit 3 = CV0 .. CV3, 0=Pitch, 1=CC (if pitch, CC assignement is ignored) 
							//	bit 5: voices: 0=2; 1=4 
							//  bit 7:6= 00 Mono; 01:Multi-Channel; 10: Poly (not supported); 
	
	unsigned char ifMode1;  // Gate Trigger Mode Bits (0=Re-Trigger, 1=TriggerControl)  
	unsigned char ifMode2;  // bit0: Velo0=>CV0; bit1:Velo0=>CV1; bit2:Velo-Poly2=>CV2; bit3:Velo1=>CV3
							// bit4: PB=>CV0; bit5:PB=>CV1; bit6:PB=>CV2; bit7:PB=>CV3
	unsigned char ifMode3; 	// bit0..bit3 = CV0... CV3; 0=10V, 1=5V Mode 

//  internal evaluated configuration 
	unsigned char numMidiChannels;


} shadow_config, // her goes a copy, when config should be written, because that might take a while 

config 	// current configuration, mostly direct evaluated troughout the program
= {		// default values (Mono-Mode, Midi-Ch 1, CV1=Pitch, CV2=Velocity CV3=ModWheel CV4=Pitch Bend
			0,  	// Midi Channel 
			24, 	// Note Offset (2 Oktaves) 
		{	255,255,1,255, },  	// CV - assigned Midi Controllers (used if not pitch output) 255=none
		{   255,18,19,20, }, 	// Gate - asigned Controllers (if not pitch) 255=none 
			63, 	// Treshold
			6,  	// Divider 6 (1/16 Note) 
			1,  	// clock time (unused) 
			0x0e, 	// mode 0 Low nibble CC-Bits, high: interface mode 
			0, 		// mode 1 re-trigger bits 
			0x82, 	// mode 2 High Nibble: PB-bits, Low: Velo-Bits
			0,    	// mode 3 (5V-Bits) 
};

#define EE_MAGIC 17
unsigned char ee_magic EEMEM;	// to check it eeprom was ever written and should be read back 
unsigned char config_eeprom[NUM_PARAMTERS] EEMEM; // Config in EEPROM, saves it during power down. 


volatile unsigned char  eepromWriteFlag;	// set to one, if main-loop should write eeprom 

volatile unsigned char button; 	// debounced button status 
volatile unsigned char learn; 	// (channel/base note/cc) "do learn" status 
volatile unsigned char blinker; // some count for blinkenlights 

volatile unsigned char gate5off; // timer counter for when clock gate output should go low again. 

volatile unsigned char watchTicker;	// midi active sense counter 




void setConfig(void); 		
void setLed(unsigned char on);
void resetAll(void);

/*
	main() 
	Main does initialization, than runs a loop, which does nearly nothing: 

	Programming the EEPROM (because its slow) 
	Blinking 
	Button evaluation 

	All the important things are done by the interupts. (Thanks to the 
	20MHZ RISC power everything can be done in less than 320µs=one Midi-Character) 
*/
int main(void)
{
	unsigned char blink=4;

	unsigned char i,x; 
	unsigned char *cp;
	static unsigned char lastButton; 

/* 

		HARDWARE INIT 

*/
   // Input/Output Ports initialization
    // DDRx  = Define I/O direction for each pins
    // PORTx = If pin is Output then `0' = lo, `1' = hi
    //         If pin is input then `0' = no pullup, `1' = pullup enabled
    // `0' = Input `1' = Output
    // Port B initialization
    DDRB  = 0x3f;                 // PB0=G4; PB1=G5 (Opt. LED); PB2=G6 ; PB3=WR1; PB4=D0; PB5=D1 (all output)
    PORTB = 0x04;                 // WR1 High, Rest Low 

    // Port C initialization
    DDRC  = 0x7F;                 // PC0=D2; PC1=D3; PC2=D4; PC3=D5; PC4=D6; PC5=D7; PC6=LED (opt.) (all output)
	PORTC = 0x00;                 // all Low

    // Port D initialization
    DDRD  = 0xee;                 // [PD0=RX]; PD1=WR2; PD2=WR3; PD3=WR4; PD4=Button; PD5=G1; PD6=G2; PD7=G3 
    PORTD = 0x1F;                 // Pullup on RX & Button, all WR High, Gates Low 


    // Timer/Counter 1 initialization
    // Clock source: System Clock
    // Clock value: 20Mhz /64
    // Mode: CTC 
    // OC0 output: Disconnected
	OCR1A= 625; // 2 ms  
	TCCR1A =0; 
	TCCR1B =8+3; // CTC Mode, TOP from OCR1A + Clock/64 
	TIMSK1 =2; // OCF1A Interupt 


    // USART initialization
    // Communication Parameters: 8 Data, 1 Stop, No Parity
    // USART Receiver: On
    // USART Transmitter: OFF
    // USART Mode: Asynchronous
    UCSR0A = 0x00;
	/* Set frame format: 8data, 1stop bit */
	UCSR0C = 6;

    // USART Baud rate: 31250;  20E6/16/31250 - 1
   	UBRR0H = 0;
    UBRR0L = 39;

    /*Enable receiver , Enable Rx-int  */
	UCSR0B = ((1<<RXEN0)|(1<<RXCIE0) ) ;


/*
	HARDWARE READY 
*/

	// Read Configuration 
	_delay_ms(10); // wait for button pin to get high if open. 
	if( eeprom_read_byte(&ee_magic) == EE_MAGIC  &&   !BUTTON) // if eeprom valid AND Button not pressed 
	{
		cp=(unsigned char* )&config; 
		for(i=0;i<NUM_PARAMTERS;++i)
		{
			x=eeprom_read_byte(config_eeprom+i);			// read config from eeprom 
			*cp=x;	
			cp++;
		}
	}
	else 
		blink=8; 

	setConfig();

	// enable interrupts
	sei(); 

	while(1)
	{
		if(eepromWriteFlag)
		{	// save configuration 
			cp=(unsigned char* )&shadow_config; 
			for(i=0;i<NUM_PARAMTERS;++i)
			{
				x=*cp;
				eeprom_write_byte(config_eeprom+i,x);
				cp++;
			}
			eeprom_write_byte(&ee_magic,EE_MAGIC); 

			setLed(1);
			blink=6;
			blinker=0;
			eepromWriteFlag=0;	
		}
		if(blink && blinker>2)  // blink after power up and after storing in nv-memory 
		{
			blink--;
			setLed(blink&1);
			blinker=0; 
		}

		if(button != lastButton)
		{
			if(button==1 )
			{
				resetAll();
				if(learn==1)
				{
					learn=0;
					setLed(0);
				}
			}

			if(button==6) 
			{
				if(learn ==0)
				{
					learn=1;
					setLed(1);
				}
			}
			lastButton=button; 
		}
	}
	return 0; 
}

/* ***********************************************************************************

	Hardware Interface

*/
/*  Pin assignment 
   Atmel Fkt 	[Orig] 
1  Reset LED 	[MCLR] 
2  RX    Midi-Rx[WR1]
3  PD1   WR2
4  PD2   WR3
5  PD3   WR4
6  PD4   Button
7  VCC   +5  	[LED] (Either from Atmel-1(Series) or Atmel-15(w/Debug))
8  GND   GND
9  OSC   OSC
10 OSC   OSC 
11 PD5   G1
12 PD6   G2
13 PD7   G3
14 PB0   G4

15 PB1   G5 (Optional + LED) 
16 PB2   G6 
17 PB3   WR1    [---] 
18 PB4   D0     [RX]
19 PB5   D1		[GND]
20 AVCC  +5
21 ARef  +5 	[D0]
22 GND   GND	[D1] 
23 PC0   D2
24 PC1   D3
25 PC2   D4
26 PC3   D5
27 PC4   D6
28 PC5   D7

*/
// put "val" to the right port bits for the DA-Converter 
// ... better program than solder *that*... 
void adByteOut(unsigned char val)
{
	unsigned char b;
	b=val;
	b>>=2;
	PORTC=b;
	b=val&3;
	b<<=4;
	val=PORTB;
	val &=0xCF;
	val|=b;
	PORTB=val;
}
// set DA-Output voltage of one CV Channel  
void set_cv(unsigned char val, unsigned char channel)
{
	adByteOut(val); 	// set D0..D7 converter data bits 
	switch (channel)	// pulse with write pin 
	{
		case 0: //PB3
			PORTB  &= ~(1<<3);
			PORTB  |=  (1<<3);
			break;
		case 1:	// PD1
			PORTD &= ~(1<<1);
			PORTD |=  (1<<1);
			break;
		case 2:	// PD2
			PORTD &= ~(1<<2);
			PORTD |=  (1<<2);
			break;
		case 3:	// PD3
			PORTD &= ~(1<<3);
			PORTD |=  (1<<3);
			break;
	}
}
// set on of the gate outputs active 
void gate_on(unsigned char channel)
{
	switch (channel)
	{
		case 0:	// PD5
			PORTD |= (1<< 5);
			break;
		case 1:	// PD6
			PORTD |= (1<< 6);
			break;
		case 2:	// PD7
			PORTD |= (1<< 7);
			break;
		case 3:	// PB0
			PORTB |= (1<< 0);
			break;
		case 4:	// PB1
#if LEDOUT != LEDGATE4
			PORTB |= (1<< 1);
#endif 
			break;
		case 5:	// PB2
			PORTB |= (1<< 2);
			break;
	}
}
// clear one of the gate outputs 
void gate_off(unsigned char channel)
{
	switch (channel)
	{
		case 0:	// PD5
			PORTD &=~(1<< 5);
			break;
		case 1:	// PD6
			PORTD &=~(1<< 6);
			break;
		case 2:	// PD7
			PORTD &=~(1<< 7);
			break;
		case 3:	// PB0
			PORTB &=~(1<< 0);
			break;
		case 4:	// PB1
#if LEDOUT != LEDGATE4
			PORTB &=~(1<< 1);
#endif
			break;
		case 5:	// PB2
			PORTB &=~(1<< 2);
			break;
	}
}
/* ***********************************************************************************

	LED

*/
void setLed(unsigned char on)
{
#if LEDOUT == LEDLED
	if (on)	// PC6
		PORTC |= (1<< 6);
	else 
		PORTC &=~(1<< 6);
#endif 
#if LEDOUT == LEDGATE4
	if (on)	// PB1
		PORTB |= (1<< 1);
	else 
		PORTB &=~(1<< 1);
#endif 
}

/* ***********************************************************************************

	Data Handling

*/
typedef struct {
	unsigned char channel;  // (relative) Midi channel (0..3) Mode dependant 
	unsigned char cvOut;	// for which CV-Ouput (0..3) fixed 
	unsigned char ccVal;	// current CC Value 
	unsigned char note;		// current Note 
	unsigned char velo;		// current Velocity 
	unsigned char on;		// if Note is on 
	signed char   pb;		// current Pitch Bend Value 
	unsigned char gateDipper;
} cvoutput;  

cvoutput cv_out[NUM_CV];	// current state for each cv out

unsigned char gates; // which gates are on => used for LED setting 

// set cv output (and assigned gate, if pitch output)
// called after anything that changes the cv_out structure  
void updateCv(cvoutput *cvo)
{
	unsigned char bm;
	unsigned char gated=0;
	int val=0;

	bm=1<<cvo->cvOut;	// bit mask for configuration flags 

	if(config.ifMode0 & bm)	// 1=CC-Mode
	{
		if(config.cvMidiCC[cvo->cvOut]>127) // if no Controller assigned 
		{
			if(config.ifMode2 & (bm<<4)) 		// if PB is active 
				val=cvo->pb+0x80;		 		//     pitch sets unipolar value 
			else 						 		// else 
				val=0; 					 		//    value is zero 
		}
		else 								// else a controller is assigned 
		{
			val=cvo->ccVal; 					//  set current controler value ;
			if(config.ifMode2 & (bm<<4)) 		//  if PB active 
				val+=cvo->pb;			 		//     add it (bipolar) 
		}

		if( (config.ifMode1 & bm) && cvo->on==0) // if Trig Flag and note off 
			gated=1; 								// than gate CV output (to zero) 


/*
		if( (config.ifMode3 & bm) && cvo->on==0)	// 5V-Flag, abused as Gated-Mode-CV Flag 
			gated=1;
*/
	}
	else // Note
	{
		val=cvo->note;
		val -= config.noteOffset;

		if(config.ifMode3 & bm)	// 5V
			val <<= 2;
		else
			val <<= 1;

		if(config.ifMode2 & (bm<<4)) // PB 
			val+=(cvo->pb>>2);  // scale down pb - value is empirical and works "not too bad" 
								//  (for "good" the converter should have 12bits a least... ) 
	}
	if(config.ifMode2 & bm) // Velocity 
		val+=cvo->velo;


	if(val<0 || gated)	// clip values to converter range 
		val=0;
	if(val>255)
		val=255;

	set_cv((unsigned char)val, cvo->cvOut);
	if((config.ifMode0 & bm)==0)
	{
		if(cvo->on)
		{
			if(cvo->gateDipper==0) // no retrigger required
				gate_on(cvo->cvOut);
			else				   // dip gate for a few milliseconds 	
				gate_off(cvo->cvOut);
			gates |=bm;
		}
		else 
		{
			gate_off(cvo->cvOut);
			gates &=~bm;
		}
	}
}

// calculate/initialize control variables after 
// mode-configuration change 
void setConfig()
{
	unsigned char i; 
	cvoutput *cvo;

	cvo=cv_out;

	for(i=0;i<NUM_CV;++i)
	{
		cvo->cvOut=i;
		cvo->pb=0;
		cvo->ccVal=0; 
		cvo++;
	} 

	cvo=cv_out;
	switch(config.ifMode0 & 0xf0 )
	{	
		default:
		case MODE_MONO:
			for(i=0;i<NUM_CV;++i)
			{
				cvo->channel=0;
				cvo++;
			} 
			config.numMidiChannels=1;
			break;
		case MODE_MULTI2:
			for(i=0;i<NUM_CV/2;++i)
			{
				cvo->channel=0;
				cvo++;
			} 
			for(;i<NUM_CV;++i)
			{
				cvo->channel=1;
				cvo++;
			} 
			config.numMidiChannels=2;
			break;
		case MODE_MULTI4:
			for(i=0;i<NUM_CV;++i)
			{
				cvo->channel=i;
				cvo++;
			} 
			config.numMidiChannels=NUM_CV;
			break;
	}
}

// assign new note state to cv outputs 
void setNote(unsigned char note, unsigned char velo, unsigned char onOff, unsigned char channel)
{
	unsigned char i;
	cvoutput *cvo;
	
	cvo=cv_out;
	for(i=0;i<NUM_CV;i++)
	{
		if(cvo->channel==channel)
		{
			cvo->note=note;
			cvo->velo=velo;
			if(onOff==2 && cvo->on && (config.ifMode1 & (1<<i)))
				cvo->gateDipper=4;
			cvo->on=onOff;
			updateCv(cvo);
		}
		cvo++;
	}
	setLed(gates);
}

// process new continous controller value 
void setCC(unsigned char cc, unsigned char value, unsigned char channel)
{
	unsigned char i;
	cvoutput *cvo;

	cvo=cv_out;

	for(i=0;i<NUM_CV;++i)
	{
		if(channel== cvo->channel )
		{
			if(config.ifMode0 &(1<<i))
			{
				if(config.cvMidiCC[i]==cc)
				{
					cvo->ccVal=value; 
					updateCv(cvo);
				}
				if(config.gateMidiCC[i]==cc  )
				{
					if(value>config.gateTreshhold)
						gate_on(i);
					else 
						gate_off(i);
				}
			}
		}
		cvo++;
	}
}
// process new pitch bend value 
void setPb(signed int value, unsigned char channel)
{
	unsigned char i;
	cvoutput *cvo;

	cvo=cv_out;

	for(i=0;i<NUM_CV;++i)
	{
		if(channel==cvo->channel && (config.ifMode2 & (16<<i)) )
		{
			cvo->pb	=(signed char) (value>>5);	
			updateCv(cvo);	
		}
		cvo++;
	}
	
}

// prepare for (asynchronous) configuration write to eeprom 
void setEeWrite(void)
{
	shadow_config=config; 
	learn=0;
	eepromWriteFlag=1;
}


void (*bootloader)(void) = (void*)0x1800;	// Bootloader sits at adress 0x1800 ... 

// process sys ex command 
void setSyx(unsigned char adr, unsigned char val)
{
	unsigned char *cp;

	cp=(unsigned char *) &config; 

	if(adr==0x14 && val ==0x7b) 
	{	// write eeprom
		if(eepromWriteFlag==0)
		{
			setEeWrite();
		}
		return; 
	}

	// 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7
	if(adr==0x16 && val ==0x42)	// Software update  
	{
		cli();			// interupts off 
		resetAll();		// outputs off 
		GPIOR1 = 0xAB;	// tell bootloader it's an application boot request 
						// (hardware reset sets GPIOR1 to zero, 0xab == magic value for bootloader )
		bootloader();	// bye bye! 
		return; 	// <-- never! 
	}


	adr-=PARAMETEROFFSET; 
	if(adr < NUM_PARAMTERS)	// if valid parameter 
	{
		*(cp+adr)=val; 		// set in 
		if(adr==0x30-PARAMETEROFFSET) // if Mode Byte 0, 
			setConfig();			  // .. cv assignement must be recalculated 
	}

}

/* ***********************************************************************************

	Note Puffer Handling

*/

#define MAX_NOTES 0x10  	// one for each finger of a real programmer 
#define MAX_CHANNELS 4
unsigned char notes[MAX_CHANNELS][MAX_NOTES];
unsigned char velocities[MAX_CHANNELS][MAX_NOTES];
unsigned char playedNote[MAX_CHANNELS]; // number of currently pressed notes 
// update note puffer for a midi note-on message 
void note_on(unsigned char note ,unsigned char velocity, unsigned char channel)
{
	unsigned char n;
	n=playedNote[channel];

	if(n<MAX_NOTES)
	{
		playedNote[channel]++;
	}
	else 
	{
		for (n=MAX_NOTES-1;n>0;--n)
		{
			notes[channel][n-1]=notes[channel][n];
			velocities[channel][n-1]=velocities[channel][n];
		}
		n=MAX_NOTES-1;
	}

	notes[channel][n]=note; 		
	velocities[channel][n]=velocity;
	setNote(note, velocity, 2, channel);
}
// update note puffer for a new midi note-off message 
void note_off(unsigned char note ,unsigned char velocity, unsigned char channel)
{
	unsigned char i;
	signed char n; 

	n=playedNote[channel];

	--n; 
	for (i=0;i<=n;i++)
	{
		if(notes[channel][i]==note)
		{
			if(i==n) // last pressed (== the on which playes) note released 
			{
				if(n==0) // it was the only pressed note 
				{
					setNote(note, velocities[channel][n], 0, channel);
					playedNote[channel]--;
				}
				else
				{	
					--n;
					setNote(notes[channel][n], velocities[channel][n], 1, channel);
					playedNote[channel]--;
				}
			}
			else // non playing note released 
			{	// =>  just remove it from list 
				int j;
				for(j=i+1;j<=n;++j)
				{
					notes[channel][j-1]=notes[channel][j];
					velocities[channel][j-1]=velocities[channel][j];
				}
				playedNote[channel]--;
			}
			break;
		}
	}
}

/* ***********************************************************************************

	All Notes off, empty Note Buffer, All Controllers Reset

*/
void resetAll(void)
{
	unsigned char i;
	cvoutput *cvo;
	cvo=cv_out;

	cli(); // this might be called asynchronous to midi stream 
	for(i=0;i<MAX_CHANNELS;++i)
		playedNote[i]=0;
	
	for(i=0;i<NUM_CV;++i)
	{
		cvo->cvOut=i;
		cvo->ccVal=0;
		cvo->on=0;
		cvo->pb=0;
		updateCv(cvo);
		cvo++;
	} 
	sei();

	setLed(0);
}



/* ***********************************************************************************

	2ms Timer Interupt

*/
ISR(TIMER1_COMPA_vect)
{
	unsigned char i;
	static unsigned char buttonCount;
	static signed char blinkCount; 

	// LED blinker 
	if(--blinkCount<=0)
	{	
		blinkCount=40;
		blinker++;
		if(button)
		{
			if(button<10)
				button++;
		}
	}

	// Button debouncer 
	if(BUTTON)
	{	// down 
		if(buttonCount < 10)
		{
			buttonCount++;
			if(buttonCount==10)
			{
				button=1;
				blinkCount=40;
			}
		}
	}
	else 
	{	// up 
		if(buttonCount > 0)
		{
			buttonCount--;
			if(buttonCount==0)
				button=0;
		}
	}


	// Gate 5 timing (clock output) 
	if(gate5off)
	{
		--gate5off;
		if(gate5off==0)
			gate_off(5);	
	}

	// activ sense 
	if(watchTicker)			// if active sense is activated 
	{
		watchTicker--;		// decrement time 
		if(watchTicker==0)	// if time elapsed
			resetAll(); 	// switch all notes off 	
	}

	// retrigger timing 
	for(i=0;i<NUM_CV;i++)	// for all cv output channels 
	{
		if(cv_out[i].gateDipper)	// if gate timer is active 
		{
			--cv_out[i].gateDipper;		// decrement timer 
			if(cv_out[i].gateDipper==0)	// if timer elapsed
				gate_on(i);				// activate gate 
		}
	}

}




/* ***********************************************************************************

	Eval Midi Data

*/

#define NOTE_ON         0x90		// Midi note on message 
#define NOTE_OFF        0x80		// Midi note off message 
#define PITCH           0xE0		// pitch bender
#define AFTERTOUCH      0xD0        // after touch command (unused) 
#define CC		        0xB0        // Continuous Controller
#define CHAN_PRES	    0xD0        // Channel Pressure (unused)
#define SONG_POSITION_POINTER 0xF2	// used for clock synchronization (first beat) 
#define SYSEX 			0xF0		// System exclusive beginn
#define SYSEND			0xF7		// System exclusive end

struct {
	unsigned char runningStatus;	// Midi runnig status (*)
	unsigned char msgByteCnt;    	// number of current midi-message byte received 
	unsigned char byte1;			// first data byte 
	unsigned char syxAdr; 			// Sys-Ex Adress Byte
	unsigned char startStop;		// current  Midi Start/Stop Status
	unsigned char startFlag;		// Start on next clock
	unsigned char clockTick;		// counter for clock division
	unsigned char channel;			// channel of current midi-command (relative, e.g. 0..3 ) 						
	unsigned int  spp; 				// song position pointer (from midi message), needed to have the clock synced to song position
}midi; 
// 	(*) running status is also used as 'current status' - it remembers allways, what next data byte is for. Or its zero, than data is ignored. 




#define FRAMING_ERROR (1<<FE0)
#define PARITY_ERROR (1<<UPE0)
#define DATA_OVERRUN (1<<DOR0)


// USART Receiver interrupt service routine, 
// complete midi processing is done here, as the CPU is fast enough to 
// do everything before next midi byte can come in. 
ISR(USART_RX_vect) 
{
	unsigned char status,byte;

    status = UCSR0A;
    byte   = UDR0;

    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0 )
	{
		if(watchTicker)						// if there had been an active sense 
			watchTicker=ACTIVE_SENSE_TICKS;	// every new byte is ok, to "feed the watchdog"

		if (byte > 0x7F)	                // if command byte (MSB set)
		{
			if(byte>= 0xF8)  				// if real-time msg 
			{
				switch (byte)
				{
					case 0xF8: 	// Clock 
					{
						if(midi.startFlag)  // if synchronized start 
						{
							midi.startStop=1;
							midi.startFlag=0;

							if(config.clockDivider>1 )// if divided clock 
							{
								if( midi.spp) // if start not from zero 
								{
									midi.clockTick=midi.spp%config.clockDivider;			// calculate clock divider count for current song position 
									if(midi.clockTick >= config.clockDivider>>1)	// if calculated divider count is mor than half elapsed 
										gate_off(5); 								// than set clock output off 
									else
										gate_on(5);									// else set it on 
								}
								else 
								{
									gate_on(5);
									midi.clockTick=0; 
								}
							}
						}
						else 
						{
							if(midi.startStop)	// if (already) running 
								++midi.spp;
							++midi.clockTick; 	// increment counter for clock output 
						}

						if(config.clockDivider<=1)
						{
							gate_on(5);								// do clock output 
							gate5off=3;							
						}
						else
						{
							if(midi.clockTick >= config.clockDivider)	// if divider count elapsed 
							{
								midi.clockTick=0;
								gate_on(5);								// do clock output 
							}
							else if(midi.clockTick == config.clockDivider>>1)	// if divider count half elapsed 
								gate_off(5); 									// set clock output off 
						}
						break;
					}
					case 0xF9:	// Tick (unused) 
						break; 
					case 0xFA: 	// Start 
						if(! midi.startStop) // if not already running 
						{
							midi.spp=0;
							midi.startFlag=1;
							gate_on(4);
							if(config.clockDivider>1)
							{
								gate_off(5); 			// set clock output off 								
								midi.clockTick=0;
							}
						}
						break;
					case 0xFB:	// Continue
						if(! midi.startStop) // if not already running 
						{
							midi.startFlag=1;
							gate_on(4);
						}
						break; 
					case 0xFC:	// Stop
						midi.startStop=0;
						gate_off(4);
						break;
					case 0xFD:	// unassigned 
						break; 
					case 0xFE:	//  Active Sense
						watchTicker=ACTIVE_SENSE_TICKS;
						break;
					case 0xFF:	// Reset 
						break; 
				}
				return ; 
			} 

			if(byte >= 0xF0) 					// if System Common Category message
			{
				if(byte == SYSEX)
				{
					midi.runningStatus=byte;
					midi.msgByteCnt = 0;
					return;
				}
				else if(byte==SYSEND)
				{
					if(midi.runningStatus==SYSEX && midi.msgByteCnt==6) // if a complete valid Sys-Ex Frame has been received 
						setSyx(midi.syxAdr, midi.byte1); 				// change configuration 
					midi.msgByteCnt = 0;
					midi.runningStatus = 0;
					return ; 
				}
				else if(byte ==SONG_POSITION_POINTER)
				{
					midi.runningStatus=byte;  
					midi.msgByteCnt = 0;
					return ; 
				}
				//							// every other System Common is ignored 	
				midi.runningStatus = 0;		// just reset running status 
				return ; 					// and done 
			}

			midi.runningStatus = 0;				// just new status messages left, so running status is lost

			// only channel messages left here ... 
			if(learn)								 // if learn mode 
			{
				if(config.midiChannel != (byte&0xf)) // if message channel not current channel
				{
					config.midiChannel=byte&0xf;	 // assign channel 
					setEeWrite(); 					 // and store it 
				}
			}

			midi.channel=(byte & 0xf)-config.midiChannel ;
			if ( midi.channel<config.numMidiChannels)   // if MIDI channel matches,
			{
				midi.runningStatus = byte & 0xF0 ;		// set running status (==Midi command w/o channel)
				midi.msgByteCnt = 0;
				return ; 
			}
			return ; 
		}
		else	// data bytes goes here 
		{
			switch (midi.runningStatus)		    // last command byte (or zero, if data is not for us) 
			{
			case SONG_POSITION_POINTER:
				if(midi.msgByteCnt)	// 2nd Byte
				{
					midi.spp= (((int)byte << 7 ) | midi.byte1) * 6;
					midi.runningStatus=0;
				}
				else
				{
					midi.byte1 = byte;
					midi.msgByteCnt=1;
				}
				break;
			case (NOTE_ON):					// if we've had a note on byte
				if (midi.msgByteCnt)		// if counter = 1
				{ 			   				// then we've just received a velocity byte
					midi.msgByteCnt = 0;	// msg complete - clear byte count 
					if (byte == 0)			// is it a note off (velo = 0) ?
						note_off(midi.byte1,byte,midi.channel);  
					else 					// NOTE ON
					{
						if(learn)
						{
							config.noteOffset=midi.byte1;
							setEeWrite();
						}
						
						note_on(midi.byte1, byte,midi.channel);  // ... and do what the note on has told us 
					}
				}
				else						// first data byte 
				{
					midi.byte1 = byte;		// save it 
					midi.msgByteCnt = 1;    // set counter to get 2nd data byte
				}
				break;
			case (NOTE_OFF): 	        	// command note off
				if (midi.msgByteCnt)	 	// if complete 
				{ 					 	
					midi.msgByteCnt = 0;	
					note_off(midi.byte1,byte,midi.channel); // switch note off
				}
				else
				{
					midi.byte1 = byte;
					midi.msgByteCnt = 1; 	
				}
				break;
			case (PITCH):		        	// PITCH BEND command
				if (midi.msgByteCnt)   	 	// if second data byte (MSB) 
				{ 						
					int v;
					v=byte;
					v<<=6;
					v|=midi.byte1;
					v-=0x1000;
					setPb(v,midi.channel);

					midi.msgByteCnt = 0;
				}
				else
				{
					midi.byte1 = byte;
					midi.msgByteCnt = 1;
					return;
				}
				break;
			case (CC):	             		// Continuous Controller Message 
				if (midi.msgByteCnt)	
				{
					midi.msgByteCnt = 0;

					if(learn)
					{
						config.cvMidiCC[2]=midi.byte1;
						setEeWrite();
					}

					setCC(midi.byte1, byte,midi.channel);
				}
				else
				{
				  midi.byte1 = byte;
				  midi.msgByteCnt = 1;
				  return; 
				}
				break;
	//		case (CHAN_PRES):	         	// if channel pressure command
	//			channel_pressure (byte); 	// set Aftertouch 
			case SYSEX:						// SYS-EX command 
				midi.msgByteCnt++;			// message Byte counter
				switch(midi.msgByteCnt)		// which byte is on? 
				{
					case 1:					// Manufactorer 
						if(byte !=0x70)		// if not the right one 
							midi.msgByteCnt=0;	// frame error / wrong byte 
						break; 
					case 2:					// Unit - ID 
						if(byte!=0x7D)
							midi.msgByteCnt=0;
						break; 
					case 3:					// Midi-Adress (or Unit ID) (ignored!)
						if(byte>=0x10)		// if not in legal range 
							midi.msgByteCnt=0;	// frame error 
						break;
					case 4:					// adress byte
						midi.syxAdr=byte;	// store it for later
						break;
					case 5:					// high data nibble 
						if(byte<0x10)		// if in range 
							midi.byte1=(byte<<4);	// set half the data 
						else 
							midi.msgByteCnt=0;				
						break;
					case 6: 				// low data nibble 
						if(byte<0x10)		// if in range 
							midi.byte1 |= byte;	// or together the complete data byte 
						else 					// evaluation is  done in the code for SYSEND above! 
							midi.msgByteCnt=0;				
						break;
					default:				// not our framing 
						midi.msgByteCnt=0;
						break;
				}
				if(midi.msgByteCnt==0)	// something did not fit 
					midi.runningStatus=0;
				break;
			case 0: // bnwtko (bytes no one wants to know off ) 
				return ;
			default:
				break;
			}
		}
	}
}