Arduino.ru

Так и должно быть.

Потому что ! - логическая операция, на выходе её true или false которые соответствуют 1 или 0. Но эффект забавный.

Да, и сдвиг здесь вобще никаким боком.

Наверно потому что bool 0  может быть только 0, а все что не 0 это уже 1 .

1 - это 1 // 2 это 1 // 32 это 1 // и так далее

ТС тут написал, что вопросов нет.

Я думаю, что нет вопросов исключительно потому, что он ничего не понял.

Невозможно понгять 3-ю строчку его сообщения и не понять 7-ю, т.к. 7-я получается из 3-й упрощением.

Идея - не скажу, что совершенно стандартная, но достаточно очевидная - двойное отрицание нужно, чтобы перевести единицу в любом разряде в единицу в нулевом разряде. По уму двигать нужно было число, а не маску, что все нормальные люди и делают, но автор 3-й строки (очевидно, не ТС) решил сделать по-другому. Такое нестандартное решение повлекло за собой другое нестандартное - какой операцией можно превратить любое ненулевое число в 1? Очевидно, двойным отрицанием.

2qwone: в Си нет булевого типа данных, обозначение bool нужно исключительно для программиста, чтобы ему легче было разобраться в коде. А так - это обычное целое  со всеми вытекающими отсюда последствиями.

Не буду цитировать каждого, т.к. все мне помогли разобраться. Спасибо вам.

Для управления CD74HC4067 на его "адресные" входа нужно поочередно подавать следующие состояния (от 0 до 15)

int readMux(int channel){
  int controlPin[] = {S0, S1, S2, S3};

  int muxChannel[16][4]={
    {0,0,0,0}, //channel 0
    {1,0,0,0}, //channel 1
    {0,1,0,0}, //channel 2
    {1,1,0,0}, //channel 3
    {0,0,1,0}, //channel 4
    {1,0,1,0}, //channel 5
    {0,1,1,0}, //channel 6
    {1,1,1,0}, //channel 7
    {0,0,0,1}, //channel 8
    {1,0,0,1}, //channel 9
    {0,1,0,1}, //channel 10
    {1,1,0,1}, //channel 11
    {0,0,1,1}, //channel 12
    {1,0,1,1}, //channel 13
    {0,1,1,1}, //channel 14
    {1,1,1,1}  //channel 15
  };

  //loop through the 4 sig
  for(int i = 0; i < 4; i ++){
    digitalWrite(controlPin[i], muxChannel[channel][i]);
  }

Используя регистры:

  DDRD |= (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7); //Выходы
  PORTD &= ~ ((1 << 4) | (1 << 5) | (1 << 6) | (1 << 7)); //LOW

  switch (var) {
    case 0:
      PORTD &= ~ ((1 << 4) | (1 << 5) | (1 << 6) | (1 << 7));//0000
      break;
    case 1:
      PORTD |= (1 << 4);
      PORTD &= ~ ( (1 << 5) | (1 << 6) | (1 << 7));
      break;
    case 1:
      PORTD |= (1 << 5);
      PORTD &= ~ ( (1 << 4) | (1 << 6) | (1 << 7));
      break;
  }

Чую с регистрами есть вариант проще...(не трогая другие биты порта)

Подскажите)

Попроще это вот так примерно:

int readMux(int channel){
  uint8_t controlPin[] = {S0, S1, S2, S3};

  //loop through the 4 sig
  for(uint8_t i = 0; i < 0x0F; i++) {
    for (uint8_t p = 0; p < sizeof(controlPin); p++) {
      uint8_t controlPinState = bitRead(i, p); 
      digitalWrite(controlPin[p], controlPinState);
    }
    ...
  }
...
}

А с регистрами - это никогда не "попроще".

<= 0x0f, bool controlPinState много букв)

/*byte port[16] = {
  0b00000000,//0000
  0b10000000,//1000
  0b01000000,//0100
  0b11000000,//1100
  0b00100000,//0010
  0b10100000,//1010
  0b01100000,//0110
  0b11100000,//1110
  0b00010000,//0001
  0b10010000,//1001
  0b01010000,//0101
  0b11010000,//1101
  0b00110000,//0011
  0b10110000,//1011
  0b01110000,//0111
  0b11110000,//1111
  };*/

byte port[16] = {0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0};

void setup() {
  DDRD |= (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7); //Выходы
  PORTD &= ~ ((1 << 4) | (1 << 5) | (1 << 6) | (1 << 7)); //LOW
}


byte readMux(byte channel) {
  for (byte b = 4; b < 8; b++) {
    byte bitread = port[channel] & (1 << b);
    if (bitread) {
      PORTD |= (1 << b);
    } else {
      PORTD &= ~ (1 << b);
    }
  }
}

Вот такой вариант

А если использовать битовые маски

byte BitsMask = port[2] & 0b11110000;
PORTD=BitsMask;

Взяла 4 5 6 7  биты из байта и записала их в порт

