Почему символы со значением выше 127 "дополняются" 1s длиной 16 бит, а символы со значениями 0-127 - нет?

Я использую Arduino IDE для запуска и мониторинга с помощью клона Arduino Nano. Этот код показывает, что я имею в виду под вопросом:

char foo = 127;
char bar = 128;
Serial.println(String(foo, BIN));
Serial.println(String(bar, BIN));
foo = 383;
bar = 384;
Serial.println(String(foo, BIN));
Serial.println(String(bar, BIN));

С принтами

1111111
1111111110000000
1111111
1111111110000000

Это все еще происходит, если я затем приведу элементы к char, но не если я приведу их к uint8_t:

char foo = 127;
char bar = 128;
Serial.println(String((char)foo, BIN));
Serial.println(String((char)bar, BIN));
Serial.println(String((uint8_t)foo, BIN));
Serial.println(String((uint8_t)bar, BIN));

1111111
1111111110000000
1111111
10000000

Он ведет себя так же, если я делаю некоторую арифметику:

char foo = 127;
char bar = 128;
Serial.println(String(foo / 64, BIN));
Serial.println(String(bar / 64, BIN));

1
1111111111111110

Почему это так? Если я назначаю число больше 255, но меньше 384, оно ведет себя так же, как и для чисел ниже 128, но выше этого оно делает это снова, так что очевидно, что только наименее значимые 8 бит значения хранятся как ожидалось, но в тех случаях, когда (n mod 255)> 127 (таким образом, 8-й бит равен 1) они извлекаются из памяти вместе с другими 8 битами, которые все равны 1с.

Я могу жить без ответа на вышеприведенный вопрос, но мне действительно нужно подтвердить следующее:

Если бы я хранил и извлекал uint16_t как два элемента char[], это всегда было бы безопасно (и не неопределенное поведение), если бы я сделал это следующим образом, верно?:

uint16_t foo = 34952;
char bar[2];
bar[0] = foo >> 8;
bar[1] = foo;
uint16_t extracted = (uint16_t((uint8_t)bar[0])) << 8 | (uint8_t)bar[1];

Заранее благодарю вас за любую помощь, которую вы можете оказать.