But a character does not have to be a char and I have just noticed that your question
Makes no sense. I originally read it as "!" and replied with that in mind, but now see that it is actually '!"
I assume that you meant
what's the difference? 33 vs '!', the answer to which is nothing
Are we having fun yet 
These are both misleading and instructive. The simpler
Serial.print('a');
selects -- of the dozen overloads -- as shown when hovering over that function name print in the IDE
so it prints as text. Adding the second argument, HEX or DEC (or OCT or BIN or any number)
The (best) match is to promote the char to an int
int as the second argument
DEC
int, you don't need that second argument at allthat prints a number: its ASCII value. One way to get a char closer to an int is with the simplest cast
Serial.print(static_cast<signed char>('a'));
They are both signed. In contrast
Serial.print(static_cast<unsigned char>('a'));
actually matches a separate overload
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
which does effectively the same thing, but as an unsigned value. For 7-bit ASCII characters, no difference.
This thread is is prime example of how things spiral out of control when it starts with the OP asking a poor question and then refusing to follow up with clarification and actual code. I hope @chrisgadg will do better next time.
i find it fun to watch - it's so predictable 
sounds elitist
... glad you're entertained
Just looking to print out the ASCCI value of a char?
int value = (int)aChar;
Uhmm.. you mean this?:
const char *Initials = "z";
int Integer = (int) *Initials;
With a smiley though
I’m sure we have had similar discussion here already a number of times where OP’s question is insufficiently qualified and OP does not provide meaningful clarification and the forum goes wild in offering various hints and questions and diverge etc…
The long story short is that if OP has
String messages[3];
And he wants to get the encoding value of the first (and only or not) character in this string is just
messages[0][0], messages[1][0] and messages[2][0]
The underlying type is char but char are implicitly promoted into integrals if used in maths operations for example.
(And to throw a bit of confusion and get the forum to go again in new conjectures - Where this becomes fun is if the first human readable character is an non ASCII character - like a 2 3 or 4 byte long UTF8 char… another debate ?)
If OP does not want the ascii encoding but an hex corresponding value then he should say so.
If OP has 0 to 9 and a or A to f or F in there and wants the numeric hex encoded value then a one liner could be
int value = isxdigit(messages[0][0]) ? (isdigit(messages[0][0]) ? messages[0][0] - '0' : tolower(messages[0][0]) - 'a' + 10) : -1;
No if, no switch case
An alternative is also possible with a standard function
With strtol, the correctness check is based on where endptr lands. If exactly one hex digit is valid, endptr should advance by one character.
const char* s = messages[0].c_str();
char* endptr;
long v = strtol(s, &endptr, 16);
if (endptr == s + 1 && v >= 0 && v <= 15) {
// all was fine
} else {
// error
}
Here you go I participated in the fun 
Ah, as in most longer threads. I missed the entire "Hex" bit.
I don't know if I understood correctly if this is what is being discussed, but I believe the answer is this.
The confusion comes from C++. By default, the system automatically treats the character '1' as if it has the mathematical value 1. If you don't specify otherwise, it does everything on its own.
This mechanism is built to guess whether it is 1 or 49. But this hidden guessing game tricks so many users, because it makes them believe that the computer naturally understands human letters. In reality, 49 is the only true value!
The meaning of a valid declaration/definition of a variale depend on the "set-of-rules (the protocl)" which te two or more parties have agreeed to follow. Here, the protocol is among the C++ programmers and the C++ compler.
1. Valid definition:
char ch = '1';
Now, you tell me what binary bits will be stored in a one-byte RAM location?
2.
What will appear on Serial Monoto if execute the following code?
Serial.print(ch);
3. What will appear on Serial Monitor if I execute te following code?
Serial.print(ch, DEC);
You asked me these questions to prove the C++ protocol, but you actually proved my point. Now you have to admit that looking at this through ASM makes it much easier to understand!
Here is the raw hardware reality of your 3 questions, using pure bits instead of hidden rules:
1. What binary bits are stored in RAM?
0b00110001 (which is the raw number 49).
The RAM slot has no idea what a 'character' is. It only holds those 8 electrical switches.
2. What appears with Serial.print(ch)?
The screen draws the symbol "1". This happens because the C++ protocol automatically decides to look up 49 (0b00110001) in the ASCII font table and paint that shape. It hides the 49.
3. What appears with Serial.print(ch, DEC)?
The screen prints "49". You had to add ", DEC" to force C++ to stop hiding the reality and finally show the true numeric value of those bits.
This is exactly why I say ASM is better for beginners! In C++, you have to jump between 3 different interpretations for the exact same byte of RAM. In ASM, there is no "set of rules" or protocol to guess. You see 0b00110001, you know it is 49, and you understand the whole picture instantly without magic!
Is this a wind-up ?
Please post the ASM equivalent of the Arduino Blink sketch so that I can see how much more obvious it is what is going on
RAM location does not store 0b and elsetrical switches.
Wrong! Screen shows: 1
The screen shows: 49
@UKHeliBob @GolamMostafa Let’s look at the real practice instead of playing with words.
Here is the perfect ASM example to show why low-level is more obvious for a beginner. Look at what happens when you push numbers directly into the Serial Data Register (UDR0 / Box 0xC6):
Pushing 49 into the serial register:
ldi r16, 49
sts 0xC6, r16 --> The PC receives 49 and the screen shows: 1
Pushing 1 into the serial register:
ldi r16, 1
sts 0xC6, r16 --> The PC receives 1 and the screen shows: NOTHING!
In C++, when a beginner writes '1', the compiler hides the background and makes them think the chip sees the mathematical value 1. But this test proves the total confusion of the high-level illusion: if the chip actually saw the number 1, the screen would show "1" in both cases.
ASM doesn't play guessing games or hide behind protocols. It shows the beginner the single, raw reality: the hardware only understands the number 49 to show the digit 1, and the number 1 is a hidden system command. This is why looking at the raw registers makes it much easier to understand!
void setup() {
Serial.begin(9600); // Initialize serial hardware at 9600 baud
}
void loop() {
// Test 1: Pushing 49 in binary into the register
asm volatile(
"ldi r16, 0b00110001 \n\t" // 49 in binary
"sts 0xC6, r16 \n\t" // 0xC6 is the UDR0 register address
);
delay(1000);
// Test 2: Pushing 1 in binary into the register
asm volatile(
"ldi r16, 0b00000001 \n\t" // 1 in binary
"sts 0xC6, r16 \n\t"
);
delay(1000);
}
i pasted gpt response but with my help,because i dont speak better english , i born in Romania but live for about 20 years in italy, belive ... if not exixt chat gpt you cn understand what i did! ... but i have only costycnc account ... where you see @costycnc, @costycnc and his triplicate account @costyca ???
yes ... you are right but i dont know because! i see now!
That's why I said you bot but you did not challenge.
but what is important , the 1 and 49 that can verify both in my asm tool or in arduino ide or because i prepare response with chat gpt! belive me if ask chat gpt to make asm and if not understand asm , the code not working, i need adjust chat gpt many times until give me a good response , because also chat gpt not known asm! is better my english now or prefer that rispond with help of chat gpt?
