How does the microcontroller distinguish char, signed/unsigned int, broken and whole numbers and float?
We just covered this in another question.  The cpu (full blown or micro doesnt matter), has no notion of unsigned or signed or float or ascii or decimal.  it is just bits...The programmer, the human, these folks care, but the processor doesnt.  Just like asking the paper how does it know the graphite or ink on it is a picture or words, english or spanish, calculus or algebra?  Doesnt know doesnt care it is just molecules that have attached.  

To the computer these are just bits, for very brief moments of time, one clock or maybe a few, the bits may be operands.

Say you have a pointer

char *p;


you assign that pointer an address

p = (char *)0x1234;


you modify that pointer

p++;


Does the cpu know that memory location is a pointer?  Most certainly not, the first line does nothing but cause the toolchain to declare some space in memory (assuming this isnt optimized into registers) somewhere for this pointer.  The second line causes a store of some immediate to that location, most definitely does not look like an address to the cpu.  The third line causes the memory location to be read, a 1 is added and that number written back.  So the data at that memory location is just some number that for a brief moment was an operand in an add.  Does the processor know unsigned add from signed addition?  nope, the beauty of twos complement makes it so that is not required.   1001 + 1 = 1010 is both 9+1=10 and -7+1=-6 at the same time, it is the reader who cares not the processor.  For both operations you may have a processor with flags and generally, although there may be an exception, both the signed and unsigned overflow flags are computed.  Then after that perhaps the human programmer may say if this is less than that using a signed variable in some programming language then one or the other flag or a combination of all the flags may be used.  The cpu doesnt care it just executes instructions (more bits, it cant tell an instruction from data, the bits have to be carefully ordered so that as they are interpreted by the cpu it doesnt try to execute what the human thinks is data) what it is told to execute, if you say compare the signed overflow flag it will if you tell it to compare the unsigned overflow flag it will.

char *p;
unsigned int x;
void fun ( void )
{
    p=(char *)0x1234;
    x=0x1234;
    p++;
    x++;
}


gives

00000000 &lt;fun&gt;:
   0:   e59f3010    ldr r3, [pc, #16]   ; 18 &lt;fun+0x18&gt;
   4:   e59f1010    ldr r1, [pc, #16]   ; 1c &lt;fun+0x1c&gt;
   8:   e59f2010    ldr r2, [pc, #16]   ; 20 &lt;fun+0x20&gt;
   c:   e5813000    str r3, [r1]
  10:   e5823000    str r3, [r2]
  14:   e12fff1e    bx  lr
  18:   00001235    andeq   r1, r0, r5, lsr r2


the compiler took what the human wanted to have done, and created the machine code and data to get it done.

Notice how the instructions and thus the cpu cant tell a pointer from a simple variable?

int sfun ( int x )
{
    return(x-9);
}
unsigned int ufun ( unsigned int x )
{
    return(x+0xFFFFFFF7);
}


gives

00000000 &lt;sfun&gt;:
   0:   e2400009    sub r0, r0, #9
   4:   e12fff1e    bx  lr

00000008 &lt;ufun&gt;:
   8:   e2400009    sub r0, r0, #9
   c:   e12fff1e    bx  lr


did what I asked in an optimized way, cpu cant tell a signed from unsigned.