0x prefix to serial write byte

Programming Questions

mskelly

0x prefix to serial write byte

in Programming Questions • 3 months ago

I'm trying to interface processing with a display with a very simple protocol. The values that the display receives have to be hex, and all writes to the display need to have a 0x prefix to tell the display to expect hex. I've got various tests running on the display when hardcoding it, for example -

myPort.write(0x00); // turns one line to all black

I'm now looking to be able to display images onto the display with a pixel array, I've used a version of ladyadas thermal printer bitmap (only runs on processing 1.5.1) converter sketch to take pixel data and create hex calls for each vertical column on the display. See original sketch below.

// Convert image to a C header file suitable for the Adafruit_Thermal library.
// This is NOT an Arduino sketch. Runs in Processing IDE (www.processing.org)
void setup() {
String filename, basename;
PImage img;
PrintWriter output;
int i, x, y, b, rowBytes, totalBytes, lastBit, sum, n;
// Select and load image
filename = selectInput("Select image file to convert:");
println("Loading image...");
img = loadImage(filename);
// Morph filename into output filename and base name for data
x = filename.lastIndexOf('.');
if(x > 0) filename = filename.substring(0, x); // Strip current extension
x = filename.lastIndexOf('/');
if(x > 0) basename = filename.substring(x + 1); // Strip path
else basename = filename;
filename += ".h"; // Append '.h' to output filename
println("Writing output to " + filename);
// Calculate output size
rowBytes = (img.width + 7) / 8;
totalBytes = rowBytes * img.height;
// Convert image to B&W, make pixels readable
img.filter(THRESHOLD);
img.loadPixels();
// Open header file for output (NOTE: WILL CLOBBER EXISTING .H FILE, if any)
output = createWriter(filename);
// Write image dimensions and beginning of array
output.println("#ifndef _" + basename + "_h_");
output.println("#define _" + basename + "_h_");
output.println();
output.println("#define " + basename + "_width " + img.width);
output.println("#define " + basename + "_height " + img.height);
output.println();
output.print("static PROGMEM prog_uchar " + basename + "_data[] = {");
// Generate body of array
for(i=n=y=0; y<img.height; y++) { // Each row...
output.print("\n ");
for(x=0; x<rowBytes; x++) { // Each 8-pixel block within row...
lastBit = (x < rowBytes - 1) ? 1 : (1 << (rowBytes * 8 - img.width));
sum = 0; // Clear accumulated 8 bits
for(b=128; b>=lastBit; b >>= 1) { // Each pixel within block...
if((img.pixels[i++] & 1) == 0) sum |= b; // If black pixel, set bit
}
output.format("0x%02X", sum); // Write accumulated bits
if(++n < totalBytes) output.print(',');
}
}
// End array, close file, exit program
output.println();
output.println("};");
output.println();
output.println("#endif // _" + basename + "_h_");
output.flush();
output.close();
println("Done!");
exit();
}

And my modified version with port writes instead of output to file writes - It's replicating this line with a myPort.write that I am struggling with:

output.format("0x%02X", sum); // Write accumulated bits
if(++n < totalBytes) output.print(',');

import processing.serial.*;
Serial myPort;
// Convert image to a C header file suitable for the Adafruit_Thermal library.
// This is NOT an Arduino sketch. Runs in Processing IDE (www.processing.org)
void setup() {
println(Serial.list());
// Open the port you are using at the rate you want:
myPort = new Serial(this, Serial.list()[0], 57600);
String filename, basename;
PImage img;
PrintWriter output;
int i, x, y, b, rowBytes, totalBytes, lastBit, sum, n;
// Select and load image
filename = selectInput("Select image file to convert:");
println("Loading image...");
img = loadImage(filename);
// Morph filename into output filename and base name for data
x = filename.lastIndexOf('.');
if(x > 0) filename = filename.substring(0, x); // Strip current extension
x = filename.lastIndexOf('/');
if(x > 0) basename = filename.substring(x + 1); // Strip path
else basename = filename;
filename += ".h"; // Append '.h' to output filename
println("Writing output to " + filename);
// Calculate output size
rowBytes = (img.width + 7) / 8;
totalBytes = rowBytes * img.height;
// Convert image to B&W, make pixels readable
img.filter(THRESHOLD);
img.loadPixels();
//
// // Open header file for output (NOTE: WILL CLOBBER EXISTING .H FILE, if any)
// output = createWriter(filename);
//
// // Write image dimensions and beginning of array
// output.println("#ifndef _" + basename + "_h_");
// output.println("#define _" + basename + "_h_");
// output.println();
// output.println("#define " + basename + "_width " + img.width);
// output.println("#define " + basename + "_height " + img.height);
// output.println();
// output.print("static PROGMEM prog_uchar " + basename + "_data[] = {");
// Generate body of array
myPort.write(0x80); //header
for(i=n=y=0; y<img.height; y++) { // Each row...
//output.print("\n ");
for(x=0; x<rowBytes; x++) { // Each 8-pixel block within row...
lastBit = (x < rowBytes - 1) ? 1 : (1 << (rowBytes * 8 - img.width));
sum = 0; // Clear accumulated 8 bits
for(b=128; b>=lastBit; b >>= 1) { // Each pixel within block...
if((img.pixels[i++] & 1) == 0) sum |= b; // If black pixel, set bit
}
println("0x" + hex(sum,2)); // Write accumulated bits
myPort.write("0x" + hex(sum,2)); // Write accumulated bits
//if(++n < totalBytes) output.print(',');
}
}
myPort.write(0x8F); //end byte
// End array, close file, exit program
// output.println();
// output.println("};");
// output.println();
// output.println("#endif // _" + basename + "_h_");
// output.flush();
// output.close();
println("Done!");
exit();
}

