Synthesizer Wiki - Benutzerbeiträge [de]

MCV876 Controller Update: File Converter

2011-06-27T21:08:08Z

Fetz: /* Datenformat */

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass vom Compiler/Linker erzeugte Binär-Datei (im [http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format])) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.

== Benutzen ==
Der Linker der Entwicklungsumgebung erzeugt ein .hex File. Dieses File zieht man einfach auf das Icon der [http://www.kanowski.de/nordcore/sys876.exe sys876.exe]. Kurz darauf taucht im gleichen Verzeichnis wie die .hex Datei eine .syx Datei sonst gleichen Namens auf. Das war es schon - diese Datei ist das Sys-Ex Update File, was man per Midi an den Controller schickt, worauf er dann sofort mit diesem neuen Programm los rennt.

== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bits auf und ist ansonsten recht kurzer Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

MCV876 Controller Update: File Converter

2011-06-27T21:07:17Z

Fetz: /* Datenformat */

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass vom Compiler/Linker erzeugte Binär-Datei (im [http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format])) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.

== Benutzen ==
Der Linker der Entwicklungsumgebung erzeugt ein .hex File. Dieses File zieht man einfach auf das Icon der [http://www.kanowski.de/nordcore/sys876.exe sys876.exe]. Kurz darauf taucht im gleichen Verzeichnis wie die .hex Datei eine .syx Datei sonst gleichen Namens auf. Das war es schon - diese Datei ist das Sys-Ex Update File, was man per Midi an den Controller schickt, worauf er dann sofort mit diesem neuen Programm los rennt.

== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bits auf und ist ansonsten recht einfacher Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

MCV876 Controller Update: File Converter

2011-06-27T20:20:05Z

Fetz: /* Benutzen */

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass vom Compiler/Linker erzeugte Binär-Datei (im [http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format])) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.

== Benutzen ==
Der Linker der Entwicklungsumgebung erzeugt ein .hex File. Dieses File zieht man einfach auf das Icon der [http://www.kanowski.de/nordcore/sys876.exe sys876.exe]. Kurz darauf taucht im gleichen Verzeichnis wie die .hex Datei eine .syx Datei sonst gleichen Namens auf. Das war es schon - diese Datei ist das Sys-Ex Update File, was man per Midi an den Controller schickt, worauf er dann sofort mit diesem neuen Programm los rennt.

== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bytes auf und ist ansonsten recht einfacher Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

MCV876 Controller Update

2011-06-27T20:16:07Z

Fetz: /* Software */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu einzustellen: Die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.

=== Controller für CV3 einstellen ===
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig. (Zur Bauanleitung hier lang: [[MCV876_Controller_Update:_Hardware_bauen]].)

Der neue Controller wird ansonsten einfach nur in den Sockel des Alten gesteckt. Alten Controller rausziehen, Atmel mit Adapter reinstecken, fertig.

[[File:AdapterEingebaut.jpg]]

''So sieht der "neue" in einem Semtex aus''

= Software =
Der Quelltext für die Controller-Software findet sich hier: '''[[MCV876_Controller_Update:_Source_Code]]'''. Da steht dann auch, wie das mit der Entwicklungsumgebung geht.
Das ist der spannende Teil, nämlich das eigentliche Betriebssystem. Um den Teil zu ändern - sprich: seinen Wünschen anzupassen - und das neue Programm in den Controller zu bekommen, braucht man a)nichts kaufen, b)keine Hardware und kann das c)einfach per Midi an den Controller schicken (das Geräte kann also zu bleiben). (Der doofe Teil ist, dass ich nur beschreiben kann, wie das unter Windows geht. Der Atmel-Compiler sollte sich, da GCC, allerdings auch auf anderen Systemen einfinden, den Konverter kann man problemlos auf jedem System übersetzen ... )

Aus der Entwicklungsumgebung kommt eine Binärdatei, die man mit einem kleinen Programm in ein Midi-Sys-Ex Format konvertieren muss. Diese Sys-Ex Datei überträgt man dann mit einem Tool der Wahl (unter Windows z.B. [http://www.midiox.com/ Midi-OX], aber jedes normale DAW-Programm sollte das können) per Midi auf den Controller. Der verfrachtet das flugs (bei aktueller Programmlänge 1,4 Sekunden) in seinen Flash-Programmspeicher.
Dieser Datei-Konverter findet sich hier: [[MCV876_Controller_Update:_File_Converter]].

Der Bootlader des Controllers, der sich auf Controller-Seite um das Update kümmert, ist hier: [[MCV876_Controller_Update:_Bootloader]]. Der wird einmalig in den Controller "gebrannt", und dient dazu, die Software jederzeit updaten zu können, auch wenn man in der eigentlichen Controller-Software gerade mal völligen Murks gemacht hat. Den Code braucht man normalerweise nicht anfassen. (Typischerweise ändert sich der alle paar Jahre mal, es ist aber auch nicht weiter schlimm, wenn man nicht die neueste Version hat... )

MCV876 Controller Update: Source Code

2011-06-27T20:03:01Z

Fetz: /* Übersetzen */

=Ü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:

[[File: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 http://www.mikrocontroller.net] kommt häufig vor, und hat ein ergiebiges Forum und gute Artikel. Auf der Atmel Webseite gibt es auch [http://www.atmel.com/dyn/products/product_card.asp?part_id=3302&category_id=163&family_id=607&subfamily_id=760 einige Info], das [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
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;
}
}
}
}

</pre>

MCV876 Controller Update: File Converter

2011-06-27T20:02:29Z

Fetz:

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass vom Compiler/Linker erzeugte Binär-Datei (im [http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format])) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.

== Benutzen ==
Der Linker der Entwicklungsumgebung erzeugt ein .hex File. Dieses File zieht man einfach auf das Icon der sys876.exe. Kurz darauf taucht im gleichen Verzeichnis wie die .hex Datei eine .syx Datei sonst gleichen Namens auf. Das war es schon - diese Datei ist das Sys-Ex Update File, was man per Midi an den Controller schickt, worauf er dann sofort mit diesem neuen Programm los rennt.

== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bytes auf und ist ansonsten recht einfacher Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

MCV876 Controller Update

2011-06-27T19:10:26Z

Fetz: /* Software */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu einzustellen: Die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.

=== Controller für CV3 einstellen ===
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig. (Zur Bauanleitung hier lang: [[MCV876_Controller_Update:_Hardware_bauen]].)

Der neue Controller wird ansonsten einfach nur in den Sockel des Alten gesteckt. Alten Controller rausziehen, Atmel mit Adapter reinstecken, fertig.

[[File:AdapterEingebaut.jpg]]

''So sieht der "neue" in einem Semtex aus''

= Software =
Der Quelltext für die Controller-Software findet sich hier: '''[[MCV876_Controller_Update:_Source_Code]]'''. Da steht dann auch, wie das mit der Entwicklungsumgebung geht.
Das ist der spannende Teil, nämlich das eigentliche Betriebssystem. Um den Teil zu ändern - sprich: seinen Wünschen anzupassen - und das neue Programm in den Controller zu bekommen, braucht man a)nichts kaufen, b)keine Hardware und kann das c)einfach per Midi an den Controller schicken (das Geräte kann also zu bleiben).

Aus der Entwicklungsumgebung kommt eine Binärdatei, die man mit einem kleinen Programm in ein Midi-Sys-Ex Format konvertieren muss. Diese Sys-Ex Datei überträgt man dann mit einem Tool der Wahl (unter Windows z.B. [http://www.midiox.com/ Midi-OX], aber jedes normale DAW-Programm sollte das können) per Midi auf den Controller. Der verfrachtet das flugs (bei aktueller Programmlänge 1,4 Sekunden) in seinen Flash-Programmspeicher.
Dieser Datei-Konverter findet sich hier: [[MCV876_Controller_Update:_File_Converter]].

Der Bootlader des Controllers, der sich auf Controller-Seite um das Update kümmert, ist hier: [[MCV876_Controller_Update:_Bootloader]]. Der wird einmalig in den Controller "gebrannt", und dient dazu, die Software jederzeit updaten zu können, auch wenn man in der eigentlichen Controller-Software gerade mal völligen Murks gemacht hat. Den Code braucht man normalerweise nicht anfassen. (Typischerweise ändert sich der alle paar Jahre mal, es ist aber auch nicht weiter schlimm, wenn man nicht die neueste Version hat... )

MCV876 Controller Update: File Converter

2011-06-27T18:59:35Z

Fetz: /* Worum geht's? */

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass vom Compiler/Linker erzeugte Binär-Datei (im [http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format])) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.
== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bytes auf und ist ansonsten recht einfacher Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

Datei:ProjectSettings.gif

2011-06-27T18:48:59Z

Fetz: uploaded a new version of "File:ProjectSettings.gif"

Project settings dialog box screen shot

MCV876 Controller Update: Source Code

2011-06-27T18:47:10Z

Fetz: Übersetzen-Abschnitt um die Projekteinstellungen erweitert

=Ü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:

[[File: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 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
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;
}
}
}
}

</pre>

Datei:ProjectSettings.gif

2011-06-27T18:45:59Z

Fetz: Project settings dialog box screen shot

Project settings dialog box screen shot

MCV876 Controller Update: Bootloader

2011-06-26T21:55:57Z

Fetz: Programmieranleitung zugefügt

= Worum geht's? =
Midi-Bootlader für den ATMega 88.

Empfängt einen als Midi-Sys-Ex Datenstrom eingepacktes Programm-Update und schreibt das in den Programm-Speicher des Controllers.

= Compilieren =
Der Code wird mit dem AVR-Studio 4 erzeugt (neues Projekt erzeugen, Quelltext in das Default-File kopieren, fertig)

Einzige Besonderheit ist, dass der Code für die Boolader-Adresse gelinkt werden muss.
Dazu unter Projekt-> Configuration Options -> Custom Options -> Linker Options eine neue Option "-Ttext=0x1800" zufügen (add)

