Convert Character to Binary and output to 8 pins

Other Hardware Displays
1

Hello everyone. I am currently working on a project to drive a 16x2 LCD displays without a library. While I accomplished most things (custom characters, text on the display) my code is not really practical to use and I want to rewrite it.

For the start, I would like to know how to convert a Character like "H" to binary, save it to a variable and then put it out over 8 pins. The second part I might be able to do on myself, but definitely not the first one.

here's my code btw:

#define RS_A 2               // _A für ARDUINO
#define RW_A 3
#define E_A 4
#define D0_A 5
#define D1_A 6
#define D2_A 7
#define D3_A 8
#define D4_A 9
#define D5_A 10
#define D6_A 11
#define D7_A 12

int delay_time = 200;         // damit das schreiben cooler aussieht

void data_stream(int D7_D, int D6_D, int D5_D, int D4_D, int D3_D, int D2_D, int D1_D, int D0_D){          // _D für DATA  // für Anweisungen
  digitalWrite(D0_A, D0_D);
  digitalWrite(D1_A, D1_D);
  digitalWrite(D2_A, D2_D);
  digitalWrite(D3_A, D3_D);
  digitalWrite(D4_A, D4_D);
  digitalWrite(D5_A, D5_D);
  digitalWrite(D6_A, D6_D);
  digitalWrite(D7_A, D7_D);
}

void rs_rw_stream(int RS_D, int RW_D){  // um Register auszuwählen und zwischen schreiben und lesen zu wechseln
  digitalWrite(RS_A, RS_D);
  digitalWrite(RW_A, RW_D);
}

void enable(){                          // um das Display zu triggern
  digitalWrite(E_A, HIGH);
  digitalWrite(E_A, LOW);
}

void clear(){                           // löscht das Display, setzt DDRAM auf 00Hex
  data_stream(0,0,0,0,0,0,0,1);
  rs_rw_stream(0,0);
  enable();
}

void writeChar(int a, int b, int c, int d, int e, int f, int g, int h) {  // Funktion um Charactäre an das Display zu senden; abc usw. ignorieren
  data_stream(a,b,c,d,e,f,g,h);
  rs_rw_stream(1,0);
  enable();
  delay(delay_time);
}

void setDDRAM(int a, int b, int c, int d, int e, int f, int g) {          // Funktion um DDRAM Adresse auf bestimmenten Wert (Hex) zu setzen; abc usw. ignorieren
  data_stream(1,a,b,c,d,e,f,g);
  rs_rw_stream(0,0);
  enable();
  delay(2);
}

void writecg(int a, int b, int c, int d, int e) {                         // Funktion um an CGRAM zu schreiben; abc usw. ignorieren
  data_stream(0,0,0,a,b,c,d,e);
  rs_rw_stream(1,0);
  enable();
}

void setcg(int a, int b, int c, int d, int e, int f) {                    // Funktion um CGRAM Adresse auf bestimmen Wert zu setzten; abc usw. ignorieren
  data_stream(0,1,a,b,c,d,e,f);
  rs_rw_stream(0,0);
  enable();
}

