Arduino MIDI Controller

Arduino MIDI controller
Controlador MIDI basado en Arduino UNO. MIDI controller based on Arduino UNO.
sbado, 8 de marzo de 2014
"Unexpected end of file" at startup of CvPcb

Al cargar los modulos en kicad a veces pasa esto cuando han sido modificados o importados de bibliotecas como por
ejemplo Eagle
"Unexpected end of file" at startup of CvPcb
La solucion que he encontrado es esta, y de momento me ha funcionado.
aadir al final del archivo que d el error $EndLIBRARY.
https://bugs.launchpad.net/kicad/+bug/872315
Salud.
Publicado por Pulse en 11:29 No hay comentarios:
Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
mircoles, 11 de diciembre de 2013
Cdigo controlador MIDI

Para poder compilar el cdigo debo en primer lugar indicar que utilizo las siguientes librerias:
MIDI: http://playground.arduino.cc/Main/MIDILibrary
U8glib: http://code.google.com/p/u8glib/
M2tklib: http://code.google.com/p/m2tklib/ ( no es imprescindible, pero si alguien se anima a modificar cosas, esta es sin
duda una herramienta de gran ayuda )
El cdigo lo hice en diferentes archivos, teneis el principal y a continuacin los ".h" que componen el total del cdigo.
Podeis aadir con el IDE que viene por defecto en Arduino los archivos .h tal y como se indica aqui:
http://arduino.cc/es/Guide/Environment
To compile the code I must first state that I use the following libraries:
MIDI: http://playground.arduino.cc/Main/MIDILibrary
U8glib: http://code.google.com/p/u8glib/
M2tklib: http://code.google.com/p/m2tklib/ (not required, but if anyone is encouraged to changethings, this is definitely
a useful tool)
I did the code in different files, you have the main and then. "H" that make up the total code. .IDE you can add to
the default one h files in Arduino as shown here:
http://arduino.cc/es/Guide/Environment
Cdigo principal / Main code:

//
//
// Changelog:
// 20120818: fixes
// 20120813: cleanup
// 2012????.Albert: implementation
// http://en.wikipedia.org/wiki/The_C_Programming_Language
#include
#include "avr/pgmspace.h"
#include "potenciometros_y_display.h"
#include "CC_defs.h"
#include "constants.h"
#include "U8glib.h"
U8GLIB_ST7920_128X64 u8g(3, 5, 6, 9, 10, 11, 7, 8, 13, U8G_PIN_NONE, U8G_PIN_NONE, 12,

4); // 8Bit Com: D0..D7: 3, 5, 6, 9, 10, 11, 7, 8 en=13, di=12,rw=4
ControlStatus current_status;
//#define DEBUG_MENU
//#define DEBUG_KNOBS
//#define DEBUG_MIDI
//#define ENCODER
//#define ENCODER_PRIMER_PASO
//#define ENCODER_SEGUNDO_PASO
//#define BOTON_PULSADO
//#define SALIDA
void setup() // -------------------------------------------------------------------------

----------------------------------------------------------
{
#if defined(DEBUG_MENU) || defined(DEBUG_MIDI) || defined(ENCODER) || defined(SALIDA) ||
defined(ENCODER_PRIMER_PASO) || defined(ENCODER_SEGUNDO_PASO) || defined(BOTON_PULSADO)
|| defined(DEBUG_KNOBS)
Serial.begin(9600);
#else
MIDI.begin(MIDI_CHANNEL_OMNI); // de esta manera recibe os 16 canales
#endif
ControlStatus_Init(&current_status);
}
void loop()
{
static unsigned int clock = 0;
const unsigned int period = 100;
input_update(&current_status);
if ((clock % period) == 0) // trigger every 'period' (e.g. 1 every 5 times)

{
input_update(&current_status);//zz!
// clock: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// clock % period: 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0
screen_update(&current_status);
output_update(&current_status);
}
}
//------------- EMPIEZAN LAS FUNCIONES-------------------------------------------
void input_update(ControlStatus *cs)

{
// Menu and submenu handling:
#ifdef ENCODER
char btmp[127];
sprintf(btmp, "cs->encoder.encoder_target %i", cs->encoder.encoder_target);
Serial.println(btmp);//zz
#endif
switch ( cs->encoder.encoder_target ) // Vale 0

{
case MenuEncoderNdx:
cs->encoder.positions[cs->encoder.encoder_target] = update_from_encoder(cs, cs-

>encoder.positions[cs->encoder.encoder_target], NUM_MENUS);//NUM_MENUS
/*
int update_from_encoder(ControlStatus *cs, int enc_pos, int x);
int update_from_encoder = ( Paso de la estructura, parametro del valor de la funcion de

encoder, valor maximo que puede alcanzar en este caso NUM_MENUS )
ejemplo:
update_from_encoder(cs, cs->encoder.positions[cs->encoder.encoder_target], NUM_MENUS): 3

cs->encoder.positions[cs->encoder.encoder_target]: 3
Valor de cs->encoder.encoder_target: 0
update_from_encoder(cs, cs->encoder.positions[cs->encoder.encoder_target], NUM_MENUS): 4

cs->encoder.positions[cs->encoder.encoder_target]: 4
Valor de cs->encoder.encoder_target: 0
*/
#ifdef ENCODER_PRIMER_PASO
char btmp[127];
char btmp1[127];
char btmp2[127];
sprintf(btmp, "cs->encoder.positions[cs->encoder.encoder_target]: %i", cs-
>encoder.positions[cs->encoder.encoder_target]);
sprintf(btmp1, "update_from_encoder(cs, cs->encoder.positions[cs-
>encoder.encoder_target], NUM_MENUS): %i", update_from_encoder(cs, cs-
>encoder.positions[cs->encoder.encoder_target], NUM_MENUS));
sprintf(btmp2, "Valor de cs->encoder.encoder_target: %i", cs->encoder.encoder_target );
Serial.println(btmp1);//zz
Serial.println(btmp);
Serial.println(btmp2);
Serial.println("\n");
,
#endif
if (update_from_button(&current_status) == BUTTON_PRESSED)
{
switch (cs->encoder.positions[MenuEncoderNdx]
{
case ME_KnobGroup:
cs->encoder.encoder_target = KnobGroupEncoderNdx;
break;
case ME_Knob:
cs->encoder.encoder_target = KnobEncoderNdx;
break;
case ME_ControlChange:
cs->encoder.encoder_target = ControlChangeEncoderNdx;
break;
case ME_MidiChannel:
cs->encoder.encoder_target = MidiChannelNdx;
break;
case ME_Behavior:
cs->encoder.encoder_target = BehaviorNdx;
break;
}
#ifdef ENCODER_SEGUNDO_PASO
char btmp[127];
char btmp1[127];
char btmp2[127];
sprintf(btmp, "cs->encoder.positions[cs->encoder.encoder_target]: %i", cs-
>encoder.positions[cs->encoder.encoder_target]);
sprintf(btmp1, "update_from_encoder(cs, cs->encoder.positions[cs-
>encoder.encoder_target], NUM_MENUS): %i", update_from_encoder(cs, cs-
>encoder.positions[cs->encoder.encoder_target], NUM_MENUS));
sprintf(btmp2, "Valor de cs->encoder.encoder_target: %i", cs->encoder.encoder_target );
Serial.println(btmp1);//zz
Serial.println(btmp);
Serial.println(btmp2);
Serial.println("\n");
#endif
}
update_encoder_targets(cs);
break;
case KnobGroupEncoderNdx:// -------------------------------------------------------------

