Convert int to byte array

Hello,

First day with the Arduino Mega2560.

I'm trying to display some data that's recieved by the serial line and display it on a 4x7 segment display.

Currently my code will only display the last 2 digits correctly. So if I enter in 1234, the output on the 4x7 segment display will be 0034.
if I enter in 123 the output will be 0023 and so on.

I'm not sure why it's doing this. I'm familiar with C++, but not C, so I may have some syntax wrong.

Here is my current code:

void displayNumber(int originalNumber)
{
  int newNumber=originalNumber;
  int digit=0;
  if (bigEndian) {
    for (byte segSetup = segmentDisplayCount; segSetup > 0; --segSetup) {
      digit = newNumber%10;
//If I print out the value of newNumber here, after the 2nd loop, 123/10=0 for some reason.
      if (newNumber > 0) {
        setNumber(segSetup-1, digit);
      }
      else {
        setNumber(segSetup-1, 0);
      }
      newNumber /= 10;
    }
  }
}

If I manually do the conversion with:

  dig1 = num / 1000;
  num = num - (dig1 * 1000);
  dig2 = num / 100;
  num = num - (dig2 * 100);
  dig3 = num / 10;
  dig4 = num - (dig3 *10);

It works fine.

Can anyone tell me why this is happening, or offer some different code that I could test? I've been stuck on this for hours trying different methods of splitting the int up, but always leads to dead ends :(.

Here is my current code:

No, it isn't. That is SOME of your code. We can't see what segmentDisplayCount is.

originalNumber is a pass by value argument. There is no reason to make a copy of it. The variable that held the value passed to the function can not possibly be impacted by what the function does.

//If I print out the value of newNumber here, after the 2nd loop, 123/10=0 for some reason.

There must be something else going on.

The full code is quite lengthy, but I've pasted it here.

// Segment labelling:
//        A
//       ----
//     F |  | B
//       ---- G
//     E |  | C
//       ----   .H
//        D

// Pins:
//             12        7
//         -----------------------
//         |   ~~  ~~  ~~  ~~    |
//         |   ~   ~   ~   ~     |
//         |   ~~. ~~. ~~. ~~.   |
//         -----------------------
//              1       6

//Pins on 4x7 Segment Display:
// Pin 1:  E
// Pin 2:  D
// Pin 3:  H
// Pin 4:  C
// Pin 5:  G
// Pin 6:  4th 7 Segment
// Pin 7:  B
// Pin 8:  3rd 7 Segment
// Pin 9:  2nd 7 Segment
// Pin 10: F
// Pin 11: A
// Pin 12: 1st 7 Segment

byte segmentPinCount=8; //Includes the . (Decimal place)
byte segmentDisplayCount=4; //How many 7 segment displays do we have?
byte sevenSegmentPins[8] = {2,3,4,5,6,7,8,9}; // A, B, C, D, E, F, G, H
byte sevenSegmentCathodePins[4]={10,11,14,16}; //1st, 2nd, 3rd, 4th

int delayTime = 4; // Time in ms to allow for pin state change.
boolean bigEndian = true; //If the display can't fit the number, which end should we show?
boolean serialCom = true; //Allow serial communication.

int num=0;
int dig1 = 0;
int dig2 = 0;
int dig3 = 0;
int dig4 = 0;

byte sevenSegmentDisplay[36][8] = {
  //A B C D E F G H
  { 1,1,1,1,1,1,0,0 },  // = 0
  { 0,1,1,0,0,0,0,0 },  // = 1
  { 1,1,0,1,1,0,1,0 },  // = 2
  { 1,1,1,1,0,0,1,0 },  // = 3
  { 0,1,1,0,0,1,1,0 },  // = 4
  { 1,0,1,1,0,1,1,0 },  // = 5
  { 1,0,1,1,1,1,1,0 },  // = 6
  { 1,1,1,0,0,0,0,0 },  // = 7
  { 1,1,1,1,1,1,1,0 },  // = 8
  { 1,1,1,0,0,1,1,0 },  // = 9
  { 1,1,1,0,1,1,1,0 },  // = A
  { 0,0,1,1,1,1,1,0 },  // = B
  { 1,0,0,1,1,1,0,0 },  // = C
  { 0,1,1,1,1,0,1,0 },  // = D
  { 1,0,1,0,1,1,1,0 },  // = E
  { 1,0,0,0,1,1,1,0 },  // = F
  { 0,0,0,0,0,0,0,0 }   // = Clear
  { 1,0,0,1,0,0,0,0 }   // = =
  { 0,0,0,0,0,1,0,0 }   // = '
  { 1,1,1,1,1,1,0,1 },  // = 0.
  { 0,1,1,0,0,0,0,1 },  // = 1.
  { 1,1,0,1,1,0,1,1 },  // = 2.
  { 1,1,1,1,0,0,1,1 },  // = 3.
  { 0,1,1,0,0,1,1,1 },  // = 4.
  { 1,0,1,1,0,1,1,1 },  // = 5.
  { 1,0,1,1,1,1,1,1 },  // = 6.
  { 1,1,1,0,0,0,0,1 },  // = 7.
  { 1,1,1,1,1,1,1,1 },  // = 8.
  { 1,1,1,0,0,1,1,1 },  // = 9.
  { 1,1,1,0,1,1,1,1 },  // = A.
  { 0,0,1,1,1,1,1,1 },  // = B.
  { 1,0,0,1,1,1,0,1 },  // = C.
  { 0,1,1,1,1,0,1,1 },  // = D.
  { 1,0,1,0,1,1,1,1 },  // = E.
  { 1,0,0,0,1,1,1,1 },  // = F.
  { 0,0,0,0,0,0,0,1 }   // = Clear. (With dot)
  
};

