MIDI to Voltage mit diskretem DAC

[Oliver F. (ollif)]

Hallo,

ich arbeite gerade an der Software zur Ansteuerung meines diskret 
aufgebauten DA Wandler Board. Neben der MIDI Impementierung soll auch 
ein 61 Tasten Manual ausgewertet werden. Habe jetzt bedenken dass das 
alles nicht schnell genug ist.

Die Erzeugung der Gate, CLK und Reset Signale funktioniert so weit.
Nur habe ich auf dem Logik Analyser immer wieder Abschnitte auf dem mein 
CLK Signal "breit" wird (siehe Screen shoots). Hat jemand eine Idee an 
was das liegen könnte?

Als Prozessor kommt ein Atmel 2560 auf einem Arduino MEGA 2560 zum 
Einsatz.

Das Signal wurde wie folgt aufgenommen:
Taste auf Midi Keyboard gedrückt und auf dem GATE1 Ausgang den LA 
getriggert.

/*
 * MIDI to Voltage Converter for using my discrete DAC Board
 * Link to schematic: http://itist.de/wordpress/wp-content/uploads/2013/11/Discrete-DAC-Sch.pdf
 * The programm has the following functions:
 
 * creating up to 8 Gate outputs                  Working  Version 0.1.10  
 * creating a CLK output for the multiplexing            Working  Version 0.1.10
 * creating a RESET output when the first Voice is transmitted    Working  Version 0.1.10

 *            __    __    __    __    __    __    __    __
 * CLK      _|  |__|  |__|  |__|  |__|  |__|  |__|  |__|  |_

 * Channel    1     2     3     4     5     6     7     8
 *          __
 * RESET  _|  |____________________________________________


 * Creating the Output for the Octave Voltage
 * Creating the Output for the Key Voltage
 
 * Creating the (monophonic) Aftertouch Voltage with the internal PWM
 * Creating the Pitchbend Voltage with internal PWM
 * Creating the Mod wheel Voltage with internal PWM
 
 
 
 * Author: Oliver Fischhaupt
 * Created:16.05.2014
 * Version 0.1.10
 */


#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 16000000UL
#endif


#define BAUD 31250UL      // Baudrate

// Calculating the Baudrate
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // Rounding
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Real Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Calculating the Error in Promille, 1000 = NoError.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Error in Baudrate is larger 1% !
#endif


#define NUM_VOICES    4      // Number of Voices
#define MIDI_CHANNEL  0      // MIDI Channel

#define LOW        0
#define HIGH      1

// MIDI Messages
#define NOTE_ON         0x90    // Midi note on message
#define NOTE_OFF        0x80    // Midi note off message
#define PITCH           0xE0    // pitch bender (Not Implemented yet)
#define AFTERTOUCH      0xD0        // after touch command (Not Implemented yet)
#define CC            0xB0        // Continuous Controller (Not Implemented yet)
#define CHAN_PRES      0xD0        // Channel Pressure (Not Implemented yet)


void init_USART(void)
{
  UCSR3B |= 0x08;          //UART TX (Transmit enable)
  UCSR3B |= 0x10;          //UART RX (Receive enable)
  UCSR3B |= 0x80;          //RX Interrupt enable
  UCSR3C |= 0x00;          //Mode Async 8N1 (8 Databits, No Parity, 1 Stopbit)
  UCSR3C |= 0x04;
  UCSR3C |= 0x02;  
  UCSR3A = 0x00;          
                    
  UBRR3H = 0;            //Highbyte is 0
  UBRR3L = UBRR_VAL;        //Lowbyte 
}


volatile unsigned char  action = 2;        //0 =note off ; 1=note on ; 2= nothing
volatile unsigned char  key = 0 ;
volatile unsigned char  velocity = 0;

volatile unsigned char voice = 0;
volatile unsigned char lastVoice = 0;
volatile unsigned char nextVoice = 0;

// ARRAYS for GATES and used Voices
volatile unsigned char voices [] = {LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW};
volatile uint8_t gates [] =  {LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW};



// DECIMAL to BINARY NOT USED 
unsigned char voiceCounter1 [] = {LOW,HIGH,LOW,HIGH,LOW,HIGH,LOW,HIGH};
unsigned char voiceCounter2 [] = {LOW,LOW,HIGH,HIGH,LOW,LOW,HIGH,HIGH};
unsigned char voiceCounter4 [] = {LOW,LOW,LOW,LOW,HIGH,HIGH,HIGH,HIGH};
  
/*Port Mapping Arduino MEGA2560 Board

PORTB Gate Output
Pin Name    Mapped Pin Name    Function
PB0        Digital Pin53    GATE 1
PB1        Digital Pin52    GATE 2
PB2        Digital Pin51    GATE 3
PB3        Digital Pin50    GATE 4
PB4        Digital Pin10    GATE 5
PB5        Digital Pin11    GATE 6
PB6        Digital Pin12    GATE 7
PB7        Digital Pin13    GATE 8

PORTA Note Output
Pin Name    Mapped Pin Name    Function
PA0        Digital Pin22    LOW NOTEA 
PA1        Digital Pin23    LOW NOTEB 
PA2        Digital Pin24    LOW NOTEC
PA3        Digital Pin25    HIGH NOTEA
PA4        Digital Pin26    HIGH NOTEB  
PA5        Digital Pin27    HIGH NOTEC
PA6        Digital Pin28    LOW CS
PA7        Digital Pin29    HIGH CS

PORTC OCT Output, CLK and Reset
Pin Name    Mapped Pin Name    Function
PC0        Digital Pin37    OCTA
PC1        Digital Pin36    OCTB
PC2        Digital Pin35    OCTC
PC3        Digital Pin34    OCT CS
PC4        Digital Pin33    CLK
PC5        Digital Pin32    RESET
PC6        Digital Pin31    NA
PC7        Digital Pin30    NA

*/
  
