Arduino.ru

Что называется какой вопрос такой ответ:

byte One[]= { 0b0000000, 0b01000010, 0b01111111, 0b01000000, 0b00000000 };// 1    49

Как Как мы видим они представлены в двоичной системе.

Любые данные можно выводить в любом виде, посмотрите itoa() например

Спасибо за ответ, поясню меня инетерсует автоматизация этого процесса и создание бинарного массива сначало для byte One[0], потом byte One[1]...byte One[i], в цикле.

Про itoa(), сейчас почитаю.

массив он и есть массив, как только вы его обьяаили, он уже создан и лежит

Вы скорее всего говорите о выводе этого массива в serial, тогда как вариант - itoa с базой 2 ( двоичная) во временную строковую переменную, а затем Serial.print  этой переменной

Можно сдедать Serial.print(переменная , BIN); без itoa.

Можете написать простой пример как из 16ой в 2юю систему используя itoa перевести переменную?

Мне именно нужно дальше с данными работать, обрабатывать их. А Serial я могу использовать, но само устройство будет не подключено к компьютеру, и вывод чего-то в сериал бесполезен. Я уже думал, что как-то можно задействовать буфер для перевода переменных из разных систем счисления.

Как бы не инициализировался массив (или переменная), данные всегда хранятся в бинарном виде. Всё остальное - вопрос отображения этих данных.

Т.о. строки:

byte One[]= { 0x00, 0x42, 0x7F, 0x40, 0x00 };// 1    49
и
byte One[]= { 0b0, 0b01000010, 0b01111111, 0b01000000, 0b0 };// 1    49

дают один и тот же код. Т.е. можете использовать любой удобный для Вас вариант.

Инициализация массива в цикле - редко применяется, однако если сформулируете конкретней, тогда будет понятно что ответить.
Код:

for( byte i = 0; i < 5; i++ )
{
  One[ i ] = i * 10;
}

редко бывает применим, но иногда - бывает.

Если предположить, что под циклом понимается loop, тогда, например, так:

#define MAX_KOL 5
byte One[MAX_KOL] = { 0, 1, 3, 6, 0 };

byte index = 0;

void loop()
{
  One[ index ] = analogRead( inptuPin ) & 0xFF;
  index++;
  if( index >= MAX_KOL )
  {
    index = 0; Или что то другое, чтобы индекс не вышел за пределы массива
  }
}

Ни пса все таки не понял вопроса

Выводить вам в сериал не надо ?  

Перевод в различные системы имеют смысл помойму только при выводе, Ваш byte лежит в памяти уже в машинном виде, то есть практически в двоичном. Ну переведете вы его char* в двоичном представлении , а как его использовать если не для вывода ?

Вот пример использования itoa для получения стринга представляющего двоичный вид  десяти

 char A[100];
 
     itoa(10,A,2); //

вместо 10 можно поставить байт из вашего массива, шеснадцатиричную константу, да что угодно.

Ваша корреная ошибка в том, что вы не различаете "значение" и "представление".

значение - это то что хранится в переменной.
представление - это то что мы пишем в коде и выводим через serial.print

одно и тоже значение - может быть показанно/записанно в разном виде.

процессору - важно значения, представление - это то что видит человек.

Это как есть предмет "стол". Для русско-язычного человека мы покажем на него пальцем и скажем "это стол", а для англичанина скажем "this is  a table". От того как мы его "назвали/прдеставили" - стол не изменил своей сути (он об этом даже не узнал). Мы просто назвали его по русски и английски в зависимости от того как нам счас удобней его назвать. 

Так и у вас. Когда вы говорите "как переменную перевести из 2-ичной, в 16-тиричную", это все равно что взять предмет "стол " и спросить как сделать так что-бы он стал "table", а не "стол".

byte digit=10;
Serial.println(digit); // "Представляем" в десятчной"
Serial.println(digit,HEX); // "Представляем" в шестднацатеричной"
Serial.println(digit,BIN); // "Представляем" в двоичной"

Как видите, мы одно и тоже число, просто "выводим по разному". У самой переменно gigit вообще нет понятия "системы исчисления". Такое свойство отсуствует. Система исчисление "выходит на сцену", только когда у нас возникает потребоность записать какое-то числовое ЗНАЧЕНИЕ в виде СТРОКИ. 

