Arrays in a library

Hi, I'm trying to figure out how to create an array for each pot connected to my UNO. I created the array in the header and then initialised in the source code but when I try change the elements in the array I get the error 'invalid types 'byte {aka unsigned char}[int]' for array subscript'. Apologies this is one of my first projects so my explanation might be kind of shaky.

The bulk of the code is from the Notes and Volts MIDI controller sketch, I've just included the relevant parts.

Thanks in advance!

///////////////////////// Header File
class Pot
{
public:
Pot(byte pin, byte command, byte control, byte channel);
Pot(Mux mux, byte muxpin ,byte command, byte control, byte channel);
void muxUpdate();
void newValue(byte command, byte value, byte channel);
byte getValue();
byte Pcommand;
byte Pcontrol;
byte Pchannel;
byte Pin;
byte Parr;
byte *inputArr;

private:
byte _pin;
byte _muxpin;
byte _numMuxPins;
int _control;
int _value;
int _oldValue;
bool _changed;
byte _enablepin;
byte *_inputArr;

///////////////////////////// CPP file
Pot::Pot(byte pin, byte command, byte control, byte channel)
{
_pin = pin;
_control = control;
_value = analogRead(_pin);
_value = _value >> 3;
_oldValue = _value << 3;
_value = _value << 3;
Pcommand = command;
Pcontrol = control;
Pchannel = channel;
Pin = pin;
Parr = *inputArr;
}
///////////////////////// Sketch
void updatePots() {
for (int i = 0; i < NUMBER_POTS; i = i + 1) {

byte potcontrol = POTS[i]->Pcontrol;
byte potmessage = POTS[i]->getValue();
byte potarr = POTS[i]->Parr;


if(POTS[i]->Pin = A0){
  potarr[0] = potcontrol;
  potarr[1] = potmessage;
}
sysExArr[4] = potcontrol;
sysExArr[5] = potmessage & 15;
sysExArr[6] = (potmessage & 240) / 16;

if (potmessage != 255) MIDI.sendSysEx(8, sysExArr, true);

}

}

Please read How to get the best out of this forum carefully, and edit your post to include the full code, correctly formatted in a code block, as well as the full error message.

There are no arrays in the code you posted.

Apologies let me try that again

//Header

#ifndef Controller_h
#define Controller_h

#include <Arduino.h>

//***********************************************************************
class Mux
{
public:
Mux(byte outpin_, byte numPins_, bool analog_);
byte outpin;
byte numPins;
bool analog;
};
//************************************************************************
//Button (Pin Number, Command, Note Number, Channel, Debounce Time)
class Button
{
public:
Button(byte pin, byte command, byte value, byte channel, byte debounce);
Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce);
byte getValue();
void muxUpdate();
void newValue(byte command, byte value, byte channel);
byte Bcommand;
byte Bvalue;
byte Bchannel;
byte Btoggle;

private:
byte _previous;
byte _current;
unsigned long _time;
int _debounce;
byte _pin;
byte _muxpin;
byte _numMuxPins;
byte _value;
byte _command;
bool _busy;
byte _status;
byte _last;
byte _enablepin;
};
//*************************************************************************
class Pot
{
public:
Pot(byte pin, byte command, byte control, byte channel);
Pot(Mux mux, byte muxpin ,byte command, byte control, byte channel);
void muxUpdate();
void newValue(byte command, byte value, byte channel);
byte getValue();
byte Pcommand;
byte Pcontrol;
byte Pchannel;
byte Pin;
byte Parr;
byte inputArr;

private:
byte _pin;
byte _muxpin;
byte _numMuxPins;
int _control;
int _value;
int _oldValue;
bool _changed;
byte _enablepin;
byte _inputArr;

};
//*************************************************************************
#endif

//CPP

#include "Controller.h"

