Arduino.ru

Общая идея как это сделать - берем 1 число digit[1], применяем к нему & B11111111 - получаем 8 бит, сохраняем. Далее смещаем побитно 8 раз digit[1]>>8. берем digit[2]<<5 смещаем его на 5, складываем, опять оператор И. И т.д. 

Чтото сложно примудро, без примера не понять.

Вытащил кусок ардуины arduino-1.6.8\hardware\arduino\avr\cores\arduino\wiring_shift.c

void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val)
{
	uint8_t i;

	for (i = 0; i < 8; i++)  {
		if (bitOrder == LSBFIRST)
			digitalWrite(dataPin, !!(val & (1 << i)));
		else	
			digitalWrite(dataPin, !!(val & (1 << (7 - i))));
			
		digitalWrite(clockPin, HIGH);
		digitalWrite(clockPin, LOW);		
	}
}

Может както побитно сюда можно втолкнуть ?

Уважаемый, да забудьте уже про пины - Вы работаете с числами! Во-первых 16 битное число лучше обозвать uint16_t digit[4]. Только у ВАс в примере их 9...

Берем первое число и вырезаем последние 8 бит - тут понятно?

Остается 5 бит (у Вас 13 же 13 бит?) на 8-13 позиции. Их надо перегнать на 0-4 позиции. Для этого есть оператор >>. Далее - у второго числа отрезаем 3 последних бита и смещаем их на 5-7 позиции оператором <<5. Складываем, вырезаем 8 бит. И вот второй байт готов.

uint16_t digit[4];
byte resultat[8];


resultat[0]=(byte) digit[0]&B11111111;
uint16_t temp=digit[0]>>8;
resultat[1]=(byte)((temp+(digit[1]&B111)<<5)&B11111111);

Тут подумалось - можно малость попроще.

Берем переменную uint64 chislo=0;

Далее chislo+=digit[0]; Смещаем на 13 бит chislo<<13; Добавляем следующее chislo+=digit[1]; Опять смещаем на 13 бит chislo<<13; и т.д.

В итоге получаем 64 битное число, которое потом режем по 8 бит.

Кидану кусочек программы 

uint64_t chislo=0;
uint8_t resultat[7];
for (byte i=0; i<4; i++){
chislo<<13;
chislo+=digit[i];
}
for (i=0;i<7;i++){
resultat[i]=(byte)chislo&B11111111
chislo>>8;
}

Пока что я понял это

chislo<<13; //не работает, нет сдвига

chislo = chislo<<13; //так работает

написано тут

В общем пришлось нанрисовать другой эмуль и приделать эмулятор терминала.

В какомто посту идею понял, но у вас там ошибок море, в этом направлении попробую сам

chislo<<13; //не работает, нет сдвига

chislo = chislo<<13; //так работает

А может Вам еще водочки поднести? Мы это завсегда! А что читаете - это очень полезно.

А насчет моря ошибок - можно поподробнее? Или так - в лужу п-нули?

uint64_t chislo=0;
uint8_t resultat[7];
for (byte i=0; i<4; i++){
chislo<<13;
chislo+=digit[i];
}
for (i=0;i<7;i++){
resultat[i]=(byte)chislo&B11111111
chislo>>8;
}

Ну, на вскидку:

строка 8 забыли точку с запятой

Строки 4 и 9 синтаксически правильны, но бессмысленны, тк ничего не делают.

Дальше не смотрел. 

Как нарубить флоат на байты? union

Вы чего думали - я его проверял??? 8-ю строку Вам компилятор указал. 4 и 9 - прочитали, молодец. Так и вставьте как поняли. А дальше ничего и нет- конец цикла. Вы кое-что поняли, теперь попытайтесь назад из resultat[] получить 4 13 битных числа. И поверьте,никто программы за Вас писать не будет. Максимум алгоритм подскажут.

Чукча не читалель, чукча писатель? Если читать внимательнее будет, то увидете, что лично мне ничего не надо. Вы захерачили код с ошибками, на замечание, что там ошибки сами же поросили

А теперь пургу несете.  Слив засчитан.

Вот так (упрощенно, можно в цикле):

float chislo=1.25;		//переменная float
byte *ptr;				//указатель
byte chislo_na_byte[4];	//здесь будет float chislo разбитым на байты
void setup()
{
ptr=(byte*)&chislo;	//нацеливаем указатель на адрес chislo
					//указатель явно на 1 байт, иначе
					//компилятор заматюкает
}
void loop()
{
chislo_na_byte[0]=*ptr++;	//младший байт
chislo_na_byte[1]=*ptr++;
chislo_na_byte[2]=*ptr++;
chislo_na_byte[3]=*ptr++;	//старший байт
}

Тоже самое с любыми типами переменных (на которые можно нацелить указатель), а также на масивы из этих типов. Естесственно подумав как лучьше.