void noteOff(unsigned char channel, unsigned char pitch, unsigned char velocity)
{
  for(int i = 0 ;i < NUM_VOICES;i++)
  {
    if(voices [i] == pitch)
    {
      gates[i] = LOW;
    }
  }
}

void noteOn(unsigned char channel, unsigned char pitch, unsigned char velocity)
{
  if (velocity == 0 )
  {
    noteOff(channel, pitch, velocity );
  }
  else
  {
    gates[nextVoice] = HIGH;
    voices [nextVoice]= pitch;
    nextVoice++;
    
    if(nextVoice ==NUM_VOICES)
    {
      nextVoice = 0;
    }
  }
}


int main(int argc, char **argv) {
  init_USART();
  
  DDRA = (1 << PA0) | (1 << PA1) | (1 << PA2) | (1 << PA3) | (1 << PA4) | (1 << PA5) | (1 << PA6) | (1 << PA7);
  DDRB = (1 << PB0) | (1 << PB1) | (1 << PB2) | (1 << PB3) | (1 << PB4) | (1 << PB5) | (1 << PB6) | (1 << PB7);                                // PB7 an PORTB als Ausgang setzen
  DDRC = (1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC3) | (1 << PC4) | (1 << PC5);
  
  sei();
  while (1)
  {
    uint8_t tmp = 0;
    for(voice = 0 ;voice < NUM_VOICES ;voice++)
    {
      if(voice ==0)
      {
        PORTC |= (1<<PC5);    //Generating the Reset Signal High
        
      }
      PORTC ^= (1<<PC4);      //Generating the Clock Signal
      PORTC &= ~ (1<<PC5);    //Generating the Reset Signal Low

      PORTA = key;        //output Key NOT IMPLEMENTED
    
      
      tmp >>= 1;
      if( gates[voice] == HIGH)
      {
  
        tmp |= (1 << 7);
      }

      PORTC ^= (1<<PC4);      //Generating the Clock Signal
      
      
      
      //TODO
      //CS Octave
      //Octave Output
      //CS Note
      //Note Output
    }
    PORTB = tmp;  //GATE Output

    
  }
}




#define FRAMING_ERROR (1<<FE3)
#define PARITY_ERROR (1<<UPE3)
#define DATA_OVERRUN (1<<DOR3)

ISR(USART3_RX_vect)
{
    unsigned char status,byte;
    status = UCSR3A;
    byte   = UDR3;
    
    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0 )
    {
      if (byte == NOTE_ON)
      {
        action = 1;
      }
      else if (byte == NOTE_OFF)
      {
        action = 0;
      }
      else if (byte == AFTERTOUCH)
      {
        //TO BE IMPLEMENTED
      }
      else if ((action==0)&&(key==0) )
      { // if we received a "note off", we wait for which note (databyte)
        key=byte;
        noteOff(1,key,0);
        key=0;
        velocity=0;
        action=2;
      }
      else if ( (action==1)&&(key==0) )
      { // if we received a "note on", we wait for the note (databyte)
        key=byte;
      }
      else if ( (action==1)&&(key!=0) )
      { // ...and then the velocity
        velocity=byte;
        noteOn(1,key,velocity);
        key=0;
        velocity=0;
        action=0;
      }
    }
}

Gerne auch Anregungen für andere Verbesserungen.

Vielen Dank im Voraus.


Gruß

Oliver

[Oliver F. (ollif)]

Hallo,

Oliver F. schrieb:
> Nur habe ich auf dem Logik Analyser immer wieder Abschnitte auf dem mein
> CLK Signal "breit" wird (siehe Screen shoots). Hat jemand eine Idee an
> was das liegen könnte?

ich denke ich habe hierfür die Ursache gefunden. Es ist die Interrupt 
Routine die bei jedem ankommenden MIDI Signal ausgelöst wird.
Alle 86mS kommt hier ein Signal an ob ich was Spiele oder nicht.
Active Sensing sollte alle 300mS etwas senden.

Vielleicht liegt das an der MIDI Implementierung meines DX7.
Dieser sendet ja auch kein NoteOff sondern NoteOn mit Velocity 0.

Die Verarbeitung dauert 1,7µS. Habe nochmal ein Screen shot gemacht.

Hierzu habe ich in der Interrupt Routine am Anfang ein Port auf High und 
am Ende der Routine auf Low gesetzt und darauf getriggert.

Die Verarbeitung eines NoteOn Events dauert 5,3µS.

Bringt es etwas wenn ich in der Interrupt Anweisung die Funktionsaufrufe 
vermeide? Oder macht das der Compiler für mich?


Gruß

Oliver