//****************************************************************************************
Mux::Mux(byte outpin_, byte numPins_, bool analog_)
{
outpin = outpin_;
//enablepin = enablepin_;
numPins = numPins_;
analog = analog_;
if (analog == false) pinMode(outpin, INPUT_PULLUP);
//pinMode(enablepin, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
if (numPins > 8) pinMode(5, OUTPUT);
}
//****************************************************************************************
//Button (Pin Number, Command, Note Number, Channel, Debounce Time)
Button::Button(byte pin, byte command, byte value, byte channel, byte debounce)
{
_pin = pin;
pinMode(_pin, INPUT_PULLUP);
_value = value;
_command = command;
_debounce = debounce;
_time = 0;
_busy = false;
_status = 0b00000010;
_last = 1;
Bcommand = command;
Bvalue = value;
Bchannel = channel;
Btoggle = 0;
}

Button::Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce)
{
_pin = mux.outpin;
_numMuxPins = mux.numPins;
_muxpin = muxpin;
_value = value;
_command = command;
_debounce = debounce;
_time = 0;
_busy = false;
_status = 0b00000010;
_last = 1;
Bcommand = command;
Bvalue = value;
Bchannel = channel;
Btoggle = 0;
}

void Button::muxUpdate()
{
byte temp = _muxpin;
temp = temp << 2;
if (_numMuxPins > 8) PORTD = PORTD & B11000011;
else PORTD = PORTD & B11100011;
PORTD = PORTD | temp;
}

byte Button::getValue()
{
// If BUSY bit not set - read button
if (bitRead(_status, 0) == false) { // If busy false
if (digitalRead(_pin) == _last) return 2; // If same as last state - exit
}

// If NEW Bit set - Key just pressed, record time
if (bitRead(_status, 1) == true) { // If new is true
bitSet(_status, 0); // Set busy TRUE
bitClear(_status, 1); // Set New FALSE
_time = millis();
return 255;
}

// Check if debounce time has passed - If no, exit
if (millis() - _time < _debounce) return 255;

// Debounce time has passed. Read pin to see if still set the same
// If it has changed back - assume false alarm
if (digitalRead(_pin) == _last) {
bitClear(_status, 0); // Set busy false
bitSet(_status, 1); // Set new true
return 255;
}

// If this point is reached, event is valid. return event type
else {
bitClear(_status, 0); // Set busy false
bitSet(_status, 1); // Set new true
_last = ((~_last) & 0b00000001); // invert _last
return _last;
}
}

void Button::newValue(byte command, byte value, byte channel)
{
Bvalue = value;
Bcommand = command;
Bchannel = channel;
}

