SOLVED How do i use an array in my program?

hello, I'm writing a program for turning a tv remote control into a midi controller for my music programs.

i've written up some of the code, got some of the buttons working and sending midi signals...

but now i want to program in a little bit of some higher functionality to it...

i want to make the volume buttons on the remote change the values of different midi parameters...

all the midi signals are hexadecimal though, so i can't just send numbers through and have them be sent along as midi...

i thought it would be good to put in hexadecimal values 0-127 into an array, so that way, rather than having to program in a bunch of values into the code, i can just put them into an array and call the different values of the array...

This way, when i press up or down on the volume on the remote, it can increase or decrease a variable value, which would be assigned to a certain hexadecimal value in the array, and it would send that hex value as a midi note...

am i explaining that clearly? i hope so...

anyway, i don't have enough experience with arrays, if someone could just show me the basics on arrays, that would be great.

byte my_array[100];  // declare an array of 100 bytes

some_val = my_array[some_index];  // get a value from the array

my_array[some_index] = some_val;  // put a value into the array

Google's servers must be groaning under the weight of pages that describe C arrays.


Rob

i thought it would be good to put in hexadecimal values 0-127 into an array, so that way, rather than having to program in a bunch of values into the code, i can just put them into an array and call the different values of the array...

Bytes is bytes. Whether you use decimal, octal, or hexadecimal notation to define the value to be stored in a byte, it will be stored in binary.

I think you have a serious misunderstanding of how numbers are stored, and sent. Storing the value 0 in position 0 in an array, then sending the value in position 0 will STILL send a 0. You might just as well send the index.

I don't think I have a serious misunderstanding of how numbers are stored, and sent, because i'm not trying to store and send number values, i'm really trying to store and send string values.

i'm trying to send the characters or text itself of the hexadecimal through the serial as a MIDI output...

i guess it would have helped if i clarified that though, thanks for bringing that up.

If i'm correct about the string array, i'm going to go ahead and make a guess as to what it would look like.

void noteSend(char midiChannel, char cmd, char data1, char data2) 
{
  cmd = cmd | midiChannel;   // merge channel number
  Serial.print(cmd, BYTE);   // or Serial.write(cmd); for arduino ide 1.0
  Serial.print(data1, BYTE); // or Serial.write(data1); for arduino ide 1.0
  Serial.print(data2, BYTE); // or Serial.write(data2); for arduino ide 1.0
}

char midiHex[8] = {"0x00","0x01","0x02","0x03","0x04","0x05","0x06","0x07"};

int endloop = 0

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  if(endloop == 0)
  {
     noteSend(0x09, 0xB0, 0x08, midiHex[0]);
     delay(1000);
     noteSend(0x09, 0xB0, 0x08, midiHex[3]);
     delay(500);
     noteSend(0x09, 0xB0, 0x08, midiHex[7]);
     endloop =1;
  }
}

There is no need to do that. You can send 0x00, or 0x07 or any other valid number as a byte. The Midi charts show them as hex representations for our benefit, not the instrument or computer's. It's all sent as binary anyway.

i'm trying to send the characters or text itself of the hexadecimal through the serial as a MIDI output...

Not as strings. MIDI doesn't know strings from cows.

char midiHex[8] = {"0x00","0x01","0x02","0x03","0x04","0x05","0x06","0x07"};

Wrong, this is an array of strings and as far as I can tell you just want to sent a single character. I'm surprised it compiled. Try

char midiHex[8] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};

However if these are the final values (not just for testing) then you don't need the array at all because the values are the same as their index.

     noteSend(0x09, 0xB0, 0x08, 0);
     delay(1000);
     noteSend(0x09, 0xB0, 0x08, 3);
     delay(500);
     noteSend(0x09, 0xB0, 0x08, 7);

Rob

     noteSend(0x09, 0xB0, 0x08, midiHex[0]);

What I don't get is why the OP is happy to send the first three parameters as hex literal, but not the fourth.

dxw00d:

     noteSend(0x09, 0xB0, 0x08, midiHex[0]);