(Im Prinzip ist das hier nicht viel anders als das, was hier beschrieben wird: http://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung )

= Controller programmieren =
Der Bootlader muss mit einem Programmiergerät in den Controller "geflasht" werden. Das sollte mit jedem Programmieradapter gehen, der für den ATmega 88 gedacht ist.
Für ISP-Adapter braucht man irgendeine Platine mit ISP-Sockel, da der Adapter keine Programmierpins hat. Ich habe einfach eine Platine eines anderen Projektes genommen...
Damit der Bootlader so arbeitet wie gewünscht, muss man die "Fuses" des Controllers richtig setzen:
[[File:fuses1.gif]]
[[File:fuses2.gif]]

Hier als Screen-Shot aus dem AVR-Studio 4, so sieht das mit dem Dragon als Programmieradapter aus. Sollte sich aber problemlos auf andere Programmiergeräte übertragen lassen.
* Der Bootbereich darf sich nicht selber überschreiben (Look SPM in Boot Section)
* 2k-Byte Boot-Bereich (kleiner hat keinen Zweck, da die ganzen 2k immer nur unter CPU-Halt beschrieben werden können, was unsere Update-Infrastruktur aber nicht zulässt)
* Reset springt in den Bootlader
* Der Reset-Pin ist I/O Pin. (Vorsicht, das sperrt den ISP-Prgrammer final aus - erst ganz zum Schluß machen!)
* Unterspannungsdetektor bei 4.3V (eher theoretisch...)
* Oszillator für externen Quarz.

Ein "neuer" Atmega steht übrigens auf intern 8MHz-RC/8, da muss man, zumindest beim Dragon, den Takt erst mal kleiner stellen, sonst spricht der Dragon gar nicht mit dem Controller.

= Quelltext =
<pre>
/*
MCV876 with ATMega 88

Bootloader

Preliminary
Version 0.98 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/boot.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <util/crc16.h>

#define LEDGATE0 0 // Led an Gate 0, keine LED Ansteuerung
#define LEDGATE4 4 // LED an Gate 5,
#define LEDLED 6 // LED an Reset-Pin (Serie, kein Debuging)

#define LEDOUT LEDLED

#define BUTTON (!(PIND & (1<<4)))

void (*applicationmain)(void) = (void *)0x0000;
void (*bootloader)(void) = (void *)0x1800;

volatile unsigned char program_it;
volatile unsigned char prog_active;
volatile unsigned char flash_buf[64];
volatile unsigned char blockAdress;

#define EESTATUS_OK 1 // last flash was ok
#define EESTATUS_START 2 // last flash was started (if read on boot-up: ... but never finished)

#define BOOTEEPROMADR ((uint8_t *) 500) // permanent Flag for last update status ('started' or 'success')
// more or less obvisious the permanent state musst be success, else it failed to complete
// and that can't be ok...

#define PROGRAM_IDLE 0
#define PROGRAM_DO 1
#define PROGRAM_FINISH 2
#define PROGRAM_ERROR 3
#define PROGRAM_START 4
#define PROGRAM_ABORT 5

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

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
}

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

Main

*/

int main(void)
{
unsigned char i,j;
unsigned short int flashAdress;

volatile uint16_t tmp;
volatile uint16_t adr;

/*

HARDWARE INIT

*/
cli(); // just to be sure... its not allways a cold boot which runs here..

// 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

if(GPIOR1==0xAB)
{
// app intended Boot Load
GPIOR1 = 0;
}
else
{ // no main application intended Boot-Load

_delay_ms(10); // Wait for Button-Pin to get High if not pressed

GPIOR1=0;

while(BUTTON && GPIOR1 < 8)
{
_delay_ms(1800);
setLed(1);
_delay_ms(200);
setLed(0);
GPIOR1++;
}
_delay_ms(10);

if( ( !BUTTON && GPIOR1==0 ) || GPIOR1 >= 8)
{
unsigned char x;

_delay_ms(100);

x=eeprom_read_byte(BOOTEEPROMADR);
if(x != EESTATUS_START && pgm_read_word(0)!=0xffff ) // if no failed update atemps and not erased
{
_delay_ms(100);
applicationmain();
}
}
}

/* Enable change of Interrupt Vectors */
MCUCR = (1 << IVCE );
/* Move Interrupts to boot flash section */
MCUCR = ( 1 << IVSEL );

// 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
*/
sei(); // Interupts on

while(1) // Main Loop
{
if(program_it== PROGRAM_DO || program_it== PROGRAM_FINISH)
{
flashAdress=blockAdress ; // Block number
flashAdress<<=6; // * block size of 64 bytes

cli(); // some register writes must be done within 4 clock cycles max, Interupts can kill that
boot_page_erase(flashAdress); // issue the block erease command
sei();

do
{
cli();
j=(__SPM_REG & (uint8_t)_BV(__SPM_ENABLE)); // j=it's done?
sei();
}while(j); // wait until j says, that it is done
// this takes some millisekonds, during which we'll receive about a quarter of the next block
// so interupts can't be off the whole time.
;
for (i = 0; i < 64; i+=2) // fill page buffer with 32 words (à two bytes each)
{
tmp = (flash_buf[i]) | (flash_buf[i + 1]<<8);
adr=flashAdress+i;
cli(); // again, one of the "max 4 cycle" macros
boot_page_fill(adr, tmp); // write a word
sei();
}

cli();
boot_page_write(flashAdress); // write to flash
sei();

do // wait until write is done
{
cli(); // prepare uninteruptable max. 4 Cylce sequence
j=(__SPM_REG & (uint8_t)_BV(__SPM_ENABLE)); // read ready flag
sei(); // done
}while(j); // while not ready. Again this takes 3.5 to 4.5ms, during which about another quarter of the
// next block comes in. As we don't want to lose any chars, the interupts cant be turned off the whole time

cli();
boot_rww_enable(); // enable read access to programm flash.
sei();

if(program_it==PROGRAM_FINISH) // if last block
{
eeprom_write_byte(BOOTEEPROMADR,EESTATUS_OK); // store flag for successfull update
prog_active=PROGRAM_IDLE; // should be senseless, but inhibits permanent eeprom writes if something goes wrong...

// Update done, go to new application programm
cli(); // no more intupts
/* Enable change of Interrupt Vectors */ // set interupt vectors to program
MCUCR = (1 << IVCE );
/* Move Interrupts to regular flash section */
MCUCR = 0; // ( 0 << IVSEL );

applicationmain(); // call application (never comes back, stack is lost...)
}
if(program_it!=PROGRAM_ERROR) // if not error // which might happen asynchronous - and should be kept
program_it=PROGRAM_IDLE; // programming of current page done.
}
if(program_it==PROGRAM_START)
{
prog_active=PROGRAM_START;
eeprom_write_byte(BOOTEEPROMADR,EESTATUS_START);

if(program_it!=PROGRAM_ERROR) // might happen asynchronous
program_it=PROGRAM_IDLE;
}
if(program_it==PROGRAM_ABORT)
{
cli();
/* Enable change of Interrupt Vectors */
MCUCR = (1 << IVCE );
/* Move Interrupts to regular flash section */
MCUCR = 0; // ( 0 << IVSEL );

bootloader(); // checks, if there is a valid program to start
}
}
}

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

2ms Timer Interupt

*/

volatile unsigned char dataRx;
#define DATARX 4

ISR(TIMER1_COMPA_vect)
{
static unsigned char bit;
static unsigned char blinker;
static unsigned char blinks[]={ 40 , 10, 200, 10, 15,15,15,15 };
static unsigned char btn;

if (blinker-- == 0)
{
bit++;
bit&=3;
blinker=blinks[bit | dataRx];

setLed(bit&1);

dataRx=0;
}

if(BUTTON)
{
btn=10;
}
else
{
if(btn>0)
{
btn--;
if(btn == 0)
{
if(prog_active==PROGRAM_IDLE && program_it == PROGRAM_IDLE)
program_it=PROGRAM_ABORT;
}
}
}

}

/* ***********************************************************************************
SERIAL MIDI INTERFACE
*/

#define SYSEX 0xF0
#define SYSEND 0xF7

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

#define STAT_IDLE 0
#define STAT_INSYSEX1 1
#define STAT_INSYSEX2 2
#define STAT_INSYSEX3 3
#define STAT_INSYSEX4 4
#define STAT_INSYSEX5 5
#define STAT_INSYSEX6 6
#define STAT_PROGRAM_BYTES 7
#define STAT_WAITEND 8
#define STAT_ERROR 9

unsigned char rx_buf[68]; // 1Byte Block-Adress, 64 Data-Bytes, 2Byte CRC

// USART Receiver interrupt service routine
ISR(USART_RX_vect)
{
static unsigned char status, error, current_block,num_blocks;
// static unsigned char nibble_cnt, data;
static unsigned short int runningByte; // no joke, this accumulates our 8-bit-bytes from 7bit midi, so it must hold up to 14bit in between...
static unsigned char byte_cnt,bits;

static unsigned short int crc;
unsigned char rxStat,byte;

rxStat = UCSR0A;
byte = UDR0;

if ((rxStat & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0 )
{
if(status > STAT_IDLE)
dataRx=DATARX;

if (byte > 0x7F ) // Command byte
{
if( byte < 0xF8 ) // no Real-Time Message
{
if(byte == SYSEX ) // Start
{
status=STAT_INSYSEX1;
}
else if(byte==SYSEND) // SysEx-End (might not be ours)
{
if( status==STAT_PROGRAM_BYTES) // properly framed SysEx received
{
status=STAT_IDLE;
if(crc==0 )
{
unsigned char i;

if(rx_buf[0]==0 && byte_cnt==6 ) // first block = info block
{
error=0;
current_block=1;
num_blocks=rx_buf[1];
for(i=0;i<2;i++)
flash_buf[i]=rx_buf[i+2];
program_it=PROGRAM_START;

}
else if(byte_cnt==67 && current_block==rx_buf[0] )
{ // Programm Data Block

for(i=0;i<64;i++)
flash_buf[i]=rx_buf[i+1];
blockAdress=rx_buf[0]-1;

if(!error)
{
if(num_blocks==current_block)
{
program_it=PROGRAM_FINISH;
}
else
{
program_it=PROGRAM_DO;
}
}
current_block++;
}
else
{
status=STAT_ERROR;
}
}
else
status=STAT_ERROR;
}
else // not my frame format
status=STAT_IDLE;
}
else // some other Status byte
{
if(status!=STAT_IDLE)
{
if(status<STAT_PROGRAM_BYTES) // might be unrelated to us
status=STAT_IDLE;
else
status=STAT_ERROR; // our Data gets messed up
}
}
} // no real time message
}
else // Data Byte
{
switch(status)
{
default: // should never happen
status=STAT_ERROR;
case STAT_IDLE: // any Data which is not in our SysExFrame
break;
case STAT_INSYSEX1: // Manufacturer
if(byte==0x70)
{
status=STAT_INSYSEX2;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX2: // Unit ID
if(byte==0x7D)
{
status=STAT_INSYSEX4;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX4: // Unit Adress (ignored)
if(byte< 0x10)
{ status=STAT_INSYSEX5;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX5: // "Data Adress" (magic byte 1)
if(byte == 0x15)
{
status=STAT_INSYSEX6;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX6: // magic byte 2 (this would stop the regular SysEx Decoder from taking this as data)
if(byte == 0x55)
{
status=STAT_PROGRAM_BYTES;
crc=0xffff;
byte_cnt=0;
bits=0;
}
else
status=STAT_IDLE;
break;
case STAT_PROGRAM_BYTES: // we've made it: now the new flash data rolls in
runningByte <<=7;
runningByte|=byte;
bits+=7;
if(bits>=8) // if enough for one Byte
{
unsigned char b;

bits-=8;
b=runningByte>>bits;
rx_buf[byte_cnt]=b;
crc=_crc16_update(crc,b);
if(++byte_cnt>67)
status=STAT_ERROR;
}
break;
} // switch status
} // data byte
}
else // any Rx-Erros => abort
status=STAT_ERROR;

if(status==STAT_ERROR)
{
status=STAT_IDLE;
error=1;
}
}

</pre>

Datei:Fuses2.gif

2011-06-26T21:44:06Z

Fetz: Fuse-Einstellungen 1

Fuse-Einstellungen 1

Datei:Fuses1.gif

2011-06-26T21:43:48Z

Fetz: Fuse-Einstellungen 1

Fuse-Einstellungen 1

MCV876 Controller Update: Hardware bauen

2011-06-26T20:49:34Z

Fetz: Created page with '= Bauanleitung Adaptersockel = Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig. Damit man gleich sieht auf was es rausl…'

= Bauanleitung Adaptersockel =
Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

Damit man gleich sieht auf was es rausläuft:

[[File:Adapter-sockel.jpg]]

Ein fertiger Adaptersockel.

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 ) Außerdem braucht man einen weiteren 28poligen Sockel als Montagehilfe/Abstandshalter für die beiden Stecksockel, sonst bekommt man das nie gerade und passend hin.

Das hässliche Weiße ist die PIN1 Markierung. Falschrum reinsetzen ist nämlich Mist.

== Der Verdrahtungplan ==

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.

== Schritt für Schritt ==

Die Steckteile passen zunächst nicht nebeneinander. Die werden mit mit Dremel oder Feile etwas eingekürzt. An beide Teilen je eine Seite kürzen und dabei aufpassen, dass man die Kontakte nicht ansäbelt)

[[File:build1.jpg]]

[[File:build2.jpg]]

Beide Stecksockel in einem extra-Sockel, der (nur) als Montagehalter/hilfe dient, stecken. Das hier wird das Unterteil.

[[File:build3.jpg]]

Der "richtige" Sockel (Oberteil, da kommt später der Atmel rein) von unten. Die Pins, die rausgekniffen werden (rotes X im Plan oben) fehlen hier schon, und die 5V Verbindung (zwischen 3 Pins) ist mit einem blanken Draht gelötet.

[[File:build5.jpg]]

Verbindungsdrähte anlöten:

[[File:build6.jpg]]

(der aufmerksame Betrachter wird den 100nF SMD-Kondensator bemerken, den ich heimlich an die Versorgung gefingert habe. Wenn man da einen bedrahteten nimmt *und* dessen eines Beinchen gleich für die +5V hernimmt, dann lötet sich das vermutlich auch gar nicht so schlimm. )

Zusammenfügen von Ober- und Unterteil.
Die Pins von den Sockelbeinchen passen genau in die Gabeln von dem Stecksockel.
Und die Drähte habe ich auch schon mal (etwa) dahin gelegt, wo sie hin sollen.

[[File:build7.jpg]]

Sockel-Pins in den Gabeln festlöten und dann die einzelnen Drähte kürzen, abisolieren und verlöten. Hier ist gerade der Violette an der Reihe:

[[File:build8.jpg]]

Alles verlötet:

[[File:build9.jpg]]

... unteren Stecksockel vorsichtig abhebeln, damit die Beinchen nicht verbiegen.

Atmel reinpröppeln und dann ab in das Interface.

Datei:Build9.jpg

2011-06-26T20:45:57Z

Fetz: Fertig

Fertig

Datei:Build8.jpg

2011-06-26T20:45:31Z

Fetz: Drähte verlöten

Drähte verlöten

Datei:Build7.jpg

2011-06-26T20:44:50Z

Fetz: Ober- und Unterteil zusammenfügen

Ober- und Unterteil zusammenfügen

Datei:Build6.jpg

2011-06-26T20:44:14Z

Fetz: Oberteil mit angelöteten Drähten

Oberteil mit angelöteten Drähten

Datei:Build5.jpg

2011-06-26T20:34:26Z

Fetz: Oberteil-Sockel, mit entfernten Pins und +5V Brücke

Oberteil-Sockel, mit entfernten Pins und +5V Brücke

Datei:Build3.jpg

2011-06-26T20:31:33Z

Fetz: Stecksockel in einem "Hilfssockel" der als Montagehilfe dient

Stecksockel in einem "Hilfssockel" der als Montagehilfe dient

Datei:Build2.jpg

2011-06-26T20:30:06Z

Fetz: Stecksockel-Unterteil gekürzt

Stecksockel-Unterteil gekürzt

Datei:Build1.jpg

2011-06-26T20:29:24Z

Fetz: Adapter-Unterteile vor der Bearbeitung

Adapter-Unterteile vor der Bearbeitung

Datei:Adapter.gif

2011-06-26T20:16:10Z

Fetz: uploaded a new version of "File:Adapter.gif"

Verdrahtungsplan des Adaptersockels
(A=Atmel-Pins, P=Platinen-Pins)

Datei:Adapter-sockel.jpg

2011-06-26T20:12:30Z

Fetz: uploaded a new version of "File:Adapter-sockel.jpg": Der fertige Adaptersockel

Adapter-Sockel um den Atmel-Controller in einen PIC-sockel stecken zu können. Die drei Pins an der Seite sind nur für Debug-Zwecke nötig, nicht für den normalen Einsatz.

MCV876 Controller Update

2011-06-26T20:03:54Z

Fetz: /* Hardware */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu einzustellen: Die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.

=== Controller für CV3 einstellen ===
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig. (Zur Bauanleitung hier lang: [[MCV876_Controller_Update:_Hardware_bauen]].)

Der neue Controller wird ansonsten einfach nur in den Sockel des Alten gesteckt. Alten Controller rausziehen, Atmel mit Adapter reinstecken, fertig.

[[File:AdapterEingebaut.jpg]]

''So sieht der "neue" in einem Semtex aus''

= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

Datei:AdapterEingebaut.jpg

2011-06-26T20:02:55Z

Fetz:

MCV876 Controller Update: Source Code

2011-06-26T19:56:43Z

Fetz: /* Übersetzen */

=Ü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, 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 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
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;
}
}
}
}