//********************************************************************
Pot::Pot(byte pin, byte command, byte control, byte channel)
{
_pin = pin;
_control = control;
_value = analogRead(_pin);
_value = _value >> 3;
_oldValue = _value << 3;
_value = _value << 3;
Pcommand = command;
Pcontrol = control;
Pchannel = channel;
Pin = pin;
inputArr[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
Parr[9] = inputArr[9];

}

void Pot::muxUpdate()
{
byte temp = _muxpin;
temp = temp << 2;
if (_numMuxPins > 8) PORTD = PORTD & B11000011;
else PORTD = PORTD & B11100011;
//PORTD = PORTD & B11000011;
PORTD = PORTD | temp;
}

Pot::Pot(Mux mux, byte muxpin, byte command, byte control, byte channel)
{
_pin = mux.outpin;
_numMuxPins = mux.numPins;
_muxpin = muxpin;
_control = control;
muxUpdate();
_value = analogRead(_pin);
_value = _value >> 3;
_oldValue = _value << 3;
_value = _value << 3;
Pcommand = command;
Pcontrol = control;
Pchannel = channel;
}

byte Pot::getValue()
{
_value = analogRead(_pin);
int tmp = (_oldValue - _value);
if (tmp >= 8 || tmp <= -8) {
_oldValue = _value >> 3;
_oldValue = _oldValue << 3;
return _value >> 3;
}
return 255;
}

void Pot::newValue(byte command, byte value, byte channel) {
Pcommand = command;
Pcontrol = value;
Pchannel = channel;
}

//Sketch

#include <MIDI.h>
#include "Controller.h"

/*************************************************************
MIDI CONTROLLER

by Notes and Volts
www.notesandvolts.com

Version 1.2 Arduino UNO ONLY!
*************************************************************/

MIDI_CREATE_DEFAULT_INSTANCE();

//************************************************************
//SET THE NUMBER OF CONTROLS USED***********************
//************************************************************
//---How many buttons are connected directly to pins?---------
byte NUMBER_BUTTONS = 0;
//---How many potentiometers are connected directly to pins?--
byte NUMBER_POTS = 3;
//---How many buttons are connected to a multiplexer?---------
byte NUMBER_MUX_BUTTONS = 0;
//---How many potentiometers are connected to a multiplexer?--
byte NUMBER_MUX_POTS = 0;
//---The System Exclusive message to be sent
byte sysExArr[8] = {240, 67, 16, 21, 0, 0, 0, 247};

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

//ANY MULTIPLEXERS? (74HC4067)*********************************
//MUX address pins must be connected to Arduino UNO pins 2,3,4,5
//A0 = PIN2, A1 = PIN3, A2 = PIN4, A3 = PIN5
//*******************************************************************
//Mux NAME (OUTPUT PIN, , How Many Mux Pins?(8 or 16) , Is It Analog?);

//Mux M1(10, 8, false); //Digital multiplexer on Arduino pin 10
//Mux M2(A0, 8, true); //Analog multiplexer on Arduino analog pin A0
//*******************************************************************

//DEFINE DIRECTLY CONNECTED POTENTIOMETERS*********************
//Pot (Pin Number, Command, CC Control, Channel Number)
//Command parameter is for future use

Pot PO1(A0, 0, 22, 1);
Pot PO2(A1, 0, 23, 1);
Pot PO3(A2, 0, 24, 1);
//Pot PO4(A3, 0, 25, 1);
//Pot PO5(A4, 0, 30, 1);
//Pot PO6(A5, 0, 31, 1);
//*******************************************************************
//Add pots used to array below like this-> Pot POTS {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6};
Pot POTS {&PO1, &PO2, &PO3};
//
*****************************************************************

//DEFINE DIRECTLY CONNECTED BUTTONS****************************
//Button (Pin Number, Command, Note Number, Channel, Debounce Time)
//** Command parameter 0=NOTE 1=CC 2=Toggle CC **

//Button BU1(2, 0, 60, 1, 5 );
//Button BU2(3, 0, 61, 1, 5 );
//Button BU3(4, 0, 62, 1, 5 );
//Button BU4(5, 0, 63, 1, 5 );
//Button BU5(6, 0, 64, 1, 5 );
//Button BU6(7, 0, 65, 1, 5 );
//Button BU7(8, 1, 64, 1, 5 );
//Button BU8(9, 2, 64, 1, 5 );
//*******************************************************************
//Add buttons used to array below like this-> Button BUTTONS {&BU1, &BU2, &BU3, &BU4, &BU5, &BU6, &BU7, &BU8};
Button BUTTONS {};
//
*****************************************************************

//DEFINE BUTTONS CONNECTED TO MULTIPLEXER**********************
//Button::Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce)
//** Command parameter 0=NOTE 1=CC 2=Toggle CC **

//Button MBU1(M1, 0, 0, 70, 1, 5);
//Button MBU2(M1, 1, 1, 71, 1, 5);
//Button MBU3(M1, 2, 2, 72, 1, 5);
//Button MBU4(M1, 3, 0, 73, 1, 5);
//Button MBU5(M1, 4, 0, 74, 1, 5);
//Button MBU6(M1, 5, 0, 75, 1, 5);
//Button MBU7(M1, 6, 0, 76, 1, 5);
//Button MBU8(M1, 7, 0, 77, 1, 5);
//Button MBU9(M1, 8, 0, 78, 1, 5);
//Button MBU10(M1, 9, 0, 79, 1, 5);
//Button MBU11(M1, 10, 0, 80, 1, 5);
//Button MBU12(M1, 11, 0, 81, 1, 5);
//Button MBU13(M1, 12, 0, 82, 1, 5);
//Button MBU14(M1, 13, 0, 83, 1, 5);
//Button MBU15(M1, 14, 0, 84, 1, 5);
//Button MBU16(M1, 15, 0, 85, 1, 5);
//*******************************************************************
////Add multiplexed buttons used to array below like this-> Button *MUXBUTTONS {&MBU1, &MBU2, &MBU3, &MBU4, &MBU5, &MBU6.....};
Button *MUXBUTTONS {};

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

//DEFINE POTENTIOMETERS CONNECTED TO MULTIPLEXER****************
//Pot::Pot(Mux mux, byte muxpin, byte command, byte control, byte channel)
//Command parameter is for future use

//Pot MPO1(M2, 0, 0, 1, 1);
//Pot MPO2(M2, 1, 0, 7, 1);
//Pot MPO3(M2, 2, 0, 50, 1);
//Pot MPO4(M2, 3, 0, 55, 2);
//Pot MPO5(M2, 4, 0, 50, 1);
//Pot MPO6(M2, 5, 0, 55, 2);
//Pot MPO7(M2, 6, 0, 50, 1);
//Pot MPO8(M2, 7, 0, 55, 2);
//Pot MPO9(M2, 8, 0, 50, 1);
//Pot MPO10(M2, 9, 0, 55, 2);
//Pot MPO11(M2, 10, 0, 50, 1);
//Pot MPO12(M2, 11, 0, 55, 2);
//Pot MPO13(M2, 12, 0, 50, 1);
//Pot MPO14(M2, 13, 0, 55, 2);
//Pot MPO15(M2, 14, 0, 50, 1);
//Pot MPO16(M2, 15, 0, 55, 2);
//*******************************************************************
//Add multiplexed pots used to array below like this-> Pot MUXPOTS {&MPO1, &MPO2, &MPO3, &MPO4, &MPO5, &MPO6.....};
Pot MUXPOTS {};
//
*****************************************************************

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

void loop() {
if (NUMBER_BUTTONS != 0) updateButtons();
if (NUMBER_POTS != 0) updatePots();
if (NUMBER_MUX_BUTTONS != 0) updateMuxButtons();
if (NUMBER_MUX_POTS != 0) updateMuxPots();
}

//*****************************************************************
void updateButtons() {

// Cycle through Button array
for (int i = 0; i < NUMBER_BUTTONS; i = i + 1) {
byte message = BUTTONS[i]->getValue();

//  Button is pressed
if (message == 0) {
  switch (BUTTONS[i]->Bcommand) {
    case 0: //Note
      MIDI.sendNoteOn(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
      break;
    case 1: //CC
      MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
      break;
    case 2: //Toggle
      if (BUTTONS[i]->Btoggle == 0) {
        MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
        BUTTONS[i]->Btoggle = 1;
      }
      else if (BUTTONS[i]->Btoggle == 1) {
        MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
        BUTTONS[i]->Btoggle = 0;
      }
      break;
  }
}

//  Button is not pressed
if (message == 1) {
  switch (BUTTONS[i]->Bcommand) {
    case 0:
      MIDI.sendNoteOff(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
      break;
    case 1:
      MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
      break;
  }
}

}
}
//*******************************************************************
void updateMuxButtons() {

// Cycle through Mux Button array
for (int i = 0; i < NUMBER_MUX_BUTTONS; i = i + 1) {

MUXBUTTONS[i]->muxUpdate();
byte message = MUXBUTTONS[i]->getValue();

//  Button is pressed
if (message == 0) {
  switch (MUXBUTTONS[i]->Bcommand) {
    case 0: //Note
      MIDI.sendNoteOn(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel);
      break;
    case 1: //CC
      MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel);
      break;
    case 2: //Toggle
      if (MUXBUTTONS[i]->Btoggle == 0) {
        MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel);
        MUXBUTTONS[i]->Btoggle = 1;
      }
      else if (MUXBUTTONS[i]->Btoggle == 1) {
        MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel);
        MUXBUTTONS[i]->Btoggle = 0;
      }
      break;
  }
}
//  Button is not pressed
if (message == 1) {
  switch (MUXBUTTONS[i]->Bcommand) {
    case 0:
      MIDI.sendNoteOff(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel);
      break;
    case 1:
      MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel);
      break;
  }
}

}
}
//***********************************************************************