---------------------Case-0
// Serial.println("Knob group");
cs->encoder.positions[cs->encoder.encoder_target] =
update_from_encoder(&current_status, cs->encoder.positions[cs->encoder.encoder_target],
NUM_KNOB_GROUPS);
#ifdef DEBUG_MENU
sprintf(btmp, "KnobGroupEncoderNdx: %i", cs->encoder.positions[cs-
>encoder.encoder_target]);
#endif
if (update_from_button(&current_status) == BUTTON_RELEASED) // pressed

{
cs->encoder.encoder_target = MenuEncoderNdx; // Return to menu.
}
break;
case KnobEncoderNdx: // -----------------------------------------------------------------

---------------------Case-1
// Serial.println("Knob");
NUM_KNOBS);
#ifdef DEBUG_MENU
sprintf(btmp, "KnobEncoderNdx: %i", cs->encoder.positions[cs->encoder.encoder_target]);
#endif

{
cs->encoder.encoder_target = MenuEncoderNdx; // Return to menu.
}
break;
case MidiChannelNdx: // -----------------------------------------------------------------

---------Case-2
// Canal Midi
// #include"canalMIDI.h"
// Serial.println("Canal Midi");
NUM_MIDI);
#ifdef DEBUG_MENU
sprintf(btmp, "MidiChannelNdx: %i", cs->encoder.positions[cs->encoder.encoder_target]);
#endif
if (update_from_button(&current_status) == BUTTON_RELEASED)
{
// Assign midi channel
int group = cs->encoder.positions[KnobGroupEncoderNdx];
int knob = cs->encoder.positions[KnobEncoderNdx];
cs->knobs[group].channel[knob] = cs->encoder.positions[cs->encoder.encoder_target];
// Return to menu:
cs->encoder.encoder_target = MenuEncoderNdx;
}
break;
case ControlChangeEncoderNdx: // --------------------------------------------------------

-----------------Case-3
// Control Change
// Serial.println("Control Change");
NUM_CONTROL_CHANGE);
#ifdef DEBUG_MENU
sprintf(btmp, "ControlChangeEncoderNdx: %i", cs->encoder.positions[cs-
>encoder.encoder_target]);
#endif
{
// Assign control change:
int group = cs->encoder.positions[KnobGroupEncoderNdx];
int knob = cs->encoder.positions[KnobEncoderNdx];
cs->knobs[group].control_change[knob] = cs->encoder.positions[cs-
>encoder.encoder_target];
// Return to menu:
cs->encoder.encoder_target = MenuEncoderNdx;
}
break;
case BehaviorNdx: // --------------------------------------------------------------------

------------------Case-4
#ifdef DEBUG_MENU
sprintf(btmp, "BehaviorNdx: %i", cs->encoder.positions[cs->encoder.encoder_target]);
#endif
cs->encoder.encoder_target = MenuEncoderNdx; // Unimplemented:

// return to menu.
break;
}//switch
// Read knob data:

input_update_knobs(cs);
void output_update(ControlStatus *cs)

{
// Update MIDI parameters, if required:
output_update_midi(cs);
}
void screen_update(ControlStatus *cs)