byte digit=10;
Serial.println(digit); // "Представляем" в десятчной"
Serial.println(digit,HEX); // "Представляем" в шестднацатеричной"
Serial.println(digit,BIN); // "Представляем" в двоичной"

Специально для топикстартера: а ведь еще и в восьмиричном представлении то же самое значение можно вывести ;) ;) ;):

Serial.println(digit,OCT); // "Представляем" в восьмиричной"

Serial.println(digit,OCT); // "Представляем" в восьмиричной"

Можно вообще свое собственное представление придумать :) Например выводить число "цветом". Это тоже "представление", но это не значит что "переменная стала цветной".

Или в какую-нибудь экзотику напимер начать выводить в виде узелковой письменности инков  или перейти на систему остаточных классов

Вообщем способов "взорвать мозг" тому кто будет потом сопровождать код - масса ;)

step962, leshak, Borland, kisoft, Спасибо вам за помощь.

Сейчас поясню Вам свою задачу.

У нас есть на входе много массивов вида:

0x7F, 0x09, 0x09, 0x01, 0x01,// F    70
0x3E, 0x41, 0x41, 0x51, 0x32,// G    71
0x7F, 0x08, 0x08, 0x08, 0x7F,// H    72
0x00, 0x41, 0x7F, 0x41, 0x00,// I    73
0x20, 0x40, 0x41, 0x3F, 0x01,// J    74
0x7F, 0x08, 0x14, 0x22, 0x41,// K    75
0x7F, 0x40, 0x40, 0x40, 0x40,// L    76
0x7F, 0x02, 0x04, 0x02, 0x7F,// M    77

Все значения внутри массива, в шестнадцатеричной форме.

Далее мы считываем первое значение первого массива, в нашем случае 0x7F, переводим в двоичный вид "1111111", далее записываем значения в массив array[]={1,1,1,1,1,1,1}. потом мы работаем с этими данными, потом снова считываем слудующее значение 0x09, переводим в другую сиситему счисления, в массив и так далее

Вот какую задачу я себе поставил. И не могу решить. 

Если я правильно понял, то типик-стартер в итоге хотел вот это:

byte One[]= { 0x00, 0x42, 0x7F, 0x40, 0x00 };// 1    49
#define TOTAL sizeof(One)/sizeof(byte) // вычисляем количество элементов в One[]


void setup(){
 Serial.begin(9600);

  // выводим массив One в раных представлениях
  for(unsigned int i=0;i< TOTAL;i++){
     Serial.print(i); Serial.print(": "); // номер элемента
     
     Serial.print("DEC=");Serial.print(One[i],DEC); // выодим в десятичной
     Serial.print(", HEX=");Serial.print(One[i],HEX); // выодим в шестнадцатеричной
     Serial.print(", BIN=");Serial.print(One[i],BIN); // выодим в двоичной
     
  }
}

void loop(){
}

У вас есть фактически две задачи.

"Считать" и "вывести".

Вывести - я вам уже дал код выше.

"Прочитать" - слишком расплывчато. Смотря откуда читать.

>переводим в двоичный вид "1111111", далее записываем значения в массив array[]={1,1,1,1,1,1,1}

А это извините немного другая задача. Это не "переводм в двоичный вид". Это "заполнить массив байтов, в соотвествии со значении битов в какой-то переменной".

Это идти в http://arduino.cc/en/Reference/HomePage и читать  "Bitwise Operators" (если хочется вправду научится, по правильно как "взрослые пацаны") или раздел "Bits and Bytes" (если хочется "по чайниковский-ардуиновски", лиш-бы заработало).

void setup(){
  byte val=147; // какое-то значение;
  
  byte bites[8]; // массив куда будем разбирать занчения
  
  // разбираем на биты  
  for(byte i=0;i<8;i++){
    bites[i]=bitRead(val,i); 
  }

  // выводим наши биты  
  for(byte i=7;i>=0;i--){ // обратите внимание что идем в обратом порядке. так как в массив мы запихнули "младшие биты" первыми
    Serial.print(bites[i]);
    Serial.print(", ");
  }
  
  Serial.println();
  
}

Update: пофиксал ошибку во втором цикле, всемето i++, нужно i--