</pre>

MCV876 Controller Update: Source Code

2011-06-26T19:54:01Z

Fetz: /* Quelltext */

=Ü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, 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 [hier Link auf Bootlader imaginieren.. ] programmiert worden sein.

Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, [http://www.mikrocontroller.net 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
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;
}
}
}
}

</pre>

MCV876 Controller Update

2011-06-26T19:39:14Z

Fetz: /* Midi-Kanalwahl */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu einzustellen: Die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.

=== Controller für CV3 einstellen ===
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:38:15Z

Fetz: /* Bedienung */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.

=== Controller für CV3 einstellen ===
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:35:58Z

Fetz: /* Grund-Note einstellen */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:35:11Z

Fetz: /* Die Leuchtdiode */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie zweimal, um anzuzeigen, dass der Controller lebt.
Sollte sie vier mal blinken, hat der Controller die permanent gespeicherte Konfiguration nicht geladen und nutzt statt dessen (wieder) die Standardeinstellung.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:23:46Z

Fetz: /* Funktionsübersicht – Standardbelegung */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1   || Tonhöhe (Noten)    || Gate 1   || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen- und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.

= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:20:45Z

Fetz: /* Betriebsart Controller */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1 || Tonhöhe (Noten) || Gate 1 || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen. und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.
= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang(sic!) ge-gated. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update

2011-06-26T19:11:42Z

Fetz: /* Erweiterte Einstellungen */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1 || Tonhöhe (Noten) || Gate 1 || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen. und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.
= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876 (3er Version), er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

==== Interface Betriebsart ====
Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:

* Mono (default): 1 Kanal monophon

* Multi2: 2 Kanal Monophon

* Multi4: 4 Kanal Monophon

* Poly2 und Poly4: nicht unterstützt

Weitere Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

==== Kanal-Betriebsart ====
Bei den vier Ausgangs-Kanälen gehören immer ein Steuerspannungs(=CV)-Ausgang und ein Gate zusammen. Das erste Feld "CC" entscheidet hier (grundlegend), ob der Kanal Tonhöhe und Gate (=Note-An) erzeugt, oder ob er ein Controller Kanal ist. Die "Resteinstellung" ist dann jeweils ziemlich unterschiedlich.

===== Betriebsart Tonhöhe =====
Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal. Im Tonhöhen-Modus wird das jeweilige Gate automatisch für Note-An vereinnahmt.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Die Ausgangsspannung ist von der Hardware auf Werte über 0 festgelegt, das wird ggfls. passend begrenzt)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Das 5V-Feld schaltet die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Das "Trig" Feld hinter dem Gate gibt (im Tonhöhen-Modus) an, ob das Gate bei neuen Midi-Noten Retriggert oder nicht. Zum Retrigger wird das Gate kurz ausgeschaltet. Der Retrigger erfolgt nur, wenn man neue Noten drückt, nicht, wenn man Noten loslässt und die Notenpriorisierung auf eine gehaltene Note zurückfällt.

===== Betriebsart Controller =====
Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe. Wählt man bei Controller "none", wird 0 als Grundwert genommen. (Sonderregel für Pitch-Bend: ist der Controller "None" und Pitch-Bend gewählt, dann wird 5V als Grundwert genommen, weil der Pitch-Bender nach links sonst keine Funktion hätte. So hat er dann ganz links 0V und ganz rechts 10V.)

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert (bipolar) auf die Ausgangsspannung addiert. (Auch hier geht "unter Null" seitens der Hardware nicht.)

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Im CC-Modus hat das 5V Feld keine Funktion. Die Midi-Werte (von 0...127) werden '''immer''' auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind, ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Den Gate-Ausgängen kann ein Controller zugewiesen werden. Das Gate ist dann an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Wird das Trig-Feld aktiviert, dann wird der DAC-Ausgang ge-gated werden. Das heißt, der CV-Ausgang wird auf Null geklemmt, wenn keine Note an ist. Damit lässt sich z.B. ein Gate bauen, dass eine analoge, velocity-abhängige Höhe hat.