{
// Prepare LCD for drawing:
u8g.firstPage();
// Draw frame and constant parts:

do
{
// Draw frame and constant parts:
lcd_draw_header();
// Dynamic data:
lcd_draw_menu(cs);
lcd_draw_knob(cs);
input_update(cs);
}
while (u8g.nextPage());
}
int update_from_button(ControlStatus * cs)
{
// read the pushbutton input pin:
int salida = BUTTON_IDLE; // Initialize, always
if (cs)
{
cs->button.buttonState = digitalRead(PIN_Button); // PIN_Button = 2;
// compare the buttonState to its previous state

if (cs->button.buttonState != cs->button.lastButtonState)
{
// if the state has changed, increment the counter
if (cs->button.buttonState == HIGH)
{
// if the current state is HIGH then the button
// wend from off to on:
cs->button.buttonPushCounter++;
#ifdef BOTON_PULSADO
Serial.println("on");
Serial.print("number of button pushes: ");
Serial.println(cs->button.buttonPushCounter);
#endif
salida = BUTTON_PRESSED;
}
else
{
// if the current state is LOW then the button
// wend from on to off:
#ifdef DEBUG_MENU
Serial.println("off");
#endif
salida = BUTTON_RELEASED;
}
}
// save the current state as the last state,
// for next time through the loop
cs->button.lastButtonState = cs->button.buttonState;
#ifdef SALIDA
Serial.print(salida == BUTTON_PRESSED? "BUTTON_PRESSED" : salida == BUTTON_RELEASED?
"BUTTON_RELEASED" : "" );
#endif
return salida;
}
int update_from_encoder(ControlStatus *cs, int enc_pos, int x)

{
if (cs)
{
int lecturaPin = digitalRead(PIN_Encoder0A);
if ((cs->encoder.ultimaPosicionPinA == HIGH) && (lecturaPin == LOW))
{
if (digitalRead(PIN_Encoder0B) == HIGH)
{
#ifdef DEBUG_MENU
Serial.println("-");
#endif
enc_pos--;
// lcd.clear();
}
else
{
#ifdef DEBUG_MENU
Serial.println("+");//zz!
#endif
enc_pos++;
// lcd.clear();
}
}
cs->encoder.ultimaPosicionPinA = lecturaPin;
if (enc_pos < 0)
{
#ifdef DEBUG_MENU
Serial.println("- [0]");//zz!
#endif
enc_pos = 0;
}
if (enc_pos > x)
{
enc_pos = x;
}
}
return enc_pos;
}
void input_update_knobs(ControlStatus * cs)

{
const int inputs[NUM_KNOBS] = { A3, A2, A1, A0 };
const int knob_group = cs->encoder.positions[KnobGroupEncoderNdx];
for ( int i = 0; i < NUM_KNOBS; i++ )

{
const int raw_input = analogRead(inputs[i]);
const int ADC_res_bits = 10;
const int meaning_adc_bits = 4; // Use 4 of the 10 ADC bits (e.g. 2**4 = 16 steps instead
of 2**10 = 1024)
const int remove_mask = ~(1 << (ADC_res_bits - meaning_adc_bits)) - 1;
const int knob_current_value = raw_input & remove_mask; // = (raw_input / 64) * 64;
if ( cs->knobs[knob_group].knob[i] != knob_current_value ) // knob changed?
{
delay(10);
cs->knobs[knob_group].knob[i] = knob_current_value;
#ifdef DEBUG_KNOBS
char btmp[32];
sprintf(btmp, "knob[%i, %i]: %i",
knob_group, i, knob_current_value);
Serial.println(btmp);//zz!
#endif
}
}
}
void lcd_draw_knob(ControlStatus * cs)

{
u8g.setFont(u8g_font_micro);

{
const int value = map(cs->knobs[knob_group].knob[i], 0, 1023, 0, 20);
const int pct = map(cs->knobs[knob_group].knob[i], 0, 1023, 0, 107);
// X, Y ; ancho , alto Linea vertical mas estrcha (debajo del restangulo )

// rectangulo que sube o baja
u8g.drawLine(2 + 20 * i, 60, 2 + 20 * i, 40);

u8g.drawBox(1 + 20 * i, (60 - value), 3, 100);
// Knob %
u8g.drawStr(1 + 20 * i + 6, 64 - value, strcpy_P(buzzer, (char
*)pgm_read_word(&(strin_table[pct])))); // sample
}
}
void lcd_draw_header()
{
u8g.drawFrame(79, 0, 49, 64); // X, Y ; ancho , alto Recuadro grupo
u8g.drawLine(0, 30, 79, 30); // linea entre el texto y los potes
u8g.drawLine(0, 37, 79, 37); // "" ""
u8g.drawLine(79, 24, 128, 24); // linea separadora grupo y auto
}
void indicador_de_pulsacion(ControlStatus * cs)

{
//u8g.setFont(u8g_font_6x10);
u8g.drawStr( 80, 15,"d" );
}
void lcd_draw_menu(ControlStatus *cs)