What I don't get is why the OP is happy to send the first three parameters as hex literal, but not the fourth.

I've hooked up an IR receiver to my arduino and programmed it to recognize the infrared signals from a tv remote. when certain buttons are pushed on the remote, i program the arduino to send different midi signals.

I don't need every button on the remote to behave dynamically. most buttons, i can just program them to do the same thing every time, so in the code all four parameters would be hex literal...

but I am also making it so that when i push the volume and channel buttons up and down, it increases and decreases a variable integer, and that integer is used to determine which array placeholder to use in sending as a midi signal.

in my new code, i've made it so that the channel and volume buttons have 2 hex literal values, but also 2 array values that are determined by integer variables. This enables me to increase and decrease channel and volume in the way i want.

here is my new example code.

void noteSend(char midiChannel, char cmd, char data1, char data2) 
{
  cmd = cmd | midiChannel;   // merge channel number
  Serial.print(cmd, BYTE);   // or Serial.write(cmd); for arduino ide 1.0
  Serial.print(data1, BYTE); // or Serial.write(data1); for arduino ide 1.0
  Serial.print(data2, BYTE); // or Serial.write(data2); for arduino ide 1.0
}

byte midiHex[128]= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F};

int volume = 0;
int chan = 0;

int endloop = 0

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  if(endloop == 0)
  {
     if(volume<=126)
     {
         volume = volume +1;
         noteSend(0x08, 0xB0, midiHex[chan], midiHex[volume]);
     }
   else if(volume ==127)
     {
         volume = volume +1;
         noteSend(0x08, 0xB0, midiHex[chan], midiHex[volume]);
         channel = channel+1;
         volume = 0;
      }
    else if(channel == 129)
      {
          channel = 0;
          endloop =1;
      }     
  }
}

and anyone interested in my IR remote MIDI project can find updated code on this thread.

http://arduino.cc/forum/index.php/topic,81699.0.html

thanks for your help!

byte midiHex[128]= {0x00,0x01,0x02,0x03,0x04,0x05,...
...
noteSend(0x08, 0xB0, midiHex[chan], midiHex[volume]);

Sorry plato_03 but that is sheer lunacy, you have the value you need in the variable "volume", just use it.

noteSend(0x08, 0xB0, midiHex[chan], volume);

The only reason for using an array like this is if the relationship between "volume" and the value sent to the Midi is not linear, for example with audio it could be logarithmic or some weird relationship so the array entries would not be the same as their index.


Rob

@plato_03 - You're still missing the point.

byte midiHex[128]= {0x00,0x01,0x02,0x03,0x04,0x05,...

is identical to

byte midiHex[128]= {0,1,2,3,4,5,...

and

byte midiHex[128]= {0b00000000,0x00000001,0x00000010,0x00000011,0x00000100,0x00000101,...

How you choose to represent numbers in your source code makes no difference to how the compiler stores them. They are all stored in binary.

hmmm... i see...

i got that from everyone's explanations above, but for whatever reason, i was stubborn and wanted to do it the way i thought it needed to be done.

i think i have had some problems in the past of just sending a digit and getting different signals than what i was expecting. I recall having problems with using integers in my code rather than hexadecimal for some reason, i can't remember exactly what those problems where though...

i will try to use just regular numbers rather than hex, and see what happens. if thats the case, then i probably don't even need an array to do what i want to do, i can just use an integer value and increase and decrease it.

use just regular numbers rather than hex,

It's really a matter of what's appropriate to make the program clearer to a human.

For example often the commands you are sending are defined in HEX in the documentation, in which case it's better to leave them that way rather than changing to decimal.

Similarly if the values are actually defining the bits, say to an LED 7-seg display then using binary is often better eg

24

Quickly now, which bits are set? Buggered if I know without some mental gymnastics but

B00011000

Is very clear.

In all cases the compiler and the processor couldn't care less, they still see the same number. It's just to help us mere humans understand the source code.

don't even need an array to do what i want to do, i can just use an integer value and increase and decrease it.

Yep.


Rob

thanks everyone for the help!