'''Beispiele:''' Drei einfache und häufige Fälle für Steuerspannungen:
* Modwheel: CC auf Modwheel (Coarse), alles andere aus.
* PitchBend: CC auf "none", nur Pitch-Bend ausgewählt.
* Velocity: CC auf "none", nur Velocity angewählt.

==== Clock-Einstellung ====
Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note (d.h.: Teiler 6=16tel, 12=8tel, 24=1/4). Die Midi Clock wird zum Midi-Start und dem Midi Song Position Pointer synchron gehalten. Wenn man also einen geraden Teiler einstellt, dann hat man den Clock immer synchron zur 1. Bei Midi-Start oder Midi-Continue 'springt' der Clockpuls daher ggfls. um wieder synchron zu werden. Der Clock-Ausgang ist immer die halbe Clock-Dauer an. Er lässt sich damit direkt als Midi-synchroner Rechteck-LFO verwenden.

Gate 5 ist immer Midi-Start/Stop. Das wird direkt durchgereicht, 5V wenn es läuft, 0V im Stopp. Wenn der Master das korrekt erzeugt, nämlich etwas vor dem nächsten Clock, der die erste 1 markiert, dann lassen sich damit analoge Sequencer synchron starten. Wenn der Sequencer allerdings sofort auf Start losrattert, dann wird er etwas zu früh sein. (Start "gleichzeitig" mit der Clock ist Mist, da dann unklar ist, ob der erste Clock-Puls erwischt wird oder nicht. )

= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update: Source Code

2011-06-26T17:25:31Z

Fetz: /* Quelltext */

=Ü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, 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 [hier Link auf Bootlader imaginieren.. ] programmiert worden sein.

Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, [http://www.mikrocontroller.net 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
MCV876 with ATMega 88

Midi to 4 Channel Control Voltage and six Gates Interface

Preliminary
Version 0.21 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.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;
}
}
}
}

</pre>

MCV876 Controller Update

2011-06-25T22:32:20Z

Fetz: /* Software */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1 || Tonhöhe (Noten) || Gate 1 || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen. und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.
= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876, er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:
Mono (default). 1 Kanal Monophon.

Multi 2. 2 Kanal Monophon

Multi 4. 4 Kanal Monophon

Die weiteren Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

Im DAC-Feld kann für jede CV (=jeden Steuerspannungs-Ausgang) gewählt werden, wie er gesteuert wird.

Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert auf die Ausgangsspannung addiert.

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe.

Das 5V-Feld schaltet im Tonhöhen-Modus die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Im CC-Modus werden die Ccs auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Die Gates 1-4 sind den Tonhöhenkanälen fest zugeordnet, gibt ein DAC eine Tonhöhe aus, ist das zugehörige Gate auch Note an/aus.