{
u8g.setFont(u8g_font_micro);
const int font_width = 4; // 4 point-wide font
const int font_height = 6; // 6 point-tall font
const int menu_pos = cs->encoder.positions[MenuEncoderNdx];
// Draw cursor:
u8g.drawStr(1, 5 + (menu_pos * font_height), ">");
// Draw menu entries:

for ( int i = 0; i < ME_Elems; i++ )
{
// Draw text:
u8g.drawStr(8, 5 + i*font_height, menu_labels[i]);

if ( i != ME_ControlChange ) // Draw all except CC
{
// Draw value:
//const int text_offset = (strlen(menu_labels[i]) ) * font_width;
const int text_offset = (strlen(menu_labels[i]) ) * font_width;
const int value = cs->encoder.positions[i+1];

const char *text = value >= 0 && value <= MAX_strin? (char
*)pgm_read_word(&(strin_table[value])) : "???!";
u8g.drawStr(8 + text_offset, 5 + i*font_height, strcpy_P(buzzer, text));
}
}
// Draw extra elements:
const int cc_text_offset = (strlen(menu_labels[ME_ControlChange]) + 1) * font_width;

const int value = cs->encoder.positions[ControlChangeEncoderNdx];
const char *cc_text = value >= 0 && value <= MAX_string? (char
*)pgm_read_word(&(string_table[value])) : "???!";
u8g.drawStr(8 + cc_text_offset, 5 + ME_ControlChange*font_height, strcpy_P(buffer,
cc_text)); // Muestra el porcentaje que se mueve
void output_update_midi(ControlStatus *cs)

{

{
const int midi_channel = cs->knobs[knob_group].channel[i];
const int cc = cs->knobs[knob_group].control_change[i];
const int value = map(cs->knobs[knob_group].knob[i], 0, 1023, 0, 137);
if ( midi_channel >= 0 && midi_channel < NUM_MIDI && cs->midi_status[midi_channel].cc !=

cc || cs->midi_status[midi_channel].knob_value != value )
{
cs->midi_status[midi_channel].cc = cc;
cs->midi_status[midi_channel].knob_value = value;
MIDI.sendControlChange(cc,value,midi_channel);
//sendControlChange (byte ControlNumber, byte ControlValue, byte Channel)
}
}
}
void ControlStatus_Init(ControlStatus * cs)

{
memset(cs, 0, sizeof(ControlStatus));
cs->button.buttonPushCounter = 1; // Counter for the number of button presses

cs->button.buttonState = 1; // Current state of the button
cs->button.lastButtonState = 0; // Previous state of the button
cs->encoder.encoder_target = 0;
cs->encoder.ultimaPosicionPinA = LOW;
for ( int i = 0; i < NUM_KNOB_GROUPS; i++ )
{
for ( int j = 0; j < NUM_KNOBS; j++ )
{
cs->knobs[i].knob[j] = 0;
cs->knobs[i].behavior[j] = 0;
cs->knobs[i].control_change[j] = 0;
cs->knobs[i].channel[j] = 0;
}
}
for ( int i = 0; i < NUM_MIDI; i++ )
{
cs->midi_status[i].cc = 0;
cs->midi_status[i].knob_value = 0;
}
}
void update_encoder_targets(ControlStatus *cs)

{
const int knob_group = MAX(0, cs->encoder.positions[KnobGroupEncoderNdx]);
const int knob = MAX(0, cs->encoder.positions[KnobEncoderNdx]);
cs->encoder.positions[ControlChangeEncoderNdx] = MAX(0, cs-
>knobs[knob_group].control_change[knob]);
cs->encoder.positions[MidiChannelNdx] = MAX(0, cs->knobs[knob_group].channel[knob]);
cs->encoder.positions[BehaviorNdx] = MAX(0, cs->knobs[knob_group].behavior[knob]);

}
------------------------------------------------------------------ CC_defs.h
// Changelog:
// 20120813: cleanup
#ifndef CC_defs_h
#define CC_defs_h
char buffer[16];
prog_char string_0[] PROGMEM = "00-BankSelMSB"; // "String 0" etc are strings to store -
change to suit.
prog_char string_1[] PROGMEM = "01-Mod Wheel";
prog_char string_2[] PROGMEM = "02-Breath Cntrl";
prog_char string_3[] PROGMEM = "03-CC 03";
prog_char string_4[] PROGMEM = "04-Foot Cntrl";
prog_char string_5[] PROGMEM = "05-Porta Time";
prog_char string_6[] PROGMEM = "06-Data Entry"; // "String 0" etc are strings to store -
change to suit.
prog_char string_7[] PROGMEM = "07-Volume";
prog_char string_8[] PROGMEM = "08-Balance";
prog_char string_10[] PROGMEM = "10-Pan";
prog_char string_11[] PROGMEM = "11-Expression ";
prog_char string_12[] PROGMEM = "12-fx Cntrl 1";
prog_char string_13[] PROGMEM = "13-fx Cntrl 2";
prog_char string_16[] PROGMEM = "16-GPCntrl1LSB1";
prog_char string_32[] PROGMEM = "32-BankSelLSB";
prog_char string_33[] PROGMEM = "33-Mod Wheel LSB";
prog_char string_34[] PROGMEM = "34-Breath Cntrl LSB";
prog_char string_36[] PROGMEM = "36-Foot Cntrl LSB";
prog_char string_37[] PROGMEM = "37-Porta Time LSB";
prog_char string_38[] PROGMEM = "38-Data Entry LSB";
prog_char string_39[] PROGMEM = "39-Volume LSB";
prog_char string_40[] PROGMEM = "40-Balance LSB";
prog_char string_42[] PROGMEM = "42-Pan LSB ";
prog_char string_43[] PROGMEM = "43-Expression LSB";
prog_char string_44[] PROGMEM = "44-fx 1 LSB ";
prog_char string_45[] PROGMEM = "45-fx 2 LSB";
prog_char string_48[] PROGMEM = "48-GPCntrl1LSB ";
prog_char string_51[] PROGMEM = "51-GPCntrl4LSB";
prog_char string_64[] PROGMEM = "64-Damper Pedal";
prog_char string_65[] PROGMEM = "65-Porta Pedal";
prog_char string_66[] PROGMEM = "66-Sostenuto";
prog_char string_67[] PROGMEM = "67-Soft Pedal";
prog_char string_68[] PROGMEM = "68-Legato Foot Sw";
prog_char string_69[] PROGMEM = "69-Hold-2";
prog_char string_70[] PROGMEM = "70-Sound Vari";
prog_char string_71[] PROGMEM = "71-Timbre/Harmonics";
prog_char string_72[] PROGMEM = "72-Realease Time";
prog_char string_73[] PROGMEM = "73-Attack Time";
prog_char string_74[] PROGMEM = "74-Brighness";
prog_char string_75[] PROGMEM = "75-Decay Time";
prog_char string_76[] PROGMEM = "76-Vib.Rate";
prog_char string_77[] PROGMEM = "77-Vib.Depth";
prog_char string_78[] PROGMEM = "78-Vib.Delay";
prog_char string_79[] PROGMEM = "79-Sound Ctrl10";
prog_char string_80[] PROGMEM = "80-GeneralPurp10 ";
prog_char string_81[] PROGMEM = "81-GeneralPurp6";
prog_char string_84[] PROGMEM = "84-PortaCntrl";
prog_char string_91[] PROGMEM = "91-Reverb Depth";
prog_char string_92[] PROGMEM = "92-Tremolo Depth";
prog_char string_93[] PROGMEM = "93-Chorus Depth";
prog_char string_94[] PROGMEM = "94-Detune Depth";
prog_char string_95[] PROGMEM = "95-Phaser Depth";
prog_char string_96[] PROGMEM = "96-Data Inc";
prog_char string_97[] PROGMEM = "97-Data Dec";
prog_char string_98[] PROGMEM = "98-NRPN LSB";
prog_char string_99[] PROGMEM = "99-NRPN-MSB";
prog_char string_100[] PROGMEM = "100-RPN LSB";
prog_char string_101[] PROGMEM = "101-RPN MSB";
prog_char string_110[] PROGMEM = "110-CC 110 ";
prog_char string_120[] PROGMEM = "120-All Sound OFF";
prog_char string_121[] PROGMEM = "121-RST all Cntrl";
prog_char string_122[] PROGMEM = "122-Local Cntrl";
prog_char string_123[] PROGMEM = "123-All note Off";
prog_char string_124[] PROGMEM = "124-Omni Off";
prog_char string_125[] PROGMEM = "125-Omni On";
prog_char string_126[] PROGMEM = "126-Mono Mode On";
#define MAX_string 126
PROGMEM PGM_P string_table[] = // change "string_table" name to suit

{
string_0,
string_1,
string_2,
string_3,
string_4,
string_5,
string_6,
string_7,
string_8,
string_9,
string_10,
string_11,
string_12,
string_13,
string_14,
string_15,
string_16,
string_17,
string_18,
string_19,
string_20,
string_21,
string_22,
string_23,
string_24,
string_25,
string_26,
string_27,
string_28,
string_29,
string_30,
string_31,
string_32,
string_33,
string_34,
string_35,
string_36,
string_37,
string_38,
string_39,
string_40,
string_41,
string_42,
string_43,
string_44,
string_45,
string_46,
string_47,
string_48,
string_49,
string_50,
string_51,
string_52,
string_53,
string_54,
string_55,
string_56,
string_57,
string_58,
string_59,
string_60,
string_61,
string_62,
string_63,
string_64,
string_65,
string_66,
string_67,
string_68,
string_69,
string_70,
string_71,
string_72,
string_73,
string_74,
string_75,
string_76,
string_77,
string_78,
string_79,
string_80,
string_81,
string_82,
string_83,
string_84,
string_85,
string_86,
string_87,
string_88,
string_89,
string_90,
string_91,
string_92,
string_93,
string_94,
string_95,
string_96,
string_97,
string_98,
string_99,
string_100,
string_101,
string_102,
string_103,
string_104,
string_105,
string_106,
string_107,
string_108,
string_109,
string_110,
string_111,
string_112,
string_113,
string_114,
string_115,
string_116,
string_117,
string_118,
string_119,
string_120,
string_121,
string_122,
string_123,
string_124,
string_125,
string_126,
};
#endif /* #ifndef CC_defs_h */
------------------------------------------------------------------ constants.h
// Changelog:
// 20120813: cleanup
#ifndef constants_h
#define constants_h
#include "Arduino.h"
char buzzer[16];
prog_char strin_0[] PROGMEM = "0"; // "String 0" etc are strings to store // change to
suit.
prog_char strin_1[] PROGMEM = "1";
prog_char strin_6[] PROGMEM = "6"; // "String 0" etc are strings to store - // change to
suit.
#define MAX_strin 100

PROGMEM PGM_P strin_table[] = // change "string_table" name to suit
{
strin_0,
strin_1,
strin_2,
strin_3,
strin_4,
strin_5,
strin_6,
strin_7,
strin_8,
strin_9,
strin_10,
strin_11,
strin_12,
strin_13,
strin_14,
strin_15,
strin_16,
strin_17,
strin_18,
strin_19,
strin_20,
strin_21,
strin_22,
strin_23,
strin_24,
strin_25,
strin_26,
strin_27,
strin_28,
strin_29,
strin_30,
strin_31,
strin_32,
strin_33,
strin_34,
strin_35,
strin_36,
strin_37,
strin_38,
strin_39,
strin_40,
strin_41,
strin_42,
strin_43,
strin_44,
strin_45,
strin_46,
strin_47,
strin_48,
strin_49,
strin_50,
strin_51,
strin_52,
strin_53,
strin_54,
strin_55,
strin_56,
strin_57,
strin_58,
strin_59,
strin_60,
strin_61,
strin_62,
strin_63,
strin_64,
strin_65,
strin_66,
strin_67,
strin_68,
strin_69,
strin_70,
strin_71,
strin_72,
strin_73,
strin_74,
strin_75,
strin_76,
strin_77,
strin_78,
strin_79,
strin_80,
strin_81,
strin_82,
strin_83,
strin_84,
strin_85,
strin_86,
strin_87,
strin_88,
strin_89,
strin_90,
strin_91,
strin_92,
strin_93,
strin_94,
strin_95,
strin_96,
strin_97,
strin_98,
strin_99,
strin_100,
};
#endif // #ifndef constants_h
------------------------------------------------------------- potenciometros_y_display.h
// Changelog:
// 20120813: cleanup
#ifndef potenciometros_y_display_h
// Definitions and constants:
#define NUM_KNOB_GROUPS 8
#define NUM_KNOBS 4 // 4 knobs * 4 knobs/bank = 16 total knobs
#define NUM_MENUS 4
#define NUM_MIDI 16
#define NUM_CONTROL_CHANGE 127
#define BUTTON_IDLE 0
#define BUTTON_RELEASED 1
#define BUTTON_PRESSED 2
/*
Version para Mega
const int PIN_Encoder0A = 30;
const int PIN_Encoder0B = 31;
const int PIN_Button = 22;
*/
// version para UNO
/*const int PIN_Encoder0A = 0;
*/
const int PIN_Encoder0A = 19;

const int PIN_Button = 2;
enum EncoderIndexes
{
MenuEncoderNdx = 0,
KnobGroupEncoderNdx,
KnobEncoderNdx,
ControlChangeEncoderNdx,
MidiChannelNdx,
BehaviorNdx,
KnobEncoderElems
};
enum MenuElems
{
ME_KnobGroup = 0,
ME_Knob,
ME_ControlChange,
ME_MidiChannel,
ME_Behavior,
ME_Elems
};
const char *menu_labels[ME_Elems] = { "K group:", "Knob:", "CC:", "Channel:",

"lin/exp/log:" };
// Data structures:
typedef struct
{
int knob[NUM_KNOBS];
int behavior[NUM_KNOBS];
int control_change[NUM_KNOBS];
int channel[NUM_KNOBS];
} KnobStatus;
typedef struct
{
int buttonPushCounter; // counter for the number of button presses
int buttonState; // current state of the button
int lastButtonState; // previous state of the button
} Button;
typedef struct
{
int encoder_target; // it will point to knob_ndx/control_change_ndx/menu_ndx.
int positions[KnobEncoderElems];
int ultimaPosicionPinA;
} Encoder;
typedef struct
{
int cc;
int knob_value;
} MIDI_STATUS;
typedef struct
{
KnobStatus knobs[NUM_KNOB_GROUPS];
Encoder encoder;
Button button;
MIDI_STATUS midi_status[NUM_MIDI];
} ControlStatus;
// Function prototypes:
void input_update(ControlStatus *cs);

void output_update(ControlStatus *cs);
void screen_update(ControlStatus *cs);
int update_from_button(ControlStatus *cs); // pulsador()
int update_from_encoder(ControlStatus *cs, int enc_pos, int x); // Paso de la estructura,
retorno del valor de la funcion de encoder, valor maximo que puede alcanzar )
void input_update_knobs(ControlStatus *cs);
void lcd_draw_knob(ControlStatus *cs);
void lcd_draw_header();
void indicador_de_pulsacion(ControlStatus *cs);
void lcd_draw_menu(ControlStatus *cs);
void output_update_midi(ControlStatus *cs);
void ControlStatus_Init(ControlStatus *cs);
void update_encoder_targets(ControlStatus *cs);
// Macros:
#define MAX(x, y) (x > y? x : y)
#endif // potenciometros_y_display_h
Pido de antemano disculpas por cualquier error u omisin que afecte al cdigo, si tenis alguna duda respecto al cdigo
hacdmela saber.
Espero que disfrutis con vuestro nuevo controlador MIDI.
I ask in advance apologies for any errors or omissions affecting the code, if you have any questions
regarding hacdmela know code.
I hope you enjoy with your new MIDI Controller.