void setup()
{
  for (byte pinSetup = 0; pinSetup < segmentPinCount; ++pinSetup) {
    pinMode(sevenSegmentPins[pinSetup], OUTPUT); //Setup our control pins for output.
  }
  
  for (byte segSetup = 0; segSetup < segmentDisplayCount; ++segSetup) {
    pinMode(sevenSegmentCathodePins[segSetup], OUTPUT); //Setup our cathode power pins for each 7 segment display.
  }

  if (serialCom) { Serial.begin(9600); } //Allow serial communication.
}
void loop()
{
  
  for (byte segSetup = 0; segSetup < segmentDisplayCount; ++segSetup) {
    digitalWrite(sevenSegmentCathodePins[segSetup], HIGH); //Reset cathode control pins.
  }

if (Serial.available() > 0)
{
  num = Serial.parseInt();
  Serial.println(num);
  dig1 = num / 1000;
  num = num - (dig1 * 1000);
  dig2 = num / 100;
  num = num - (dig2 * 100);
  dig3 = num / 10;
  dig4 = num - (dig3 *10);
}
//displayNumber(num);
// /*
  setNumber(3, dig4);
  setNumber(2, dig3);
  setNumber(1, dig2);
  setNumber(0, dig1);
  // */
}

void displayNumber(int originalNumber)
{
  int newNumber=originalNumber;
  int digit=0;
  if (bigEndian) {
    for (byte segSetup = segmentDisplayCount; segSetup > 0; --segSetup) {
      //Serial.println(newNumber);
      //digit = ((originalNumber/(10^segSetup))%10);
      digit = newNumber%10;
      
      if (newNumber > 0) {
        setNumber(segSetup-1, digit);
      }
      else {
        setNumber(segSetup-1, 0);
      }
      newNumber /= 10;
    }
  }
}

void setNumber(byte pin, int x)
{
  digitalWrite(sevenSegmentCathodePins[pin], LOW);
   switch(x){
     case 1:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[1][segIndex]);
       }
       break;
     case 2:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[2][segIndex]);
       }
       break;
     case 3:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[3][segIndex]);
       }
       break;
     case 4: 
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[4][segIndex]);
       }
       break;
     case 5:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[5][segIndex]);
       }
       break;
     case 6:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[6][segIndex]);
       }
       break;
     case 7:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[7][segIndex]);
       }
       break;
     case 8:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[8][segIndex]);
       }
       break;
     case 9:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[9][segIndex]);
       }
       break;
     case 0:
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[0][segIndex]);
       }
     case 10: //A
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[10][segIndex]);
       }
       break;
     case 11: //B
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[11][segIndex]);
       }
       break;
     case 12: //C
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[12][segIndex]);
       }
       break;
     case 13: //D
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[13][segIndex]);
       }
       break;
     case 14: //E
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[14][segIndex]);
       }
       break;
     case 15: //F
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[15][segIndex]);
       }
       break;
     case 36: //Clear . (With dot)
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[36][segIndex]);
       }
       break;
       
       
     default: //Clear
       for (byte segIndex = 0; segIndex < segmentPinCount; ++segIndex) {
         digitalWrite(sevenSegmentPins[segIndex], sevenSegmentDisplay[16][segIndex]);
       }
       break;
   }
   delay (delayTime);
   digitalWrite( sevenSegmentCathodePins[pin], HIGH);
}

I took your function, and made some minor tweaks, just to test it's functionality:

void setup()
{
  Serial.begin(115200);
  
  displayNumber(1234);
}

void loop()
{
}

void displayNumber(int number)
{
  Serial.print("number: ");
  Serial.println(number);

  int digit=0;
  for (byte s = 4; s > 0; --s)
  {
    //Serial.println(newNumber);
    //digit = ((originalNumber/(10^segSetup))%10);
    digit = number%10;
    number /= 10;

    Serial.print("digit: ");
    Serial.println(digit);

    Serial.print("number: ");
    Serial.println(number);
  }
}

Running this, I get:

number: 1234
digit: 4
number: 123
digit: 3
number: 12
digit: 2
number: 1
digit: 1
number: 0

So, you need to look at how you are using the function.

digit = ((originalNumber/(10^segSetup))%10);

It's a good thing that this got commented out and replaced.

In C++ (and the Arduino programming language is just glorified C++), the ^ symbol does not stand for exponentiation.
In fact, there is no built-in function for integer exponentiation. You have to write your own, using a loop or some such.

Figured it out. The problem was the code I was using to debug above was changing the variable I was passing into the function. It was only passing in 34 in the first place. I feel like an idiot, that's something I should have checked first, lol.

Thanks for your help PaulS, I wouldn't have thought to look there unless I had used your code.

Can you overload the ^ opperator in the sketchup IDE? Also, I noticed if I get errors, it's refering to a CPP file somewhere (and not the actual lines in my sketch up). I've Googled around a little bit and can't find the file's location (I'm running Ubuntu 12).

You can overload the ^ operator, but that only lets you define what it means for a new data type. You can't change what an existing operator means for one of the built-in data types such as integers.