void updatePots() {
for (int i = 0; i < NUMBER_POTS; i = i + 1) {

byte potcontrol = POTS[i]->Pcontrol;
byte potmessage = POTS[i]->getValue();
byte potarr[9] = POTS[i]->Parr[9];


if(POTS[i]->Pin = A0){
  potarr[0] = potcontrol;
  potarr[1] = potmessage;
}
sysExArr[4] = potcontrol;
sysExArr[5] = potmessage & 15;
sysExArr[6] = (potmessage & 240) / 16;

if (potmessage != 255) MIDI.sendSysEx(8, sysExArr, true);

}

}

//***********************************************************************
void updateMuxPots() {
for (int i = 0; i < NUMBER_MUX_POTS; i = i + 1) {
MUXPOTS[i]->muxUpdate();
byte potmessage = MUXPOTS[i]->getValue();
if (potmessage != 255) MIDI.sendControlChange(MUXPOTS[i]->Pcontrol, potmessage, MUXPOTS[i]->Pchannel);
}
}


//Error
Arduino: 1.8.13 (Mac OS X), Board: "Arduino Uno"

sketch/Controller.cpp: In constructor 'Pot::Pot(byte, byte, byte, byte)':
Controller.cpp:121:13: error: invalid types 'byte {aka unsigned char}[int]' for array subscript
inputArr[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
^
Controller.cpp:122:9: error: invalid types 'byte {aka unsigned char}[int]' for array subscript
Parr[9] = inputArr[9];
^
Controller.cpp:122:23: error: invalid types 'byte {aka unsigned char}[int]' for array subscript
Parr[9] = inputArr[9];
^
/Users/conallomaolain/Documents/Arduino/MIDI Controller FB 01/MIDI_Controller_SysEx_copy_2/MIDI_Controller_SysEx_copy_2.ino: In function 'void updatePots()':
MIDI_Controller_SysEx_copy_2:237:37: error: invalid types 'byte {aka unsigned char}[int]' for array subscript
byte potarr[9] = POTS[i]->Parr[9];
^
exit status 1
invalid types 'byte {aka unsigned char}[int]' for array subscript

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.

Worse.

Why did you not read the link that @PieterP posted?

You are declaring 'inputArr' as a single byte and then using it as if it were an array. That's why you get an error when you say 'inputArr[9] = ...'.

Can you explain what you are trying to change in how the "Notes and Volts" Controller.h sketch works? What it is not doing that you want done?

I'm trying to include an array, 'inputArr[9]' in the class 'Pot' and then assign it values in the .cpp file. If I assign the array like this 'inputArr[9] = {1,2,3,4,5,6,7,8,9};' in the .cpp file I get the error 'cannot convert '' to 'byte {aka unsigned char}' in assignment'

Post your complete code. Also, post the complete error message .... not your paraphrased version of it.

Also, read the forum guidelines on how to properly post your code using Code Tags. You should have done that before you asked your question.

Except you declared it as "byte inputArr;" and not as "byte inputArr[9];"

You can't 'assign' an array like that. You have to assign each element separately. Like this:

    for (int i=0; i<9; i++)
      inputArr[i] = i+1;

Of course you have to declare it as an array first.