Ist der DAC auf CC gestellt, kann der Gate-Ausgang einem Controller zugewiesen werden, das Gate ist an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note. (6=16tel, 12=8tel, 24=1/4)
Gate 5 ist immer Midi-Start/Stop.
= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Der Bootlader ist hier: [[MCV876_Controller_Update:_Bootloader]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update: Bootloader

2011-06-25T22:31:00Z

Fetz: Created page with '= Worum geht's? = Midi-Bootlader für den ATMega 88. Empfängt einen als Midi-Sys-Ex Datenstrom eingepacktes Programm-Update und schreibt das in den Programm-Speicher des Contro…'

= Worum geht's? =
Midi-Bootlader für den ATMega 88.

Empfängt einen als Midi-Sys-Ex Datenstrom eingepacktes Programm-Update und schreibt das in den Programm-Speicher des Controllers.

= Compilieren =
Der Code wird mit dem AVR-Studio 4 erzeugt (neues Projekt erzeugen, Quelltext in das Default-File kopieren, fertig)

Einzige Besonderheit ist, dass der Code für die Boolader-Adresse gelinkt werden muss.
Dazu unter Projekt-> Configuration Options -> Custom Options -> Linker Options eine neue Option "-Ttext=0x1800" zufügen (add)

(Im Prinzip ist das hier nicht viel anders als das, was hier beschrieben wird: http://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung )

<pre>
/*
MCV876 with ATMega 88

Bootloader

Preliminary
Version 0.98 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/boot.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <util/crc16.h>

#define LEDGATE0 0 // Led an Gate 0, keine LED Ansteuerung
#define LEDGATE4 4 // LED an Gate 5,
#define LEDLED 6 // LED an Reset-Pin (Serie, kein Debuging)

#define LEDOUT LEDLED

#define BUTTON (!(PIND & (1<<4)))

void (*applicationmain)(void) = (void *)0x0000;
void (*bootloader)(void) = (void *)0x1800;

volatile unsigned char program_it;
volatile unsigned char prog_active;
volatile unsigned char flash_buf[64];
volatile unsigned char blockAdress;

#define EESTATUS_OK 1 // last flash was ok
#define EESTATUS_START 2 // last flash was started (if read on boot-up: ... but never finished)

#define BOOTEEPROMADR ((uint8_t *) 500) // permanent Flag for last update status ('started' or 'success')
// more or less obvisious the permanent state musst be success, else it failed to complete
// and that can't be ok...

#define PROGRAM_IDLE 0
#define PROGRAM_DO 1
#define PROGRAM_FINISH 2
#define PROGRAM_ERROR 3
#define PROGRAM_START 4
#define PROGRAM_ABORT 5

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

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
}

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

Main

*/

int main(void)
{
unsigned char i,j;
unsigned short int flashAdress;

volatile uint16_t tmp;
volatile uint16_t adr;

/*

HARDWARE INIT

*/
cli(); // just to be sure... its not allways a cold boot which runs here..

// 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

if(GPIOR1==0xAB)
{
// app intended Boot Load
GPIOR1 = 0;
}
else
{ // no main application intended Boot-Load

_delay_ms(10); // Wait for Button-Pin to get High if not pressed

GPIOR1=0;

while(BUTTON && GPIOR1 < 8)
{
_delay_ms(1800);
setLed(1);
_delay_ms(200);
setLed(0);
GPIOR1++;
}
_delay_ms(10);

if( ( !BUTTON && GPIOR1==0 ) || GPIOR1 >= 8)
{
unsigned char x;

_delay_ms(100);

x=eeprom_read_byte(BOOTEEPROMADR);
if(x != EESTATUS_START && pgm_read_word(0)!=0xffff ) // if no failed update atemps and not erased
{
_delay_ms(100);
applicationmain();
}
}
}

/* Enable change of Interrupt Vectors */
MCUCR = (1 << IVCE );
/* Move Interrupts to boot flash section */
MCUCR = ( 1 << IVSEL );

// 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
*/
sei(); // Interupts on

while(1) // Main Loop
{
if(program_it== PROGRAM_DO || program_it== PROGRAM_FINISH)
{
flashAdress=blockAdress ; // Block number
flashAdress<<=6; // * block size of 64 bytes

cli(); // some register writes must be done within 4 clock cycles max, Interupts can kill that
boot_page_erase(flashAdress); // issue the block erease command
sei();

do
{
cli();
j=(__SPM_REG & (uint8_t)_BV(__SPM_ENABLE)); // j=it's done?
sei();
}while(j); // wait until j says, that it is done
// this takes some millisekonds, during which we'll receive about a quarter of the next block
// so interupts can't be off the whole time.
;
for (i = 0; i < 64; i+=2) // fill page buffer with 32 words (à two bytes each)
{
tmp = (flash_buf[i]) | (flash_buf[i + 1]<<8);
adr=flashAdress+i;
cli(); // again, one of the "max 4 cycle" macros
boot_page_fill(adr, tmp); // write a word
sei();
}

cli();
boot_page_write(flashAdress); // write to flash
sei();

do // wait until write is done
{
cli(); // prepare uninteruptable max. 4 Cylce sequence
j=(__SPM_REG & (uint8_t)_BV(__SPM_ENABLE)); // read ready flag
sei(); // done
}while(j); // while not ready. Again this takes 3.5 to 4.5ms, during which about another quarter of the
// next block comes in. As we don't want to lose any chars, the interupts cant be turned off the whole time

cli();
boot_rww_enable(); // enable read access to programm flash.
sei();

if(program_it==PROGRAM_FINISH) // if last block
{
eeprom_write_byte(BOOTEEPROMADR,EESTATUS_OK); // store flag for successfull update
prog_active=PROGRAM_IDLE; // should be senseless, but inhibits permanent eeprom writes if something goes wrong...

// Update done, go to new application programm
cli(); // no more intupts
/* Enable change of Interrupt Vectors */ // set interupt vectors to program
MCUCR = (1 << IVCE );
/* Move Interrupts to regular flash section */
MCUCR = 0; // ( 0 << IVSEL );

applicationmain(); // call application (never comes back, stack is lost...)
}
if(program_it!=PROGRAM_ERROR) // if not error // which might happen asynchronous - and should be kept
program_it=PROGRAM_IDLE; // programming of current page done.
}
if(program_it==PROGRAM_START)
{
prog_active=PROGRAM_START;
eeprom_write_byte(BOOTEEPROMADR,EESTATUS_START);

if(program_it!=PROGRAM_ERROR) // might happen asynchronous
program_it=PROGRAM_IDLE;
}
if(program_it==PROGRAM_ABORT)
{
cli();
/* Enable change of Interrupt Vectors */
MCUCR = (1 << IVCE );
/* Move Interrupts to regular flash section */
MCUCR = 0; // ( 0 << IVSEL );

bootloader(); // checks, if there is a valid program to start
}
}
}

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

2ms Timer Interupt

*/

volatile unsigned char dataRx;
#define DATARX 4

ISR(TIMER1_COMPA_vect)
{
static unsigned char bit;
static unsigned char blinker;
static unsigned char blinks[]={ 40 , 10, 200, 10, 15,15,15,15 };
static unsigned char btn;

if (blinker-- == 0)
{
bit++;
bit&=3;
blinker=blinks[bit | dataRx];

setLed(bit&1);

dataRx=0;
}

if(BUTTON)
{
btn=10;
}
else
{
if(btn>0)
{
btn--;
if(btn == 0)
{
if(prog_active==PROGRAM_IDLE && program_it == PROGRAM_IDLE)
program_it=PROGRAM_ABORT;
}
}
}

}

/* ***********************************************************************************
SERIAL MIDI INTERFACE
*/

#define SYSEX 0xF0
#define SYSEND 0xF7

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

#define STAT_IDLE 0
#define STAT_INSYSEX1 1
#define STAT_INSYSEX2 2
#define STAT_INSYSEX3 3
#define STAT_INSYSEX4 4
#define STAT_INSYSEX5 5
#define STAT_INSYSEX6 6
#define STAT_PROGRAM_BYTES 7
#define STAT_WAITEND 8
#define STAT_ERROR 9

unsigned char rx_buf[68]; // 1Byte Block-Adress, 64 Data-Bytes, 2Byte CRC

// USART Receiver interrupt service routine
ISR(USART_RX_vect)
{
static unsigned char status, error, current_block,num_blocks;
// static unsigned char nibble_cnt, data;
static unsigned short int runningByte; // no joke, this accumulates our 8-bit-bytes from 7bit midi, so it must hold up to 14bit in between...
static unsigned char byte_cnt,bits;

static unsigned short int crc;
unsigned char rxStat,byte;

rxStat = UCSR0A;
byte = UDR0;

if ((rxStat & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0 )
{
if(status > STAT_IDLE)
dataRx=DATARX;

if (byte > 0x7F ) // Command byte
{
if( byte < 0xF8 ) // no Real-Time Message
{
if(byte == SYSEX ) // Start
{
status=STAT_INSYSEX1;
}
else if(byte==SYSEND) // SysEx-End (might not be ours)
{
if( status==STAT_PROGRAM_BYTES) // properly framed SysEx received
{
status=STAT_IDLE;
if(crc==0 )
{
unsigned char i;

if(rx_buf[0]==0 && byte_cnt==6 ) // first block = info block
{
error=0;
current_block=1;
num_blocks=rx_buf[1];
for(i=0;i<2;i++)
flash_buf[i]=rx_buf[i+2];
program_it=PROGRAM_START;

}
else if(byte_cnt==67 && current_block==rx_buf[0] )
{ // Programm Data Block

for(i=0;i<64;i++)
flash_buf[i]=rx_buf[i+1];
blockAdress=rx_buf[0]-1;

if(!error)
{
if(num_blocks==current_block)
{
program_it=PROGRAM_FINISH;
}
else
{
program_it=PROGRAM_DO;
}
}
current_block++;
}
else
{
status=STAT_ERROR;
}
}
else
status=STAT_ERROR;
}
else // not my frame format
status=STAT_IDLE;
}
else // some other Status byte
{
if(status!=STAT_IDLE)
{
if(status<STAT_PROGRAM_BYTES) // might be unrelated to us
status=STAT_IDLE;
else
status=STAT_ERROR; // our Data gets messed up
}
}
} // no real time message
}
else // Data Byte
{
switch(status)
{
default: // should never happen
status=STAT_ERROR;
case STAT_IDLE: // any Data which is not in our SysExFrame
break;
case STAT_INSYSEX1: // Manufacturer
if(byte==0x70)
{
status=STAT_INSYSEX2;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX2: // Unit ID
if(byte==0x7D)
{
status=STAT_INSYSEX4;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX4: // Unit Adress (ignored)
if(byte< 0x10)
{ status=STAT_INSYSEX5;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX5: // "Data Adress" (magic byte 1)
if(byte == 0x15)
{
status=STAT_INSYSEX6;
}
else
status=STAT_IDLE;
break;
case STAT_INSYSEX6: // magic byte 2 (this would stop the regular SysEx Decoder from taking this as data)
if(byte == 0x55)
{
status=STAT_PROGRAM_BYTES;
crc=0xffff;
byte_cnt=0;
bits=0;
}
else
status=STAT_IDLE;
break;
case STAT_PROGRAM_BYTES: // we've made it: now the new flash data rolls in
runningByte <<=7;
runningByte|=byte;
bits+=7;
if(bits>=8) // if enough for one Byte
{
unsigned char b;

bits-=8;
b=runningByte>>bits;
rx_buf[byte_cnt]=b;
crc=_crc16_update(crc,b);
if(++byte_cnt>67)
status=STAT_ERROR;
}
break;
} // switch status
} // data byte
}
else // any Rx-Erros => abort
status=STAT_ERROR;

if(status==STAT_ERROR)
{
status=STAT_IDLE;
error=1;
}
}

</pre>

Datei:Adapter.gif

2011-06-25T19:33:00Z

Fetz: uploaded a new version of "File:Adapter.gif": Korrektur: Pin 2 gehört nicht durchverbunden irrelevanten Stern an Pin 1/7 entfernt

Verdrahtungsplan des Adaptersockels
(A=Atmel-Pins, P=Platinen-Pins)

MCV876 Controller Update: Source Code

2011-06-23T19:18:36Z

Fetz: /* Übersetzen */

=Ü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, 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 [hier Link auf Bootlader imaginieren.. ] programmiert worden sein.

Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, [http://www.mikrocontroller.net 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
MCV876 with ATMega 88

Midi to 4 Channel Control Voltage and six Gates Interface

Preliminary
Version 0.20 2011-06-23

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...

/* ===================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 LEDGATE4 // 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 1 Low nibble CC-Bits, high: interface mode
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.

// to have the clock synced to "beat 1" of a bar ...
volatile unsigned int spp; // song position pointer (from midi message)
unsigned char ticksPerBar=96; // How many ticks per bar (is not tx-ed: guess 96 for 4/4 ... )
volatile unsigned char barTick; // where are we inside the bar (counted, because calculation from spp takes some cpu-cycles )

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 clocker; // timer counter for half a midi-clock (which is needed for divider 1)
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=6;

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
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++;
}
}
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
{
val=cvo->ccVal; // <<1;
/*
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) // Velocity
val+=cvo->velo;
if(config.ifMode2 & (bm<<4)) // PB
val+=cvo->pb;

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=0x80;
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(channel);
else
gate_off(channel);
}
}
}
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>>6);
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=0x80;
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)
clocker++;
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 char syncStartFlag; // start on next 1
}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;
midi.syncStartFlag=1;
midi.clockTick=0;
gate_on(4);
}
else if(midi.startStop) // if (already) running
{
++spp;
++barTick;
if(barTick >= ticksPerBar)
barTick=0;
}
++midi.clockTick; // increment counter for clock output
if(midi.clockTick >= config.clockDivider) // if divider cout elapsed do clock output
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1; // pulse-width counter = half of current midi clock pulse width
}

if(midi.syncStartFlag && barTick==0 && midi.startStop ) // synchronize clock output to bars
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1;
midi.syncStartFlag=0;
}
clocker=0; // restart midi clock pulse width counter.
break;
}
case 0xF9: // Tick (unused)
break;
case 0xFA: // Start
if(! midi.startStop) // if not already running
{
spp=0;
barTick=0;
midi.startFlag=1;
}
break;
case 0xFB: // Continue
if(! midi.startStop) // if not already running
midi.startFlag=1;
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
{
spp= (((int)byte << 7 ) | midi.byte1) * 6;
barTick = spp % (unsigned int) ticksPerBar;
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-=0x2000;
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[3]=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;
}
}
}
}

</pre>

MCV876 Controller Update

2011-06-23T19:16:25Z

Fetz: /* Software */

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1 || Tonhöhe (Noten) || Gate 1 || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen. und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.
= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876, er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:
Mono (default). 1 Kanal Monophon.

Multi 2. 2 Kanal Monophon

Multi 4. 4 Kanal Monophon

Die weiteren Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

Im DAC-Feld kann für jede CV (=jeden Steuerspannungs-Ausgang) gewählt werden, wie er gesteuert wird.

Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert auf die Ausgangsspannung addiert.

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe.

Das 5V-Feld schaltet im Tonhöhen-Modus die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Im CC-Modus werden die Ccs auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Die Gates 1-4 sind den Tonhöhenkanälen fest zugeordnet, gibt ein DAC eine Tonhöhe aus, ist das zugehörige Gate auch Note an/aus.

Ist der DAC auf CC gestellt, kann der Gate-Ausgang einem Controller zugewiesen werden, das Gate ist an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note. (6=16tel, 12=8tel, 24=1/4)
Gate 5 ist immer Midi-Start/Stop.
= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

Der Datei-Konverter, der eine mit der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 Entwicklungsumgebung] erzeugte Binär-Datei ([http://de.wikipedia.org/wiki/Intel_HEX Intel .hex Format]) in ein Sys-Ex File für ein Software-Update über Midi umwandelt, findet sich hier: [[MCV876_Controller_Update:_File_Converter]]

MCV876 Controller Update: File Converter

2011-06-23T19:12:04Z

Fetz: Created page with '= Worum geht's? = Der File Konverter ist ein kleines Programm, dass die aus dem Compiler/Linker stammende Programm-Datei (.hex) in ein Datenformat wandelt, dass per Midi übertr…'

= Worum geht's? =
Der File Konverter ist ein kleines Programm, dass die aus dem Compiler/Linker stammende Programm-Datei (.hex) in ein Datenformat wandelt, dass per Midi übertragen werden kann und das der Controller so versteht, dass er sich selber updaten kann.
== Datenformat ==
Die Programm-Daten werden in 64-Byte Nutzdatenhäppchen eingepackt. Diese Pakete sind Brutto 84 Bytes lang.
Die Daten müssen für Midi umkodiert werden, da Midi nur 7 Bit Nutz-Daten übertragen kann. Dazu werden einfach immer die nächsten 7 bit aus dem 8-Bit breiten Datenstrom entnommen. Das gibt völlig undurchsichtige Werte, geht erst nach 7x8=56 Bytes auf und ist ansonsten recht einfacher Code, der kompakte Daten erzeugt. Um Datenübertragungsfehler zu erkennen, bekommt jedes Paket eine 16 Bit CRC als Prüfsumme. Und damit es als Midi durchgeht, kommen noch ein paar Bytes ("hallo hier kommt ein SysEx") davor und ein Ende Byte dahinter.

Die 64 Byte sind eine für Midi, Sys-Ex und das Controller-RAM noch verträgliche Datensatzlänge. Und der Controller schreibt seinen Programm-Speicher in genau solchen 64 Byte Blöcken.

Vor die eigentlich Progamm-Daten werden noch zwei Pakete vorangestellt:

Das erste schaltet einen in normalem Midi-Betrieb laufenden Controller auf den Boot-Lader um. Nach dem eigentlichen, kurzen Kommando, das den Normalbetrieb beendet, folgen 70 Nullen, die dem Controller mindestens 22ms Luft verschaffen, um auf den Bootlader zu wechseln. (Ist der Controller bereits im Bootlader wird dieses Paket nebst den Nullen schlichtweg überlesen/ignoriert. )

Das zweite Paket enthält nur die Info, dass es a)das erste Update-Pakte ist (d.h. es setzt den Empfänger auf "jetzt geht es los" zurück), und b)die Zahl der folgenden Blöcke (damit Vollständigkeit geprüft werden kann).

Dann kommen die eigentlichen Programmdaten.

= Quelltext =
<pre>
/*
Programm zum Erzeugen von Midi-Sys-Ex Software Update Files aus einer HEX-Datei
für das MCV-876 Midi Interface mit ATMEL ATMEGA 88 Controller.
*/

/*
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/>.

*/

/*
Aufruf:
sys676 avr-studio-compiler-out.hex

das erzeugt dann eine Datei
sys676 avr-studio-comipler-out.syx

die mit Midi-OX (oder einen andern "ich kann Midi senden" Programm) an das
Interface übertragen wird.

Unter Windows kann man das übrigens bequem per "Drag and Drop" bedienen, einfach die
.hex Datei auf die sys876.exe draufziehen, das Ergebnis taucht dann im gleichen Order wie
die .hex Datei auf. (Man sieht halt keine Fehlermeldungen... )

Erfolgreich übersetzt mit Visual Studio .net 2003 auf Windows XP
Leeres Konsolenprojekt Namens syx876 erzeugen, diesen Quelltext in das .cpp
File kopieren und bauen lassen. Ggfls. auf "Release" umstellen, im Release Ordner
findet sich dann die fertige Applikation.

Sollte sich nach marginalen Änderungen allerdings mit jedem Compiler übersetzen lassen.

*/
// für Windows =======================
#include "stdafx.h"
#define main _tmain

// für normale Compiler =============
/*
#include <stdio.h>
*/
//===================================

#define VERSION "1.00"

#define MAX_DATA 8192 // netto data size (ATMEGA 88 Flash Rom size)
#define MAX_SYX_DATA (2*MAX_DATA) // max. complete syx-ex size
#define MAX_SYX_BLOCK (2*64) // one Sys-Ex Block of 64 bytes netto data

unsigned char data[MAX_DATA]; // holds binary program data

// Convert one HEX-ASCII character to its numerical value, or -1 if illegal value
int conf( char c)
{
switch (c)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
}
return (-1);
}

// calculate 16 bit crc from previous crc and new data byte, initial (first) crc should be 0xffff, returns new crc
unsigned int crc16(unsigned int crc, unsigned char byte)
{
int i;
crc^=byte;
for(i=0;i<8;++i)
{
if (crc&1)
crc=(crc>>1)^0xA001;
else
crc>>=1;
}
return crc & 0xffff;
}

// generates first Sys-EX Block, this switches the interface from operation mode to boot-load mode
int makePrgPrep(unsigned char *str)
{
int i;

unsigned char a[] = { 0xF0, 0x70, 0x7D,0x00,0x16,0x04, 0x02, 0xF7 }; // the switch command string (see makeSysEx for byte value explanation)

for(i=0;i<sizeof(a);i++)
*str++=a[i];
for(;i<70;i++) // 70 bytes * 0,32ms for midi data transmission gives the interface the time to start the bootloader
{
*str++=0;
}
return i;
}
// make a sys-ex data block with proper midi framing and crc from binary data in "block"
int makeSysEx(unsigned char *block, int len, unsigned char *syxTarget)
{
int crc=0xffff;
unsigned int out=0;
int bits=0;
int i;
unsigned char c;

unsigned char *syxStr=syxTarget;

// make CRC
for(i=0;i<len;i++)
{
c=block[i];
crc=crc16(crc, c);
}
block[len++]= ( crc)&0xff;
block[len++]= (crc >>8 ) &0xff;

*syxStr++ = (0xF0); // start sys ex
*syxStr++ = (0x70); // manufacturer id
*syxStr++ = (0x7D); // unit type
*syxStr++ = (0x00); // unit id
*syxStr++ = (0x15); // for normal sysEx it is a adress, here magic byte 1
*syxStr++ = (0x55); // magic byte 2

for(i=0;i<len;i++)
{
c=block[i]; // data byte
/*
Midi data is 7 bit only, as MSB is command/data bit.
So data must be converted to 7 bit.
Each source data byte gives 8/7 target bytes,
as soon as there is one complete byte more (which happens every 7 input bytes)
two target bytes will be generated.
*/
out<<=8;
out|=c;
bits+=8;
while(bits>=7)
{
*syxStr++ = ((out>>(bits-7)) & 0x7f);
bits-=7;
}
}
if(bits) // don't forget about the last bits of the last data byte
{
out<<= 7-bits; // this will pad last byte with up to 6 zero bits.
*syxStr++ = (out & 0x7f);
}
*syxStr++ = 0xF7; // Sys-Ex end

return (int) (syxStr - syxTarget); // lenght of generated data
}

// argv[1] is filename to be converted
int main(int argc, _TCHAR* argv[])
{
FILE *fp;
int minAdr=0xffff;
int maxAdr=0;
int chars=0;
int error=0;
int c;
int val;
int field=-1;
int adress=0;
int cnt;
int sum=0;
int field_len=0;
int type=99;
int line=0;

// the controller allways flashes 64 byte blocks, so the last block is padded with arbitrary data
int padit[]= {110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43,43,43,32,
110,111,114,100,99,111,114,101,32,119,97,115,32,104,101,114,101,32,43 } ;

printf("syx876 Version " VERSION "\nHex-File to Sys-Ex Converter for ATMega88 on MCV876\n");

// 'check' for proper input filename (it must have a "three byte extension" )
// *not* fool proof, try "/../a" and you'll get interesting results
size_t l=strlen(argv[1]);

if(argc !=2 || l<5 || *(argv[1]+l-4)!='.' )
{
printf("\nUsage: syx876 filename.hex\n");
return -1;
}
l -= 3;

fp=fopen (argv[1],"rb"); // open input files

if(fp)
{
// make output file name
*(argv[1]+l)=0;
strcat (argv[1],"syx");

while( (c=fgetc(fp)) != EOF ) // read input hex file
{
chars++;

if(c==':')
{
cnt=0;
field=0;
sum=0;
line++;
}
else if ( conf( (unsigned char) c ) >=0 )
{
if(cnt==0)
val=conf( (unsigned char) c );
else
{
val<<=4;
val += conf( (unsigned char) c );
}
cnt++;

if(cnt==2) // add up checksum
sum+= val;
if( cnt==4)
sum += val & 0xff;

if(field ==0 && cnt==2)
{ // byte count
field_len=val;
field =1;
cnt=0;
}
else if( field ==1 && cnt == 4)
{ // adress
adress=val;
field=2;
cnt=0;
}
else if( field ==2 && cnt == 2)
{ // type
type=val;
field=4;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len>0)
{ // data
field_len--;

if(adress < minAdr)
minAdr=adress;
if(adress>maxAdr)
maxAdr=adress;

if(type==0 && adress < MAX_DATA)
data[adress]=val;
adress++;
cnt=0;
}
else if ( field ==4 && cnt ==2 && field_len == 0)
{ // checksum
cnt=0;
sum &=0xff;
if(sum)
{
error++;
printf("Line %d Checksum error (sum=%d)\n",line, sum);
}
}
}
else if( c !=10 && c !=13)
{
error ++;
printf( "Line %d unexpected character (%c)\n",line, c); // characters I don't know
}
}

printf( "\nread %d charactes, from adress %d to %d with %d errors\n", chars, minAdr, maxAdr,error);

// generate output data
if(error==0 && minAdr==0)
{
int blocks;
int blockNr;
unsigned char block[MAX_SYX_BLOCK]; // buffer to collect/prepare one binary data block
unsigned char stp[MAX_SYX_DATA]; // output data buffer, collects the sysEx data
unsigned char *str; // current write pointer
int adr;
int padded;
FILE *wp;
int i;

str=stp;

blocks= (((maxAdr)/64)+1); // total number of blocks

str+= makePrgPrep(str); // generate sys-ex header (=switch to bootloader command)

// first block is a spezial block - it tells controller number of blocks he has to expect.
blockNr=0;
block[0]=blockNr;
block[1]=blocks;
block[2]=0; // reserved
block[3]=0; // reserved
str += makeSysEx(block,4,str); // generate SysEx from block data

adr=minAdr;
// make flash data blocks
// flash data blocks are 65 bytes, 1 Byte Block number, 64 data bytes
// the controller allways writes 64 byte blocks to flash, so this format
// helps to keep the controller program straight.
while (blockNr<blocks)
{
blockNr++;
block[0]=blockNr; // first data byte in block is block number (so controller sees, when a block is lost)
padded=0;
for(i=0;i<64;i++)
{
if(adr>maxAdr) // it beyond highest adresses from hex file: last block is(must be) padded to 64 bytes
{
block[i+1]=padit[padded];
padded++;
}
else // write programm data
{
block[i+1]=data[adr++];
}
}
str +=makeSysEx(block,65,str);
}

// write output file
wp=fopen(argv[1],"wb");
if(wp)
{
fwrite ((void *) stp ,sizeof(unsigned char), str-stp, wp);
fclose(wp);

printf("%d sysEx data blocks in %d bytes written\n",blocks, str-stp);
}
else
printf("Cant open output file %s\n",argv[1]);
}
else
{
if(minAdr)
printf("Lowest adress %d is not zero!\n",minAdr);
return -2;
}
}
else
printf ("Input file %s not found\n",argv[1]);

return 0;
}

</pre>

MCV876 Controller Update: Source Code

2011-06-23T07:27:24Z

Fetz: /* Quelltext */

=Ü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, 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 [->Link auf Konverter folgt...], und das an den Controller zu schicken. Dann programmiert der sich selber um. Dazu muss er allerdings einmalig mit dem Bootlader [hier Link auf Bootlader imaginieren.. ] programmiert worden sein.

Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, [http://www.mikrocontroller.net 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>/*
MCV876 with ATMega 88

Midi to 4 Channel Control Voltage and six Gates Interface

Preliminary
Version 0.20 2011-06-23

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...

/* ===================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 LEDGATE4 // 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 1 Low nibble CC-Bits, high: interface mode
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.

// to have the clock synced to "beat 1" of a bar ...
volatile unsigned int spp; // song position pointer (from midi message)
unsigned char ticksPerBar=96; // How many ticks per bar (is not tx-ed: guess 96 for 4/4 ... )
volatile unsigned char barTick; // where are we inside the bar (counted, because calculation from spp takes some cpu-cycles )

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 clocker; // timer counter for half a midi-clock (which is needed for divider 1)
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=6;

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
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++;
}
}
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
{
val=cvo->ccVal; // <<1;
/*
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) // Velocity
val+=cvo->velo;
if(config.ifMode2 & (bm<<4)) // PB
val+=cvo->pb;

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=0x80;
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(channel);
else
gate_off(channel);
}
}
}
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>>6);
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=0x80;
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)
clocker++;
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 char syncStartFlag; // start on next 1
}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;
midi.syncStartFlag=1;
midi.clockTick=0;
gate_on(4);
}
else if(midi.startStop) // if (already) running
{
++spp;
++barTick;
if(barTick >= ticksPerBar)
barTick=0;
}
++midi.clockTick; // increment counter for clock output
if(midi.clockTick >= config.clockDivider) // if divider cout elapsed do clock output
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1; // pulse-width counter = half of current midi clock pulse width
}

if(midi.syncStartFlag && barTick==0 && midi.startStop ) // synchronize clock output to bars
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1;
midi.syncStartFlag=0;
}
clocker=0; // restart midi clock pulse width counter.
break;
}
case 0xF9: // Tick (unused)
break;
case 0xFA: // Start
if(! midi.startStop) // if not already running
{
spp=0;
barTick=0;
midi.startFlag=1;
}
break;
case 0xFB: // Continue
if(! midi.startStop) // if not already running
midi.startFlag=1;
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
{
spp= (((int)byte << 7 ) | midi.byte1) * 6;
barTick = spp % (unsigned int) ticksPerBar;
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-=0x2000;
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[3]=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;
}
}
}
}

</pre>

MCV876 Controller Update

2011-06-22T22:44:43Z

Fetz:

= ATMEGA88 CPU für MCV876 Midi Interface =

WARNUNG: Dieser Artikel ist in Arbeit und kann sich jederzeit deutlich ändern.

Das Projekt ist zwar schon recht weit fortgeschritten (sprich: die Software tut, was sie soll), die Dokumentation ist aber derzeit Baustelle und unvollständig.

== Worum geht’s? ==
Das Midi-Interface MCV876 von Marc Bareille hat im Original einen PIC-Controller. Der muss aus Rechenleistungs- und Speichergründen in Assembler programmiert werden, was Wartung und Pflege erschwert.

Hier wird ein alternativer Controller für die gleiche Hardware beschrieben. Mit dem Atmel ATMEGA 88 steht ein halbwegs Pinkompatibler Controller zur Verfügung, der komfortabel in C programmiert werden kann. Um diesen Controller auf der für den PIC gedachten Platine verwenden zu können, ist ein Adapter-Sockel nötig.
Die Software für den ATMEGA ist einiger Hinsicht kompatibel zum Original-Controller. Allerdings ist es kein 100% Clone, einige Funktionen der PIC-Software sind mir auch verborgen geblieben.

Deshalb kann es sehr gut sein, dass die Funktionen abweichen. Diese Beschreibung bezieht sich ausschließlich auf die Software für den ATMEL Controller.
Der Controller wurde mit Blick auf dem Einsatz im Semtex XL (und vergleichbare Mono-Synths) entwickelt, für andere Einsatzfälle mögen Systementscheidungen daher nicht optimal sein.
Die Software ist unter der GPL veröffentlicht. Als Entwicklungsumgebung kommt das (kostenlos verfügbare) ATMEL AVR Studio 4 zum Einsatz. Ist der Controller einmal mit einem Bootlader versehen worden, ist ein Software-Update über Midi im Gerät möglich. Damit kann man mit komplett kostenlos verfügbarer ToolChain und ohne (Programmier-) Hardware eigene Codeänderungen einpflegen.

== Ausstattungsmerkmale ==
Die Beschreibung ist für das komplette Interface, d.h. MCV876 Platine (bzw. der entsprechende Teil auf der SEMTEX-XL Platine) mit dem ATMEGA88 Controller.

'''Hardware'''

4 Spannungsausgänge (CV) von 0-10V

6 Gate Ausgänge 0 auf 5V schaltend.

1 LED „Universalanzeige“

1 Taster.

Midi-Eingang

Midi-Thru Ausgang

(Es gibt keinen Midi-Ausgang, das Interface kann also nicht ausgelesen werden. )
== Funktionsübersicht – Standardbelegung ==
Das Interface kann zwar (über Midi und Sys-Ex Befehle) durchaus unterschiedlich konfiguriert werden. Zunächst aber die Standardbelegung. Die ist einkanalig und monophon.

{| class="table"
|-
|-
| CV 1 || Tonhöhe (Noten) || Gate 1 || Note-ON
|-
| CV 2 || Velocity || Gate 2 || CC 18
|-
| CV 3 || Mod Wheel || Gate 3 || CC 19
|-
| CV 4 || Pitch Bend || Gate 4 || CC 20
|-
| || || Gate 5 || Midi Start/Stop
|-
| || || Gate 6 || Midi Clock /6 (entsprechend 16-tel)
|}

CV 1 und Gate 1 sind die Standardausgänge für den Tonhöhen. und Gate-Eingang des Synths. Die CV ist für 1V/Oktave ausgelegt.
CV2 ist die Anschlagstärke und geht von 0-5V.
CV3 ist der Pitchbender, in Mittelstellung liegen hier 5V an, es geht von 0...10V.
CV4 ist das Modulationsrad, von 0 (Ruhestellung) bis 5V.
= Bedienung =
Im „Normalbetrieb“ gibt es gar nichts zu Bedienen, das Interface setzt eben Midi auf CV & Gate um.

=== Die Leuchtdiode ===
Leuchtet, solange eine Note (=ein Gate) eingeschaltet ist.
Nach dem Einschalten blinkt sie dreimal, um anzuzeigen, dass der Controller lebt.

=== Midi-Kanalwahl ===
Um den Midi Kanal neu Einzustellen die Taste vom Interface drücken, bis die LED leuchtet.
Dann eine Note mit dem gewünschten Kanal am Keyboard spielen. Das Interface stellt sich auf diesen Kanal ein.
Die LED blinkt drei mal, um das permanente Abspeichern des Kanals anzuzeigen.

=== Grund-Note einstellen ===
Die „tiefste Note“, also die Note, bei der das Interface 0 V ausgibt, wird ganz ähnlich wie der Kanal eingestellt. Taste drücken, bis die LED angeht, dann gewünschte tiefste Note spielen.
Die LED blinkt drei mal, um das permanente Abspeichern der Note anzuzeigen.
Controller für CV3 einstellen
Taste drücken, bis die LED angeht, dann einen Controller bewegen. Dieser Controller wird dem dritten Steuerspannungsausgang zugewiesen.
Die LED blinkt drei mal, um das permanente Abspeichern des Controllers anzuzeigen.
(Wo das jetzt hier zum dritten mal leicht unterschiedlich steht: die finstere Wahrheit ist, das jedes mal die komplette Konfiguration gespeichert wird. )

=== Alle Noten aus ===
Taste kurz drücken. Dann werden alle Noten auf „aus“ gesetzt und die Controller auf 0 zurückgestellt.
Da Midi immer nur Datenänderungen überträgt, kann es schon mal zu hängenden Noten und schief stehenden Controllern kommen. Dann hilft ein kurzer Druck auf die Taste.
Das Interface selber sollte das bei korrektem Midi-Datenstrom allerdings niemals alleine fertigbringen. Nur ist nicht jeder Midi-Datenstrom immer korrekt.

=== Active Sense ===
Das Interface wertet Active-Sense Nachrichten aus. Erzeugt der Controller (bzw. das sendende Midi-Interface) Active-Sense und zieht man dann das Midi-Kabel ab, werden (nach 330ms) alle Noten ausgeschaltet.
Roland und Edirol senden das eher mal, die andern eher nicht.

=== Service Funktionen ===
Wird die Taste beim Einschalten festgehalten, kann man zwei Service-Funktionen wählen:
==== Bootlader ====
Wird die Taste beim Einschalten festgehalten und gleich (ähm ... Reaktionszeit eines Dinosauriers ist auch ok... ) losgelassen, wenn die Leuchtdiode zu blinken anfängt, dann kommt man direkt in den "Bootlader", das ist ein spezielles Programm, mit dem man ein Software-Update über Midi einspielen kann. Das braucht man nur, wenn etwas schief gegangen ist (mehr dazu im Abschnitt über Software bauen und eintwickeln). Normalerweise kann man ein Update einfach aufspielen.
Im Bootlader blinkt die Leuchtdiode zwei mal kurz, dann etwas Pause. Das kann durch erneuten Tastendruck, oder Aus- und Einschalten abgebrochen werden.
==== Einstellungen zurücksetzen ====
Wird die Taste beim Einschalten sehr lange festgehalten (knapp 10 Sekunden, bis das Geblinke aufhört), dann werden die Einstellungen des Interfaces gelöscht und auf den Standard zurückgestellt. (Monophon, Midi-Kanal 1)

= Erweiterte Einstellungen =
Der Controller ist Sys-Ex-Kompatibel zum PIC-Controller des MCV876, er lässt sich daher mit dem gleichen PC-Programm einstellen.

Bei der Programmierung wird der Midi-Kanal ignoriert, man kann also nur ein Interface diesen Typs zur Zeit (oder mehrere genau gleich) konfigurieren. Damit die Konfiguration permanent bleibt, muss sie gespeichert werden (Chip-Symbol drücken, LED am Interface blinkt 3 mal. )

Es werden 3 grundsätzliche Betriebsarten (Mode) unterschieden:
Mono (default). 1 Kanal Monophon.

Multi 2. 2 Kanal Monophon

Multi 4. 4 Kanal Monophon

Die weiteren Kanäle werden über den nächsten oder die drei nächsten Midi-Kanäle angesteuert. (Sollte man dabei Kanäle „über 16“ bekommen, kann man diese nicht ansteuern. )

Im DAC-Feld kann für jede CV (=jeden Steuerspannungs-Ausgang) gewählt werden, wie er gesteuert wird.

Ist das CC-Feld aus (nicht grün), dann wird eine Tonhöhenspannung erzeugt. Im „Mono“ Mode ist das ggfls. 4 mal die gleiche, in Multi2 gehören DAC 1 und 2 zum ersten und DAC 3 und 4 zum 2. Midi-Kanal. In Multi 4 gehört jeder DAC zu einem Midi-Kanal.

Ist das PB-Feld aktiv, wird der Pitch-Bend Wert auf die Ausgangsspannung addiert.

Ist das VL-Feld aktiv, wird die Anschlagstärke (Velocity) auf die Ausgangsspannung addiert.

Ist das CC-Feld aktiv, wird der eingestellte Controller als Grundwert genommen, und nicht die Tonhöhe.

Das 5V-Feld schaltet im Tonhöhen-Modus die Ausgabe so um, das ein auf 5V Full-Scale skalierter Wandler 1V/Oktave macht. Das sind dann nur 5 Oktaven, aber doppelt so viele Bits, d.h. die Töne treffen besser.

Im CC-Modus werden die Ccs auf 5V skaliert, nicht auf 10V. Da sie nur 7bittig sind ist das ausreichend, oft sinnvoller skaliert, und dadurch das es einige „Additionen“ gibt generell eher sinnvoll.

Die Gates 1-4 sind den Tonhöhenkanälen fest zugeordnet, gibt ein DAC eine Tonhöhe aus, ist das zugehörige Gate auch Note an/aus.

Ist der DAC auf CC gestellt, kann der Gate-Ausgang einem Controller zugewiesen werden, das Gate ist an, wenn der Controller über den Wert gestellt wird, der bei Tresh.(hold) eingestellt ist.

Duration und Gate 5 im „Triggers“-Feld haben keine Funktion. (Wenn mir dazu was sinnvolles einfällt, dann ändert sich das noch..)

Unter Midi-Clock wird eingestellt, was Gate 6 erzeugt. Midi-Clock sind 24 Ticks pro Viertel-Note. (6=16tel, 12=8tel, 24=1/4)
Gate 5 ist immer Midi-Start/Stop.
= Hardware =
Verwendet wird ein ATMEGA 88.
Der ist gut erhältlich, nicht all zu teuer (um 3.60€) und für die Anwendung ausreichend. Er hat einen getrennten und schütztbaren Bootlader-Bereich und kann (Bootlader-)Code ausführen, während er den Anwenndungs-Programmspeicher ändert. Das ist sehr hilfreich, um beim Update über Midi eine unproblematische Handhabung zu erzielen.

Der Atmel Controller ist nicht völlig pinkompatibel programmierbar, daher ist ein Adaptersockel nötig.

[[File:Adapter-sockel.jpg]]

''So kann der Sockel aussehen''

Oben ist ein normaler 28-poliger DIL-Sockel, unten sind zwei 14 polige Stecksockel von Fischer. ( Conrad 187607 )
(Die drei extra-Pins zur Seite braucht man nicht, die sind nur Anschluss für meinen Debugger.)

Der Verdrahtungplan:

[[File:Adapter.gif]]

Die Pins mit den grünen = werden 1:1 aneinander gelötet, bei den roten X werden die Pins am Sockel weg gekniffen und die Verbindung wird mit einem Draht hergestellt.
= Software =
Der Quelltext für die Controller-Software findet sich hier [[MCV876_Controller_Update:_Source_Code]].

Fertige Files zum runterladen und selber brennen gibt es, wenn die Software fertig getestet ist, "Beta-Tester" werden über das Forum bzw. per Mail versorgt.

MCV876 Controller Update: Source Code

2011-06-22T22:26:25Z

Fetz: Created page with '=Ü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 m…'

=Ü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, 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 [->Link auf Konverter folgt...], und das an den Controller zu schicken. Dann programmiert der sich selber um. Dazu muss er allerdings einmalig mit dem Bootlader [hier Link auf Bootlader imaginieren.. ] programmiert worden sein.

Zu den Atmel Controllern findet man eine Menge Info mit Tante Google, [http://www.mikrocontroller.net 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 [http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf ATMega 88 Datenblatt] ist spätestens dann nötig, wenn es um die Hardware geht.

=Quelltext=
<pre>
/*
MCV876 with ATMega 88

Midi to 4 Channel Control Voltage and six Gates Interface

Preliminary
Version 0.20 2011-06-22

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...

/* ===================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 LEDGATE4 // select your evil...

#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

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 1 Low nibble CC-Bits, high: interface mode
0x82, // mode 2 High Nibble: PB-bits, Low: Velo-Bits
0, // mode 3 (5V-Bits)
};

#define EE_MAGIC 17
unsigned char ee_magic EEMEM;
unsigned char config_eeprom[NUM_PARAMTERS] EEMEM; // Config in EEPROM, saves it during power down.

#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

// to have the clock synced to "beat 1" of a bar ...
volatile unsigned int spp; // song position pointer (from midi message)
unsigned char ticksPerBar=96; // How many ticks per bar (is not tx-ed: guess 96 for 4/4 ... )
volatile unsigned char barTick; // where are we inside the bar (counted, because calculation from spp takes some cpu-cycles )

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 clocker; // timer counter for half a midi-clock (which is needed for divider 1)
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=6;

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
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++;
}
}
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
{
val=cvo->ccVal; // <<1;
/*
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) // Velocity
val+=cvo->velo;
if(config.ifMode2 & (bm<<4)) // PB
val+=cvo->pb;

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=0x80;
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(channel);
else
gate_off(channel);
}
}
}
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>>6);
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=0x80;
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)
clocker++;
if(gate5off)
{
--gate5off;
if(gate5off==0)
gate_off(5);
}

// activ sense
if(watchTicker)
{
watchTicker--;
if(watchTicker==0)
resetAll();
}

// retrigger timing
for(i=0;i<NUM_CV;i++)
{
if(cv_out[i].gateDipper)
{
--cv_out[i].gateDipper;
if(cv_out[i].gateDipper==0)
gate_on(i);
}
}

}

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

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 char syncStartFlag; // start on next 1
}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=160; // every byte is ok, to see that cable is still plugged in

if (byte > 0x7F) // if command byte (MSB set)
{
if(byte>= 0xF8) // if real-time msg
{
switch (byte)
{
case 0xF8: // Clock
{
if(midi.startFlag) // synchronized start
{
midi.startStop=1;
midi.startFlag=0;
midi.syncStartFlag=1;
midi.clockTick=0;
gate_on(4);
}
else if(midi.startStop) // running
{
++spp;
++barTick;
if(barTick >= ticksPerBar)
barTick=0;
}
++midi.clockTick;
if(midi.clockTick >= config.clockDivider) // clock output
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1; // pulse-width == half of a midi clock
}

if(midi.syncStartFlag && barTick==0 && midi.startStop ) // synchronize clock out to bars
{
midi.clockTick=0;
gate_on(5);
gate5off=clocker>>1;
midi.syncStartFlag=0;
}
clocker=0; // restart midi clock pulse width counter.
break;
}
case 0xF9: // Tick
break;
case 0xFA: // Start
spp=0;
barTick=0;
midi.startFlag=1;
break;
case 0xFB: // Continue
midi.startFlag=1;
break;
case 0xFC: // Stop
midi.startStop=0;
gate_off(4);
break;
case 0xFD: // unassigned
break;
case 0xFE: // Active Sense
watchTicker=160;
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)
setSyx(midi.syxAdr, midi.byte1);
midi.msgByteCnt = 0;
}
else if(byte ==SONG_POSITION_POINTER)
{
midi.runningStatus=byte;
midi.msgByteCnt = 0;
return ;
}
midi.runningStatus = 0;
return ;
}

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

// only channel messages left here ...
if(learn)
{
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
{
switch (midi.runningStatus) // last command byte (or zero, if data is not for us)
{
case SONG_POSITION_POINTER:
if(midi.msgByteCnt) // 2nd Byte
{
spp= (((int)byte << 7 ) | midi.byte1) * 6;
barTick = spp % (unsigned int) ticksPerBar;
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): // if we've had a note off byte
if (midi.msgByteCnt) // is second data byte ?
{
midi.msgByteCnt = 0; // clear byte count
note_off(midi.byte1,byte,midi.channel); // switch note off
}
else
{
midi.byte1 = byte;
midi.msgByteCnt = 1; // set counter to get 2nd byte
}
break;
case (PITCH): // PITCH BEND command
if (midi.msgByteCnt) // second data byte (MSB)
{
int v;
v=byte;
v<<=6;
v|=midi.byte1;
v-=0x2000;
setPb(v,midi.channel);

midi.msgByteCnt = 0; // clear byte count
}
else
{
midi.byte1 = byte;
midi.msgByteCnt = 1; // set counter to get next byte
return;
}
break;
case (CC): // Continuous Controller Message
if (midi.msgByteCnt) // if we've had first byte
{
midi.msgByteCnt = 0; // clear byte count

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

setCC(midi.byte1, byte,midi.channel);
}
else
{
midi.byte1 = byte;
midi.msgByteCnt = 1; // set counter ready to get 3rd byte
return;
}
break;
// case (CHAN_PRES): // if channel pressure command
// channel_pressure (byte); // set Aftertouch
case SYSEX:
midi.msgByteCnt++;
switch(midi.msgByteCnt)
{
case 1: // Manufactorer
if(byte==0x70)
;
else
midi.msgByteCnt=0;
break;
case 2: // Unit - ID
if(byte==0x7D)
;
else
midi.msgByteCnt=0;
break;
case 3: // Midi-Adress (ignored!)
if(byte<0x10)
;
else
midi.msgByteCnt=0;
break;
case 4: // adress byte
midi.syxAdr=byte;
break;
case 5: // high data nibble
if(byte<0x10)
{
midi.byte1=(byte<<4);
}
else
midi.msgByteCnt=0;
break;
case 6: // low data nibble
if(byte<0x10)
{
midi.byte1 |= byte;
}
else
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;
}
}
}
}

</pre>

MCV876 Controller Update

2011-06-22T06:10:37Z

Fetz: /* Bedienung */

MCV876 Controller Update

2011-06-21T21:09:07Z

Fetz:

Datei:Adapter.gif

2011-06-21T21:04:27Z

Fetz: Verdrahtungsplan des Adaptersockels (A=Atmel-Pins, P=Platinen-Pins)

Verdrahtungsplan des Adaptersockels
(A=Atmel-Pins, P=Platinen-Pins)

Datei:Adapter-sockel.jpg

2011-06-21T20:52:44Z

Fetz: Adapter-Sockel um den Atmel-Controller in einen PIC-sockel stecken zu können. Die drei Pins an der Seite sind nur für Debug-Zwecke nötig, nicht für den normalen Einsatz.

Adapter-Sockel um den Atmel-Controller in einen PIC-sockel stecken zu können. Die drei Pins an der Seite sind nur für Debug-Zwecke nötig, nicht für den normalen Einsatz.