uint64_t chislo=0;
uint8_t resultat[7];
for (byte i=0; i<4; i++){
chislo<<13;
chislo+=digit[i];
}
for (i=0;i<7;i++){
resultat[i]=(byte)chislo&B11111111
chislo>>8;
}

Модифицирую немного (можно?):

uint64_t chislo=0;
byte *ptr;
uint8_t resultat[7];
ptr=(byte*)chislo;
for (byte i=0; i<7; i++){
resultat[i]=*ptr++;
}

Не забываем что байти будут складываться в массив от младшего к старшему.

Наложите на свой uint64 union с bytes[8] безо всяких циклов.

Еслиб я видел что на выводе, но Serial.println не может выводить uint64_t, какойто костыль есть, но там тоже только последние 32 бита.

;)))) Ложить - неправильно, правильно класть! (с) "День выборов"

Даже если и "наложить"(в штаны) используя union, один фиг его нужно передавать как-то.

Цикл нужен для друго, например передачи через UART:

uint64_t chislo=0;
byte *ptr;

ptr=(byte*)chislo;
for (byte i=0; i<7; i++){
uart.send(*ptr++);
}

Это всего лишь пример. 

Ну, если Вам нужно что-то "например", то я тоже могу привести:

 uint64_t chislo=0xDEADBEEFFEED;
 Serial.write((uint8_t*) &chislo, sizeof(chislo));

Пока сделал так. 

Знаки

  8190, //0     1111111111110
  1984, //1     0011111000000
  8061, //2     1111101110101
  8177, //3     1111111110001
  6087, //4     1011111000111
  7671, //5     1110111110111
  7679, //6     1110111111111
  8128, //7     1111111000000
  8191, //8     1111111111111
  8183  //9     1111111110111

После того как определяется x

uint64_t chislo=0;

        chislo+=digit[x4]; // левый знак
        chislo = chislo<<13;

        chislo+=digit[x3];
        chislo = chislo<<13;

        chislo+=digit[x2]; 
        chislo = chislo<<13; 

        chislo+=digit[x1]; // правый знак
        chislo = chislo<<4; // 4 неиспользуемых порта

Сама запись в регистры

for (int i=0; i < 7; i++){
      shiftOut(dataPin, clockPin, LSBFIRST, lowByte(chislo));
      chislo = chislo>>8;
   }

Из за того что вывод 8 битный и создавать переменную для хранения старшего бита не хотелось, поменял их местами из 4321 8765 в более приемлемый 1234 5678, а именно заменил MSBFIRST на LSBFIRST.

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

Не уверен нужен ли мне вообще цикл for, или быстрее будет работать построчно, или компилятору пофиг, не думаю. В общем написал для примера.

Как тут и говорят, альтернативный вариант это побитно выводить сразу 13 бит побитно без переменной uint.

Ну а последовательность бит не красиво только 4 младшими битами которые надо дописывать, в конце последнего регистра они бы не мешали.

mykaida идею подал, но видимо я не програмист чтоб понять что там конкретно. По сравнению с autoit, функционал ардуины очень скромный.

---

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

Выкинул этот uint64 и получилось чтото такое

  for ( int n = 0; n < 13; n++)  {
    digitalWrite(dataPin, !!(digit[x1] & (1 << n)));
    digitalWrite(clockPin, HIGH);
    digitalWrite(clockPin, LOW);    
  }
     
  for ( int n = 0; n < 13; n++)  {
    digitalWrite(dataPin, !!(digit[x2] & (1 << n)));
    digitalWrite(clockPin, HIGH);
    digitalWrite(clockPin, LOW);    
  }

  for ( int n = 0; n < 13; n++)  {
    digitalWrite(dataPin, !!(digit[x3] & (1 << n)));
    digitalWrite(clockPin, HIGH);
    digitalWrite(clockPin, LOW);    
  }

  for ( int n = 0; n < 13; n++)  {
    digitalWrite(dataPin, !!(digit[x4] & (1 << n)));
    digitalWrite(clockPin, HIGH);
    digitalWrite(clockPin, LOW);    
  }

Вообще не понимаю как имея переменную  i вызвать  digit[x4] где цифра будет переменной

x[3] = pot/1000;
x[2] = (pot/100)%10;
x[1] = (pot/10)%10;
x[0] = pot%10; 

for (uint8_t = 0; i < 4; i++) {

  Serial.println(x[i]);

}

В общем получилось такое

    digitalWrite(latchPin, LOW);
for (int i=0; i < 4; i++){
  for ( int n = 0; n < 13; n++)  {
    digitalWrite(dataPin, !!(digit[x[i]] & (1 << n)));
      digitalWrite(clockPin, HIGH);
      digitalWrite(clockPin, LOW);
  }
}
    digitalWrite(latchPin, HIGH);

Теперь вот думаю пустить это в другую сторону и переделать ноги портов, а то чтото неудобно выходит.

---

Как оказалось достаточно физически расположить разряды в обратном порядке, пока 2 регистра легли хорошо. К коде поменять только порядок x[0]-x[3]