void customChar_1() {     // eigener Charakter 1
  setcg(0,0,0,0,0,0);     // start 0x00
  writecg(0,0,1,0,0);     // ⬛⬛⬜⬛⬛
  writecg(0,1,1,1,0);     // ⬛⬜⬜⬜⬛
  writecg(0,1,1,1,0);     // ⬛⬜⬜⬜⬛
  writecg(1,1,1,1,1);     // ⬜⬜⬜⬜⬜
  writecg(1,1,1,1,1);     // ⬜⬜⬜⬜⬜
  writecg(1,1,1,1,1);     // ⬜⬜⬜⬜⬜
  writecg(0,0,1,0,0);     // ⬛⬛⬜⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x07

void customChar_2() {     // eigener Charakter 2
  setcg(0,0,1,0,0,0);     // start 0x08
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x0F

void customChar_3() {     // eigener Charakter 3
  setcg(0,1,0,0,0,0);     // start 0x10
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x17

void customChar_4() {     // eigener Charakter 4
  setcg(0,1,1,0,0,0);     // start 0x18
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x1F

void customChar_5() {     // eigener Charakter 5
  setcg(1,0,0,0,0,0);     // start 0x20
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x27

void customChar_6() {     // eigener Charakter 6
  setcg(1,0,1,0,0,0);     // start 0x28
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x2F

void customChar_7() {     // eigener Charakter 7    
  setcg(1,1,0,0,0,0);     // start 0x30
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x37

void customChar_8() {     // eigener Charakter 8
  setcg(1,1,1,0,0,0);     // start 0x38
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
  writecg(0,0,0,0,0);     // ⬛⬛⬛⬛⬛
}                         // ende 0x3F

void setup() {
  pinMode(13, INPUT);                   // reset Knopf; eigentlich Nutzlos; für Notfälle

  pinMode(RS_A, OUTPUT);                // setzt RS_A auf OUTPUT           
  pinMode(RW_A, OUTPUT);                // setzt RW_A auf OUTPUT
  pinMode(E_A, OUTPUT);                 // setzt E_A  auf OUTPUT
  pinMode(D0_A, OUTPUT);                // setzt D0_A auf OUTPUT
  pinMode(D1_A, OUTPUT);                // setzt D1_A auf OUTPUT
  pinMode(D2_A, OUTPUT);                // setzt D2_A auf OUTPUT
  pinMode(D3_A, OUTPUT);                // setzt D3_A auf OUTPUT
  pinMode(D4_A, OUTPUT);                // setzt D4_A auf OUTPUT
  pinMode(D5_A, OUTPUT);                // setzt D5_A auf OUTPUT
  pinMode(D6_A, OUTPUT);                // setzt D6_A auf OUTPUT
  pinMode(D7_A, OUTPUT);                // setzt D7_A auf OUTPUT
  
  clear();                              // um nach jedem reset das Display zu clearen und DDRAM Adresse 00 zu setzen 
  delay(10);                            // dieses Delay ist wichtig; mindestens 1,55ms
  
  data_stream(0,0,1,1,1,0,0,0);         // 8-bit Modus; 2 Zeilen; 5x8 Schrift
  rs_rw_stream(0,0);
  enable();
  data_stream(0,0,0,0,1,1,1,0);         // aktiviert den Cursor (kein blinken); letzte Zahl ändern um blinkenden Curor zu toggeln
  rs_rw_stream(0,0);
  enable();
  data_stream(0,0,0,0,0,1,1,0);         // verschiebe die Register Adresse jedes mal +1
  rs_rw_stream(0,0);
  enable();
  
  writeChar(0,1,0,0,1,0,0,0);           // H schreiben
  writeChar(0,1,1,0,0,1,0,1);           // e schreiben
  writeChar(0,1,1,0,1,1,0,0);           // l schreiben
  writeChar(0,1,1,0,1,1,0,0);           // l schreiben
  writeChar(0,1,1,0,1,1,1,1);           // o schreiben
  writeChar(0,0,1,0,1,1,0,0);           // , schreiben
  writeChar(0,0,1,0,0,0,0,0);           //   schreiben
  writeChar(0,1,0,1,0,1,1,1);           // W schreiben
  writeChar(0,1,1,0,1,1,1,1);           // o schreiben
  writeChar(0,1,1,1,0,0,1,0);           // r schreiben
  writeChar(0,1,1,0,1,1,0,0);           // l schreiben
  writeChar(0,1,1,0,0,1,0,0);           // d schreiben
  writeChar(0,0,1,0,0,0,0,1);           // ! schreiben
  
  setDDRAM(1,0,0,0,0,0,0);              // setzt DDRAM Adresse auf 40Hex --> 2te Zeile; siehe display character adress code (Seite 11)

  writeChar(0,1,0,0,1,1,1,1);           // O schreiben
  writeChar(0,1,1,0,1,0,0,0);           // h schreiben
  writeChar(0,1,1,0,1,1,1,0);           // n schreiben
  writeChar(0,1,1,0,0,1,0,1);           // e schreiben
  writeChar(0,0,1,0,0,0,0,0);           //   schreiben
  writeChar(0,1,0,0,0,0,1,0);           // B schreiben
  writeChar(0,1,1,0,1,0,0,1);           // i schreiben
  writeChar(0,1,1,0,0,0,1,0);           // b schreiben
  writeChar(0,1,1,0,1,1,0,0);           // l schreiben
  writeChar(0,1,1,0,1,0,0,1);           // i schreiben
  writeChar(0,1,1,0,1,1,1,1);           // o schreiben
  writeChar(0,1,1,1,0,1,0,0);           // t schreiben
  writeChar(0,1,1,0,1,0,0,0);           // h schreiben
  writeChar(0,1,1,0,0,1,0,1);           // e schreiben
  writeChar(0,1,1,0,1,0,1,1);           // k schreiben
  writeChar(0,0,1,0,0,0,0,1);           // ! schreiben
}

void loop() {
  if (digitalRead(13) == LOW) {
    clear();
  }
}
2

bitRead is a handy function.

"H" is a string, but 'H' is a character, and is already binary

3

thanks a lot

after reading through the reference, I came up with this

void binary(char Char) {
  int i;
  int n = 8;
  int pos = 0;
  for(i = 0; i < n; i++) {
    Serial.print(bitRead(Char, pos));
    pos += 1;
  }
}

edit: and I implemented it into my code

example of printing H:

#define RS_A 2               // _A für ARDUINO
#define RW_A 3
#define E_A 4
#define D0_A 5
#define D1_A 6
#define D2_A 7
#define D3_A 8
#define D4_A 9
#define D5_A 10
#define D6_A 11
#define D7_A 12

int delay_time = 300;         // damit das schreiben cooler aussieht

void data_stream(int D7_D, int D6_D, int D5_D, int D4_D, int D3_D, int D2_D, int D1_D, int D0_D){          // _D für DATA  // für Anweisungen
  digitalWrite(D0_A, D0_D);
  digitalWrite(D1_A, D1_D);
  digitalWrite(D2_A, D2_D);
  digitalWrite(D3_A, D3_D);
  digitalWrite(D4_A, D4_D);
  digitalWrite(D5_A, D5_D);
  digitalWrite(D6_A, D6_D);
  digitalWrite(D7_A, D7_D);
}

void rs_rw_stream(int RS_D, int RW_D){  // um Register auszuwählen und zwischen schreiben und lesen zu wechseln
  digitalWrite(RS_A, RS_D);
  digitalWrite(RW_A, RW_D);
}

void enable(){                          // um das Display zu triggern
  digitalWrite(E_A, HIGH);
  digitalWrite(E_A, LOW);
}

void clear(){                           // löscht das Display, setzt DDRAM auf 00Hex
  data_stream(0,0,0,0,0,0,0,1);
  rs_rw_stream(0,0);
  enable();
}


void binary(char Char) {
  int pointer = 12;
  int i;
  int n = 8;
  int pos = 0;
  for(i = 0; i < n; i++) {
    Serial.print(bitRead(Char, pos));
    digitalWrite(pointer, bitRead(Char, pos));
    pos += 1;
    pointer -= 1;
  }
}



void setup() {
  pinMode(RS_A, OUTPUT);                // setzt RS_A auf OUTPUT           
  pinMode(RW_A, OUTPUT);                // setzt RW_A auf OUTPUT
  pinMode(E_A, OUTPUT);                 // setzt E_A  auf OUTPUT
  pinMode(D0_A, OUTPUT);                // setzt D0_A auf OUTPUT
  pinMode(D1_A, OUTPUT);                // setzt D1_A auf OUTPUT
  pinMode(D2_A, OUTPUT);                // setzt D2_A auf OUTPUT
  pinMode(D3_A, OUTPUT);                // setzt D3_A auf OUTPUT
  pinMode(D4_A, OUTPUT);                // setzt D4_A auf OUTPUT
  pinMode(D5_A, OUTPUT);                // setzt D5_A auf OUTPUT
  pinMode(D6_A, OUTPUT);                // setzt D6_A auf OUTPUT
  pinMode(D7_A, OUTPUT);                // setzt D7_A auf OUTPUT
  
  clear();                              // um nach jedem reset das Display zu clearen und DDRAM Adresse 00 zu setzen 
  delay(10);                            // dieses Delay ist wichtig; mindestens 1,55ms
  
  data_stream(0,0,1,1,1,0,0,0);         // 8-bit Modus; 2 Zeilen; 5x8 Schrift
  rs_rw_stream(0,0);
  enable();
  data_stream(0,0,0,0,1,1,1,0);         // aktiviert den Cursor (kein blinken); letzte Zahl ändern um blinkenden Curor zu toggeln
  rs_rw_stream(0,0);
  enable();
  data_stream(0,0,0,0,0,1,1,0);         // verschiebe die Register Adresse jedes mal +1
  rs_rw_stream(0,0);
  enable();
  
  binary("H");
  rs_rw_stream(1,0);
  enable();

  
}

void loop() {
}
4

That is the idea, but you do not need the pos +=1, set the for loop indexer to n < 7; and use the for loop indexer (n) in the bitRead function (see below).

Here is a demo that reads a character from the serial port and sends the ASCII character code out to an array of 8 pins.

// serial input basics Example 1 - Receiving single characters
// https://forum.arduino.cc/t/serial-input-basics-updated/382007
// set serial monitor baud rate to 115200 and line endings to "no line ending"

const byte pins[] = {2, 3, 4, 5, 6, 7, 8, 9};

char receivedChar;
boolean newData = false;

void setup()
{
   Serial.begin(115200);
   Serial.println("<Arduino is ready>");
   for (int n = 0; n < 7; n++)
   {
      pinMode(pins[n], OUTPUT);
   }
}

void loop()
{
   recvOneChar();

   if (newData == true)
   {
      for (int n = 0; n < 7; n++)
      {
         digitalWrite(pins[n], bitRead(receivedChar, n));
      }
      newData == false;
   }
}

void recvOneChar()
{
   if (Serial.available() > 0)
   {
      receivedChar = Serial.read();
      Serial.println(receivedChar, BIN);
      newData = true;
   }
}
5

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.