Разделить строку на массив

Question

У меня есть строка двоичных чисел, поступающих в мой Arduino.Мне нужно преобразовать их в массив.Данные представляют столбцы света на светодиодном дисплее.В моей программе у меня уже есть рабочая функция, которая принимает массив и использует данные для отображения слов на экране.Данные должны быть отформатированы, как показано ниже:

Моя строка символов может выглядеть по-разному.Вот примеры:

char CurrentWord = "11111110001000000100011111110000000B00000001000001111111110000010000000";

Или

char CurrentWord = "1111111 0001000 0001000 1111111 0000000 B0000000 1000001 1111111 1000001 0000000";

Или даже:

char CurrentWord = "B1111111 B0001000 B0001000 B1111111 B0000000 B0000000 B1000001 B1111111 B1000001 B0000000";

В приведенных выше примерах слово "Hi" будет отображаться на экране.Однако, чтобы диплей работал, данные должны быть преобразованы в массив.так это должно выглядеть так:

int CurrentWordInt[] = {B1111111, B0001000, B0001000, B1111111, B0000000, B0000000, B1000001, B1111111, B1000001, B0000000};

Как я могу это сделать?

Answer 1

c ++ версия:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using namespace std;

int binstrToInt(const char* str){
    int wk = 0;
    while(*str){
        wk = wk * 2 + (*str++ - '0');
    }
    return wk;
}

vector<int> binstrToVector(const char* str, const size_t size){
    vector<int> v;
    istringstream iss(str);

    while(iss){
        ostringstream oss;
        for(int i=0;i<size;){
            char x;
            iss >> x;
            if(x == 'B' || x == 'b') continue;
            oss << x;
            ++i;
        }
        v.push_back(binstrToInt(oss.str().c_str()));
    }
    return v;
}

int main(){
    const char* binstr = "11111110001000000100011111110000000B00000001000001111111110000010000000";
    vector<int> v = binstrToVector(binstr, 7);

    for(int i=0;i<v.size();++i){
        cout << v[i] << endl;
    }
}

Answer 2

Если вопрос заключается в том, как сделать синтаксический анализ C ++ двоичным, используйте этот макрос:

#define B(in) ( ((in&(1<< 0))>> 0) \
               |((in&(1<< 3))>> 2) \
               |((in&(1<< 6))>> 4) \
               |((in&(1<< 9))>> 6) \
               |((in&(1<<12))>> 8) \
               |((in&(1<<15))>>10) \
               |((in&(1<<18))>>12) \
               |((in&(1<<21))>>14) \
               |((in&(1<<24))>>16) \
              )


#include <iostream>
int main() {
    int CurrentWordInt[] = {B(01111111), B(00001000), B(0001000), B(01111111), B(0000000)}; 
    std::cout << CurrentWordInt[0] << ' ';
    std::cout << CurrentWordInt[1] << ' ';
    std::cout << CurrentWordInt[2] << ' ';
    std::cout << CurrentWordInt[3] << ' ';
    std::cout << CurrentWordInt[4] << ' ';
}

Показывает 127 8 8 127 0
Обратите внимание, что этот макрос требует, чтобы все входные данные были нулем, за которым следуют семь единиц / нулей.

Если это не ваш вопрос, тогда я не знаю, о чем вы нас спрашиваете.

Answer 3

class bitbuffer {
    char buffer;
    char held_bits;
    char* input;
public:
    bitbuffer(char* in) :held_bits(0), buffer(0), input(in) {}
    unsigned long long read(unsigned char bits) { 
        unsigned long long result = 0;
        //if the buffer doesn't hold enough bits
        while (bits > held_bits) {
            //grab the all bits in the buffer
            bits -= held_bits;
            result |= ((unsigned long long)buffer) << bits;
            buffer = *(input++);
            held_bits = (char)std::cin.gcount() * CHAR_BIT;
        }
        //append the bits left to the end of the result
        result |= buffer >> (held_bits-bits);
        //remove those bits from the buffer
        held_bits -= bits;
        buffer &= (1ull<<held_bits)-1;
        return result;
    };
};

int main() {
    char* CurrentWord = data from stream
    bitbuffer bitter(CurrentWord);
    int CurrentWordInt[10];
    for(int i=0; i<10; ++i) {
        CurrentWordInt[i] = bitter.read(7); //reads next 7 bits
    }
}

Экстраполировано из моего ответа на Как читать целочисленные данные bitN из двоичного файла? Обратите внимание, что это не проверяет границы и будет читать после конца данного массива.

Answer 4

Вы можете использовать что-то вроде этого:

char alphabet[256][5] = {{B0000000,
                          B0000000,
                          B0000000,
                          B0000000,
                          B0000000},
                          ...
                          //hLetter
                         {B1111111,
                          B0001000,
                          B0001000,
                          B0001000,
                          B1111111},
                          ....
                        };

или

char letter_H[5] = {B1111111,
                    B0001000,
                    B0001000,
                    B0001000,
                    B1111111}

char* translate_to_bitarray(char c)
{
  switch(c)
  {
  case 'H':
  case 'h':
   return letter_H;
  ...
  }
}

и затем создать функцию для перевода всей строки ...

Совет: Используйте «кадровый буфер» - массив из 10 х 5 символов или 10 структур. Отправить в Arduino, нормальный, C струнных. При необходимости преобразуйте символы из строки и поместите их в буфер кадра. Таким образом, вы можете легко создать эффект прокрутки. Используйте структуру для хранения информации о персонаже.

struct character
{
  char _column1;
  char _column2;
  char _column3;
  char _column4;
  char _column5;
}