Но при этом будут меняться и 0 1 2 3 биты

Неужто нужна скорость?

byte BitsMask = port[2] & 0b11110000;
PORTD=BitsMask;

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

А избежать изменения можно:

int8_t writeToPort(const uint8_t _portNo, const uint8_t _value, const uint8_t _port_protect_mask) {
  volatile uint8_t *portRegister = portOutputRegister(_portNo);
...
  // Port write transaction
  // Use protection mask when write to port for saving some pins state
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { *portRegister = (*portRegister & _port_protect_mask) | (_value & ~_port_protect_mask); }
...
}

port_protect_mask задается так: B11110000 - если в маске 1, то бит порта не изменяется, если 0 - перезаписывается новым значением.

Мы говорим не "входы". а "входа" -

Слова входят коротки и смачны.

"ПинЫ" - не "пИны" - сводят нас с ума,

Из флэша выкорчёвывая байты.

Почти Высоцкий! ;)))

Я понимаю, что здесь полно грубых мужиков, да еще и без "вышки", да еще из прованса... но тут я никак не ожидал варианта "входа"! Куда мир катиццо? ;))

Осталось измерить напряжение "на пину", и "прошить скейч".

<= - верно.

А много букв - для понятности. Компилятору-то пофиг, он читать не умеет. Можно было, конечно, прямо в digitalWrite битшифт заговнокодить ))

Irinka, не страдали бы вы ерундой. Вся эта мнимая скорость никому не нужна. Постоянно вижу как "гонщики" скоростят до светофора.)

byte BitsMask = port[2] & 0b11110000;
PORTD=BitsMask;

идея правильная, чуть-чуть подправить осталось:

PORTD &= ~  0b11110000;   // сначала обнуляем все биты с 4 по 7
PORTD |= port[2];          // а потом выставляем только те, что 1

Итог - биты с 4 по 7 поменяны в соответсвии со значением port[2], остальные биты порта не затронуты.

Ужос! Вот только зачем, спросит удивлённый читатель?

PORTD = (PORTD & B00001111) | ВАШИ БИТЫ ОТ 0 ДО 15<<4;

PORTD &= ~  0b11110000;   // сначала обнуляем все биты с 4 по 7
PORTD |= port[2];          // а потом выставляем только те, что 1

Так не пойдёт, каждый проход будет сбрасывать 4 адресных входа в ноль.

запишите эти две строки в одну, как Green выше показал

PORTD = (PORTD & B00001111) | ВАШИ БИТЫ ОТ 0 ДО 15<<4;

Как эту запись понимать?

PORTD = (PORTD & B00001111) | ВАШИ БИТЫ ОТ 0 ДО 15<<4;

это тоже самое, как

PORTD &= ~  0b11110000;   // сначала обнуляем все биты с 4 по 7
PORTD |= port[2];          // а потом выставляем только те, что 1

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

port[0]=0b11000000;

PORTD = (PORTD & B00001111) | port[0];

В итоге сначала биты с 4 по 7 будут 0, потом будут 1 1 0 0

Так?

port[0]=0b11000000;

PORTD = (PORTD & B00001111) | port[0];

все это считается в одно действие, поэтому никакие "сначала" и "потом" на содержимом PORTD не скажутся, результат будет аналогичен единомоментной установке старших четырех бит в значения 1 1 0 0

Классно! Не то что digitalWrite...Код стал красивее, короче!

PORTD & B00001111 это тоже, что и PORTD = B00001111? Но при этом в 0 1 2 3 биты ничего не записывается.

далее | port[0] записываются в порт только 1, 0 не пишутся, т.е.  если port[0]=0b10000011

то два младших бита так же запишутся в порт?

Нет, ну это, конечно, годится для тренировки, но. Ардуино - это более высокая абстракция, нежели PORTD и DDRD.
И это удобно. Это специально сделано для вас, блондинок. А тогда заради чего вам спускаться вниз, в эту клоаку?

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

Спасибо

а что с брюнетками?

Все куда прозаичнее

PORTD=(PIND)&(0xF0|port[0]);

Ты сейчас прям меня описал

у нее в массиве port[] уже подготовленные данные, сдвинутые в старшие биты:

/*byte port[16] = {
  0b00000000,//0000
  0b10000000,//1000
  0b01000000,//0100
  0b11000000,//1100
  0b00100000,//0010
  0b10100000,//1010
  0b01100000,//0110
  0b11100000,//1110
  0b00010000,//0001
  0b10010000,//1001
  0b01010000,//0101
  0b11010000,//1101
  0b00110000,//0011
  0b10110000,//1011
  0b01110000,//0111
  0b11110000,//1111
  };*/

поэтому двигать port[0] уже не нужно

Нет, ну тогда, это уж как ей соизволится.)

Вообще, конечно, не красиво говорить о человеке в третьем лице, но думаю, вы понимаете. У нас тут всё по простому.)

Всё поняла, спасибо)