lunes, 9 de diciembre de 2013
Material
Este es el listado de material de la ltima versin que tengo en marcha del controlador que sale en la foto.
Hubo una versin anterior con un display de 162 y otra versin posterior con un display de 164 caracteres, pero debido
a que se me quedaba corto decid implementar un display GLCD de 128X64 pxeles con la posibilidad de aadir grficos.
A continuacin describo los elementos que he utilizado en esta ltima (?) versin.
This is the list of material that I have latest version of the driver up in the photo.
There was an earlier version with a display of 16 2 and a later version with a display of 16 4 character, but because
I fell short I decided to implement a 128X64 GLCD display pixels with the ability to add graphics.
Below I describe the items that I have used in the last (?) Version.
Ncleo / Core :
Arduino UNO y su IDE.

Medio para visualizar la informacin:
Pantalla 128X64 GLCD ( permite visualizar grficos )
Means for displaying the information:
128X64 GLCD display (used to display graphics)
Control:
4 potencimetros ( lineales no importa el valor), un encoder y un pulsador.
Control:
4 sliders (linear no matter the value), an encoder and a button.

Esquemtico donde se puede apreciar los diferentes mdulos MIDI IN, OUT y TRHU que lo conforman y sus
componentes.
Schematic where you can see the different modules MIDI IN, OUT and THRU comprising it and its components.
Conectores DIN 5 hembra (hay muchos modelos, yo escog el que NO era areo y podia soldarlo en la PCB).
5 female DIN connectors (there are many models, I chose the one that was NO air and I couldsolder on the PCB).
Opto-acoplador Sharp PC-900 o equivalente para el modulo MIDI IN.
Optocoupler Sharp PC-900 or equivalent to the MIDI IN module.
HCF4069UBE inversor hexadecimal para el modulo MIDI OUT.
HCF4069UBE hex inverter module to the MIDI OUT.
Resistencias de 220 y 280 Ohms y diodo 1N914, tal y como se indica en el esquemtico.
Pcb con pistas y agujeros para trabajar con mas facilidad a la hora de soldar, evitando pegotes de estao y por ende
falsos contactos.
Resistors 220 and 280 Ohms and 1N914 diode, as indicated in the schematic.
Pcb with tracks and holes to work more easily when welding, avoiding globs of tin and thereforefalse contacts.
Cable rgido y las herramientas que corresponda.
Espadines, para poder hacer las conexiones
Como elemento final, eleg reunir todos estos elementos en una pieza de metacrilato por varios motivos:
Elegante.
Relativamente fcil de manipular.
Hard wire and tools appropriate.
Sprats, to make connections
As a final element, I chose to bring all these elements in a piece of acrylic for several reasons:
Elegant.
Relatively easy to manipulate.
Pero tambin caro si lo cortas con laser.
But also expensive if you cut with laser.
Edit