void setup(){
  byte val=147; // какое-то значение;
  
  byte bites[8]; // массив куда будем разбирать занчения
  
  // разбираем на биты  
  for(byte i=0;i<8;i++){
    bites[i]=bitRead(val,i); 
  }

  // выводим наши биты  
  for(byte i=7;i>=0;i--){ // обратите внимание что идем в обратом порядке. так как в массив мы запихнули "младшие биты" первыми
    Serial.print(bites[i]);
    Serial.print(", ");
  }
  
  Serial.println();
  
}

Спасибо большое, очень полезно!

void setup(){
  byte val=147; // какое-то значение;
  
  byte bites[8]; // массив куда будем разбирать занчения
  
  // разбираем на биты  
  for(byte i=0;i<8;i++){
    bites[i]=bitRead(val,i); 
  }

  // выводим наши биты  
  for(int i=7;i>=0;i--){ // обратите внимание что идем в обратом порядке. так как в массив мы запихнули "младшие биты" первыми
    Serial.print(bites[i]);
    Serial.print(", ");
  }
  
  Serial.println();
  
}

во втором цикле инт i 

так будет правильней

signed char правильнее.

Всем здравствуйте!!! Вопрос , не знаю в тему или нет... имеется цвет (ниже) .  Как его перевести в формат в виде 0x0000 , весь инет облазил, везде нахожу что это шестнадцатиричный формат, что и без того понятно...А чтобы сконвертить правильно нигде этого нет.. Кто знает объясните принцип пожалуйста....

Так это и есть 0xCD00CD

Название цвета - это человеческая категория. Категорически нет никакого алгоритма преобразования "цвета мякоти северно-атлантического лосося в период нереста" в компоненты R, G и B.

Самое простое - это взять таблицу Pantone и выбирать из неё.

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

Там маска после x 4 символа , а здесь 6 символов, пробую как Вы указали, совсем другой цвет... темно синий

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

Ничего не понятно, но очень интересно...  а как нить словами можно? Вот к примеру такой цвет  rgb(255, 38, 38) он же в шестнадцатеричном - #FF2626, а как будет выглядеть в формате 0x0000 ? 

Взял таблицу, но цвета то там есть, но шестнадцатиричного кода в виде 0x0000 нет(( там просто номер цвета да и все

Первый попавшийся цвет:

https://www.pantone.com/color-finder/120-C

HEX/HTML FBDB65

Но вот с чего вы решили, что три байта можно в два уложить - мне пока непонятно. Опять какой-нить Гувер мутит воду?

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

Вероятно Вам нужно преобразовать цвет из трехбайтового представления (TrueColor), активно используемого в ПК, в двухбайтовое (HiColor), активно используемое в дисплеях для Ардуино (в ПК тоже использовалось - ориентировочно в 90-х годах прошлого века).

Основная идея: из красного и синего берется по 5 старших битов, а из зеленого - 6 и все это складывается в 16-битное число. Формула, по которой это делается, приведена выше.

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

все верно это нужно для дисплея, да, формула прекрасно работает, при этом получается десятичное число, которое также можно использовать для задания цвета, но я хотел понять принцип преобразования как вы правильно заметили из 3-х цветного в 2-х ...ну да ладно..и на этом огромное спасибо, теперь могу свой цвет задать который я хочу а не который в списке у них

Не знаю кто такой Гувер ...))) но для определения цвета в 16-ом исполнении лучше воспользоваться конвертером... https://colorscheme.ru/color-converter.html , интересно было как они укладывают 3 байта в 2...))

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

Ну а Вам спасибище за функцию...

uint_16t color565( byte r,  byte g, byte b )
{
	return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( ( b & 0xF8 ) >> 3 );
}

а тему лучше было сделать отдельно - преобразование трёхбайтного значения цвета RGB в двухбайтное для дисплеев TFT Arduino, 100500 - потеряется вопрос

Преобразование ... (далее по тексту) было актуально четверть века назад, когда Ардуино еще не было в проекте.

Да и вопрос-то банальный. (еще бы он не был банальным, когда решение в одну строчку.)

блин, ну вам же дали функцию?Там всего одна строка!  вам одна строка кода непонятна? - так тут дело не в цвете, а в то что вы Си не знаете. Берите учебник и смотрите, что означает X <<5 или X>>3