# Streaming integer data from Arduino to Java, integer greater than 0xFF

I need to send how many milliseconds elapsed since the beginning of the time the arduino runs to java using Serial.write(). However, the largest integer that I can throw in there is 255, naturally since the largest 1 byte value we can send is 0xFF.

But if we have an integer like 6000 miliseconds that I want to send into java, how can I do this? I was initially thinking of just checking if the number is greater than 255 then bit shift it by 4 to the left then doing `number<<4 & 0xFF00` and also writing `(number<<4)>>8 &0xFF`

But

1. that doesn't work for numbers really large and
2. I believe when I stream these int values into Java they get read as characters...

how do I fix this?

EDIT I've created a second version as the following

``````void sendData(int a ){
while(a>0){
Serial.write(a&255);
a = a>>8;
}
}
``````

on the java side I have to somehow multiply the correct x for 16^(x) to the value that we receive since everything is received backwards I'm not sure if this is the best way to go since we don't necessarily know how many bytes that we'll receive

I'm assuming you will be using the Arduino `millis()` function for keeping time. The output of the `millis()` function in the Arduino environment is a 32-bit unsigned integer*.

A 32-bit integer can be split into 4 x 8-bit bytes. To keep things simple you could program the Java receiving side to always expect 4 bytes (or whatever amount you need, see *). Assuming 32 bits is enough, you could use the following:

``````void sendData (uint32_t uptime) {
int i;
for (i = 0; i < 4; i++) {
Serial.write (uptime & 255);
uptime = uptime >> 8;
}
}
``````

On the Java side, you would receive the lowest order byte first, and you could reconstruct the 32-bit value by taking the first received 8-bit value, adding the second value shifted left by 8 bits (=multiplied by 256), adding the third value shifted left by 16 bits (=multiplied by 65536) and adding the fourth value shifted left by 24 bits (=multiplied by 16777216). Java is not my strong point so I will leave that to you.

BTW, is there a particular reason you have to use `Serial.write()`? It would be much easier to just write the value as a string with `Serial.println()`.

*After 2^32 milliseconds (a little under 50 days of uptime) the 32-bit counter that feeds the `millis()` function will wrap around to 0. You could keep the amount of times that the timer has overflowed in a separate (integer) variable and make that (i.e. bytes 5 and onward) part of your output.