mircoles, 3 de julio de 2013
Controlador MIDI Arduino UNO ( I Presentacin )
Despus de muchas horas, pruebas y de casi no poder acabarlo, os presento mi primer controlador MIDI basado en
Arduino UNO.
After many hours of testing and almost unable to finish it, I present my first MIDI controller based on Arduino UNO.
Como funciona
How does it work?
Seleccionamos un grupo de potenciometros, 0, 1, 2, 3... hay 8 grupos, es decir 8 x 4 potenciometros = 32

potenciometros virtuales.
We selected a group of potentiometers, 0, 1, 2, 3 ... There are 8 groups, i.e 8 x 4 = 32 virtual potentiometers .
Elegimos entre el P0, P1, P2, P3, ( los cuatro potenciometros reales ).
Chose between P0, P1, P2, P3, ( the four real potentiometers ).
Una vez elegidos, asignamos mediante el pulsador ( manteniendo pulsado ) y el encoder mecnico, uno de
los Control Change que aparece en el listado de Control Change que a continuacin aparece en el display .
Once selected, assigned by the button (holding down) and mechanical encoder, choose one of the Control
Change that appears in the display.
Habiendo asignado el nmero de canal al potenciometro, es decir que el canal MIDI no est en midi = 0. El
controlador empezar a enviar mensajes por la salida de MIDI OUT.
Having allocated channel number potentiometer, ie the MIDI channel is not in midi = 0. The controller will start
sending out messages for MIDI OUT.
Podis observar que el funcionamiento es muy sencillo. Este uno de los objetivos mas importantes que quera conseguir,
pues como msico electrnico y usuario de hardware me he encontrado con mquinas que no hacen lo que se supone
tienen que hacer, y este era el caso de mi controlador Evolution UC-33
You can see that the operation is very simple. This one of the most important goals I wanted to achieve, because as
electronic musician and hardware user I found machines that do not do what they are supposed to do, and this was the
case of my Evolution UC-33 controller.
No es que sea una mala mquina, pero es que ( yo creo ) que no es prctico tener 24 potenciometros, 8 deslizadores
adems de pulsadores y que la nica informacin que obtienes de su bonito display azul sea tan criptico como esto:
It's not a bad machine, but is that (I believe) it is not practical to have 24 potentiometers, 8 sliders and buttons as well as
the only information you get from her pretty blue display is as cryptic as this:
Obligndote de esta manera a introducir un elemento ms en tu "set-up"... la cinta de pintor para poder saber que has
asignado en cada potenciometros.
Thus forcing you to introduce another element in your "set-up" ... masking tape to know that you assigned in
each potentiometers.
.
.
.
Os imaginis hacer una actuacin y que perdis la cinta para anotar adonde asignasteis cada funcin?
Can you imagine doing a show and you miss the tape to record where each function was asigned ?
Descripcin de la informacin en el men:

Description information in the menu:
K group: Grupo de potenciometros

K group: Group potentiometers
Knob: Potenciometro
Knob: Potentiometer
CC: Control Change

CC: Control Change
Channel: Canal MIDI que estamos asignando.

Channel: MIDI channel that we are assigning
Lin/exp/log: Respuesta de los potenciometros lineal / exponencial y logartmica ( no implementado ).

Lin / exp / log: linear potentiometers Response / exponential and logarithmic (not implemented).
Los niveles indican la posicin absoluta del potenciometro, esto va muy bien para ver a simple vista doce tienes el
potenciometro.
The levels indicate the absolute position of the potentiometer, this is nice to see at a glance twelve have the
potentiometer.
El controlador se basa completamente en un Arduino UNO, utilizando todas las entradas menos el pin nmero 0 ( de
momento ) ya que en en breve quiero implementar un par de cosas ms, y entre ellas estr la capacidad de poder sumar
una seal MIDI externa ( MIDI Merge ) y tendr que utilizar el que me queda como entrada serie.
The controller is based on an Arduino UNO copmpletamente, using all entries but the pin number 0 (for now) and that
soon I want to implement a few more things, including stress and the ability to add external MIDI signal ( MIDI Merge) and
I have to use the one I have as input series.
El controlador solo maneja CC ( Control Change ), el motivo por el cual eleg esta particularidad antes de abordar tems
como el Program Change o el Play / Stop es que pueden emplearse para modificar cualquier parmetro y para mi E-MU
5000 me v de perlas, as que si el sintetizador que queremos gobernar permite manejar CC, no habr problemas para
comunicarse con l.
The controller only handles CC (Control Change), the reason why I chose this feature before boarding issues as Program
Change or the Play / Stop is that they can be used to modify any parameter of my E-MU 5000, so if the synthesizer you
want to handle CC rule, there will be no problem communicating with it.
Por otra parte al no ser una de las partes estandarizadas en el protocolo MIDI, copi uno a uno los 127 parmetros
que reconoca mi AKAI MPC 1000 con su sistema operativo actualizado al
JJOS2XL http://www7a.biglobe.ne.jp/~mpc1000/os2xl/ as que haciendo esto me aseguraba que los parmetros que
copiaba por lo menos estaban "actualizados" como mi AKAI.
On the other hand not being a party in the MIDI standard, I copied one by one the 127 parameters that recognized my
AKAI MPC 1000 with its updated operating system to JJOS2XL http://www7a.biglobe.ne.jp/ ~ MPC1000 / os2xl / so doing
that I made sure that the parameters were copied at least "updated" as my AKAI.
El material que he empleado ha sido este:

The material I have used has been this:
GLCD display 128X64 link

Podis observar que este montaje no corresponde a la placa del Arduino UNO, pero para haceros rpidamente una idea
de como va el conexionado creo que ya sirve.
You can see that this show is not for the Arduino UNO board, but to make you a quick idea of how the wiring goes I think
it serves.
Por cierto el programa que hace estos graficos tan chulos se llama Fritzing y es Open Software.
Certainly the graphics program that makes these so cool is called Fritzing and Open Software.
Una de las pruebas con el display de 128x6.
One of the early tests with the display 128x64.
Libreria u8glib, del Seor Oliver, una gran tipo: link

U8glib Library of Mr. Oliver, a great guy.
Libreria MIDI aqu: link
MIDI Library
Potenciometros valor de 10K lineales, se encuentran en cualquier tienda electronica.
Linear Potentiometers 10K value, found in any electronics store.
Mdulo MIDI: Lo hice siguiendo este esquema: link
MIDI Module: I did following this scheme
Mdulo encoder: A partir de un dibujo que encontr, ya que al inicio estaba completamente perdido, no puedo
poner el enlace porque no lo tengo, mil gracias al creador del boceto me fue de perlas.
Encoder module: From a drawing I found, since at the beginning was completely lost, I can not put the link
because I have not, thank the creator of the sketch.
Es un divisor de tensin un poco particular con un par de condensadores para evitar rebotes.
Is a curious voltage divider with a pair of capacitors to avoid rebounds.
Debo sealar que controlarlo por soft junto con el pulsador fue un infierno. Ya que al montarlo en la protoboard y con el
juego que a veces tienen los cables me daban falsas seales y me pas das en busca de la falla.
I should note that for soft control with the push was hell. Since when mounted on the breadboard and the game that
sometimes have the cables gave me false signs and I spent days looking for the fault.
Aqu os adjunto un vdeo ( calidad telfono mvil ) del funcionamiento de la primera versin del controlador conectado a
la MPC 1000.
Here I attached a video (mobile phone quality) performance of the first version of MPC 1000connected to the controller.
Sugerencias:
Suggestions:
C/C++ Curso de programacion Fco Javier ceballos Sierra
A mi me ha servido y me sigue sirviendo de mucho este libro, encuentro que es una joya, y su autor es espectacular el
como explica las cosas.
C / C + + programming course ceballos Fco Javier Sierra

To me has served and continues to serve me this book a lot, I find it a gem, and its author is spectacular explains things.
Arduino Internals
Muy interesante.
Very interesting.
Programming And Customizing The AVR Microcontroller
Super interesante una vez te ha picado el mundo de los microcontroladores.
Super interesting once you've been bitten by the world of microcontrollers.
Nos vemos en la siguiente entrega.
See you in the next installment.
Publicado por Pulse en 13:01 6 comentarios:

Etiquetas: Arduino, controlador, electronica, MIDI, open hardware, open software, sintetizador
lunes, 8 de octubre de 2012
Primer paso: Editor de texto para trabajar.
Actualizacin:
He encontrado este enlace:
http://www.mupuf.org/project/arduide.html
De una forma muy sencilla podis instalaros un IDE mucho ms completo con respecto a la informacin que ofrece,
rpido y agradable a la hora de compilar.
Primer paso:
Un editor de texto para trabajar.
Despus de la experiencia con el entorno de desarrollo que viene por defecto con el paquete de Arduino, he decidido
cambiar y aprovechar para aprender a utilizar Vim.
Ahora mismo tal y como lo estoy utilizando es probablemente una de las maneras menos eficientes de utilizarlo,
pero despus de un da entero de bsqueda, y con decenas de pruebas fallidas, doy por finalizada la "cacera" hasta otro
momento.
La configuracin y el modo de empleo son relativamente sencillos;
En primer lugar se trata de abrir el archivo que vayamos a editar/crear con el editor Vim.
Una vez hayamos abierto el archivo, el siguiente paso es abrir el IDE del Arduino y en las preferencias elegir "Usar editor
externo".
De esta manera al editar o crear el texto que nos convenga, y una vez hayamos hechas las correcciones pertinentes en
nuestro archivo, cuando salvemos el archivo debemos recordar que la extensin que utilizar el IDE de Arduino es .ino.
As que lo salvamos como; 'nombre'.ino
Ahora vamos al IDE de Arduino, abrimos el mismo archivo y podremos compilarlo y subirlo a nuestra placa siempre que
est bien.
Una de las pequeas ventajas que de cierta manera nos ofrece esta configuracin, es que una vez editemos el archivo y
lo guardemos al tener el modo "usar editor externo", el IDE de Arduino nos mostrar los cambios que hayamos
realizados en Vim o en el editor que hayamos elegido.
Tambin es cierto que estamos obligados a hacer un paso mas a la hora de trabajar, pero eso ya depende de cada cual.

Arduino MIDI Controller

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arduino MIDI Controller

Uploaded by

Copyright:

Available Formats

Arduino MIDI controller

"Unexpected end of file" at startup of CvPcb

"Unexpected end of file" at startup of CvPcb

La solucion que he encontrado es esta, y de momento me ha funcionado.

aadir al final del archivo que d el error $EndLIBRARY.

mircoles, 11 de diciembre de 2013

Cdigo controlador MIDI

Cdigo principal / Main code:

U8GLIB_ST7920_128X64 u8g(3, 5, 6, 9, 10, 11, 7, 8, 13, U8G_PIN_NONE, U8G_PIN_NONE, 12,

void setup() // -------------------------------------------------------------------------

if ((clock % period) == 0) // trigger every 'period' (e.g. 1 every 5 times)

void input_update(ControlStatus *cs)

switch ( cs->encoder.encoder_target ) // Vale 0

cs->encoder.positions[cs->encoder.encoder_target] = update_from_encoder(cs, cs-

int update_from_encoder = ( Paso de la estructura, parametro del valor de la funcion de

update_from_encoder(cs, cs->encoder.positions[cs->encoder.encoder_target], NUM_MENUS): 3

update_from_encoder(cs, cs->encoder.positions[cs->encoder.encoder_target], NUM_MENUS): 4

case KnobGroupEncoderNdx:// -------------------------------------------------------------

if (update_from_button(&current_status) == BUTTON_RELEASED) // pressed

case KnobEncoderNdx: // -----------------------------------------------------------------

if (update_from_button(&current_status) == BUTTON_RELEASED) // pressed

case MidiChannelNdx: // -----------------------------------------------------------------

case ControlChangeEncoderNdx: // --------------------------------------------------------

case BehaviorNdx: // --------------------------------------------------------------------

cs->encoder.encoder_target = MenuEncoderNdx; // Unimplemented:

// Read knob data:

void output_update(ControlStatus *cs)

void screen_update(ControlStatus *cs)

// Draw frame and constant parts:

// compare the buttonState to its previous state

int update_from_encoder(ControlStatus *cs, int enc_pos, int x)

void input_update_knobs(ControlStatus * cs)

for ( int i = 0; i < NUM_KNOBS; i++ )

void lcd_draw_knob(ControlStatus * cs)

for ( int i = 0; i < NUM_KNOBS; i++ )

// X, Y ; ancho , alto Linea vertical mas estrcha (debajo del restangulo )

u8g.drawLine(2 + 20 * i, 60, 2 + 20 * i, 40);

void indicador_de_pulsacion(ControlStatus * cs)

void lcd_draw_menu(ControlStatus *cs)

// Draw menu entries:

u8g.drawStr(8, 5 + i*font_height, menu_labels[i]);

const int text_offset = (strlen(menu_labels[i]) ) * font_width;

const int value = cs->encoder.positions[i+1];

const int cc_text_offset = (strlen(menu_labels[ME_ControlChange]) + 1) * font_width;

void output_update_midi(ControlStatus *cs)

for ( int i = 0; i < NUM_KNOBS; i++ )

if ( midi_channel >= 0 && midi_channel < NUM_MIDI && cs->midi_status[midi_channel].cc !=

void ControlStatus_Init(ControlStatus * cs)

cs->button.buttonPushCounter = 1; // Counter for the number of button presses

void update_encoder_targets(ControlStatus *cs)

cs->encoder.positions[BehaviorNdx] = MAX(0, cs->knobs[knob_group].behavior[knob]);

#define MAX_string 126

PROGMEM PGM_P string_table[] = // change "string_table" name to suit

#define MAX_strin 100

#endif // #ifndef constants_h

// Definitions and constants:

const int PIN_Encoder0A = 19;

const char *menu_labels[ME_Elems] = { "K group:", "Knob:", "CC:", "Channel:",

void input_update(ControlStatus *cs);

#define MAX(x, y) (x > y? x : y)

I hope you enjoy with your new MIDI Controller.

Publicado por Pulse en 9:06 No hay comentarios:

lunes, 9 de diciembre de 2013

Arduino UNO y su IDE.