myPort.write("0x" + hex(sum,2)); // Write accumulated bits

This line shows up as a random pattern on the display and not what I need, however printing this serially - it looks like the correct format. I think the byte is being converted to an int when I add the 0x to it so I've tried to add the 0x in various ways and convert it to a byte after this, but without any luck.

Anyone got any ideas?

Replies(5)

GoToLoop

Re: 0x prefix to serial write byte

3 months ago

I don't get much about Serial and such; but I wonder whether its method write()

accepts a whole String besides integral numbers?

I've peeked at "Serial.java" source file and found this:

public void write(String what) {
write(what.getBytes());
}

getBytes() is a String's method:

http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#getBytes%28%29

In my understanding, you're not gonna send a String representing a whole hexadecimal value;

rather a sequence of ASCII values from the characters of that String!

mskelly

Re: 0x prefix to serial write byte

3 months ago

Thanks for the suggestion - that makes a lot of sense. I tried to cast the 0x to a string, and the hex function to a string, and then concatenate them to send to port like below.

String data = ("0x");
String value = (hex(127,2));
String complete = (data + value);
println(complete);
myPort.write(complete);

String value becomes 7F and the complete byte when printed serially looks right as "0x7F" however I dont get 7 white pixels on the column of the display, its as if it gets scrambled. Compared to writing a direct

myPort.write(0x7F);

Does anyone know if concatenating strings leave some sort of identification on the new string that might be messing this up?

GoToLoop

Re: 0x prefix to serial write byte

3 months ago

You gotta understand that a String in Java is actually an Array of data-type char -> char[].

The literal number 0x7F (or 127) isn't the same as String "0x7F".

And neither String "0x7F" is the same as "0x7f" or "0x007F", etc.

String "0x7F" = char[] {'0', 'x', '7', 'F'}.

In short, it's a sequence of 4 values rather than 1!

When you send a String as argument for method write(),

it converts the String into byte[] using method getBytes().

Thus, it ends up as a sequence of data-type byte representing the former String, which is itself char[].

char[] {'0', 'x', '7', 'F'} becomes byte[] {48, 120, 55, 70}.

Take a look at the ASCII table in this Wikipedia article:

http://en.wikipedia.org/wiki/Ascii

Here's an illustration of this fact:

// final String myHex = "0x7f";
final String myHex = "0x7F";

final char[] myChars = myHex.toCharArray();
final byte[] myBytes = myHex.getBytes();

println(myChars);
println();

println(myBytes);
println();

println(0x7F);

exit();

mskelly

Re: 0x prefix to serial write byte

3 months ago

Hi GoToLoop,

Thanks again for your brilliant explanation. I think I'm getting closer. Based on your explanation above, when I combine the prefix with the byte as a string, and then strip the char values into a byte array and send this as an array of bytes through the serial port I still get a very random display of dots.

String myHex = ("0x" + hex(sum,2));
println(myHex);
byte[] myBytes = myHex.getBytes();
println(myBytes);
myPort.write(myBytes);

Does anyone know how I can make the contents of the bracket below more dynamic, or have suggestions for how to tweak the function above into the same format as the line below. One thought was to cast the 4 chars to an int and send it as one byte, however the display requires the 0x to be before every byte, and it has to be two bit hex. If I take the contents of the byte or char array and add them together and send I end up making a string again which I know will not work.

myPort.write(0x7F);

GoToLoop

Re: 0x prefix to serial write byte

3 months ago

... the display requires the 0x to be before every byte,

Although I don't understand anything about Arduino, serial and such;

it's very strange that 0x must-send demand!

Are you suppose to send char '0', then char 'x' before sending the real byte value itself?

... and it has to be two bit hex.

2-bit hex number? I guess you've meant 2-digit hex number, which in turn, it is an 8-bit byte!

When speaking about bits, it's always in a binary notation format:

println( binary(0x7F, 8) );

You gotta be aware that prefix 0x and others, are just means to express the same value

in different notation formats; like binary, octal, hexadecimal and decimal:

               
                final byte myByte = 0x7F;
                //final byte myByte = 127;
                

                println( "Decimal: \t" + myByte );
                println( "Hex: \t" + hex(myByte) );
                println( "Octal: \t" + Integer.toOctalString(myByte) );
                println( "Binary: \t" + binary(myByte) );
                

                exit();

As you can see at the example above, all of those 4 different representations are the very same value!

It doesn't matter whether myByte was = 127; b/c both 127 & 0x7F are the same number representation!

Prefix 0x only means that you typed the literal in hexadecimal rather than decimal!

Those lines below are exactly the same thing:

myPort.write(0x7F);

myPort.write(127);

Both would send the very same value to your port!

Actually, the generated Java compiled code would be the same!

Perhaps you would also be interested in this Processing's conversion function -> unhex().

Top Reply