Версия для печати темы Нажмите сюда для просмотра этой темы в оригинальном формате

Форум программистов > C/C++: Для новичков > проверка на чётность последовательности битов

Автор: supercelt 12.8.2015, 11:32

Помогите пожалуйста разобраться как правильно. А то на вики пишут так, в другом месте сяк Есть последовательность из 5 битов. Первые 4 - это данные, 5й - бит чётности. 1101 - данные Вариант проверки 1 В этом коде 3 единицы, а 3 - нечётное число, значит бит чётности будет 1 Вариант 2 делается логическая И с маской 0001 1101 & 0001 = 0001 Получаем 1 - нечётное. Ну и правильно, 1101 это 13. А 13 нечётное А теперь 1111 - данные при первом варианте будет 0, так как там 4 единицы, а 4 - чётное во втором варианте будет 1 - нечётное, 1111 это 15 - нечётное число Так вот как правильно?

Автор: volatile 12.8.2015, 11:41

supercelt, это две разные вещи, четность числа, и четность данных Четность числа определяется его младшим битом. Четность данных это четность количества единиц в битовом представлении числа. Его еще называют паритет. И естественно четное число может быть с нечетным паритетом, и наоборот. Добавлено через 2 минуты и 30 секунд Цитата(supercelt @  12.8.2015,  11:32 ) Есть последовательность из 5 битов. Первые 4 - это данные, 5й - бит чётности в данном случае имеется в виду именно паритет.

Автор: supercelt 12.8.2015, 11:46

спс

Автор: TarasProger 12.8.2015, 14:25

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

Автор: feodorv 12.8.2015, 16:38

Цитата(TarasProger @  12.8.2015,  14:25 ) количества единичных бит во всей пятёрке Наверное, имелось в виду "четвёрке"?

Автор: TarasProger 12.8.2015, 18:53

Цитата(feodorv @  12.8.2015,  16:38 ) Наверное, имелось в виду "четвёрке"? Пятёрке: 4 бита данных он не трогает, количество единичных бит в ней может быть любым, в том числе и нечётным, но в этом случае бит партитета тоже единичный и он то один, в сумме с битами данных количество единичных бит чётно, если же количество единичных бит данных уже чётно, то паритетный бит нулевой, в сумме опять таки количество единичных бит чётно. Добавлено @ 19:01 Например, единичные биты - одиночные импульсы чередующихся разрядностей, а ноли - отсутствие импульсов, + пилотон на весь пакет. Если количество единичных бит не чётно, то имеем не нулевую составляющую нулевой частоты, которая плохо идёт по кабелю, а если оно чётно, то всякие отличия среднего от ноля случайны, бит паритета даёт гарантию номинального ноля в компоненте нулевой частоты, а дрейф ноля можно не передавать, не страшно. Равное количество нолей и единц одним дополнительным битом не обеспечишь, для этого нужна 100% избыточность, да и договориться о том, какая полярость будет единицей, а какая нолём можно в одном устройтсве, но не в распределённой сети. А чётность количества единиц с меньшими затратами. Добавлено через 9 минут и 50 секунд Не надо рассказывать про самосинхронизацию каждого бита, это был просто максимально упрощённый пример.

Автор: supercelt 12.8.2015, 19:06

Да имелось ввиду в 4. пятый - бит чётности. Может тогда подскажете как работает эта функция. Описано что она проверяет 4 бита на чётность. Но я не понимаю смысл этой функции или... алгоритм Код unsigned char CheckCRC(unsigned char *buffer) {         unsigned char i;         crc = 0;         for (i=0; i<5; i++){                 crc = crc ^ ( buffer[i] & 0x0F ) ^ ( ( buffer[i] >> 4 ) & 0x0F );             }         if (crc != ( buffer[5] & 0x0F )) { return 0; } else { return 1; }  }

Автор: feodorv 12.8.2015, 19:54

Ну, тут явно идёт речь о байтах, не о битах. А как Вы в коде задаёте последовательность этих 4 или 5 бит? Добавлено через 36 секунд Цитата(TarasProger @  12.8.2015,  18:53 ) Пятёрке Да, прошу прощения.

Автор: feodorv 12.8.2015, 20:43

Вычислить паритет 4-х младших бит целочисленной переменной можно по-разному. Например так: Код unsigned int getParity( unsigned int fourBits ) {   unsigned int count = 0;   if( fourBits & 0x01u ) count++;   if( fourBits & 0x02u ) count++;   if( fourBits & 0x04u ) count++;   if( fourBits & 0x08u ) count++;   return count & 0x01u; } Или менее прямолинейно через цикл. Можно с использованием таблицы: Код const unsigned int parityTable[16] = {   0, /* 0000 */   1, /* 0001 */   1, /* 0010 */   0, /* 0011 */   1, /* 0100 */   0, /* 0101 */   0, /* 0110 */   1, /* 0111 */   1, /* 1000 */   0, /* 1001 */   0, /* 1010 */   1, /* 1011 */   0, /* 1100 */   1, /* 1101 */   1, /* 1110 */   0  /* 1111 */ }; unsigned int getParity( unsigned int fourBits ) {   return parityTable[ fourBits & 0x0fu ]; } Объединяя биты паритета в таблице parityTable в одно число, получаем такую функцию: Код unsigned int getParity( unsigned int fourBits ) {   fourBits &= 0x0fu; // на всякий случай   return (0x6996u >> fourBits) & 0x01u; } Что и предлагается в сборнике битовых трюков http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel.

Автор: TarasProger 13.8.2015, 06:15

Цитата(feodorv @  12.8.2015,  19:54 ) Ну, тут явно идёт речь о байтах, не о битах. А как Вы в коде задаёте последовательность этих 4 или 5 бит?  Байты существуют в памяти конкретного компьютера, а не в линиях связи. Передаются именно биты, даже если их количество картно 8. Но паритет на уровне байта - это как минимум 9, значит и кратность будет такой же.

Автор: TarasProger 13.8.2015, 06:49

Цитата(supercelt @  12.8.2015,  19:06 ) unsigned char CheckCRC(unsigned char *buffer) {         unsigned char i;         crc = 0;         for (i=0; i<5; i++){                 crc = crc ^ ( buffer[i] & 0x0F ) ^ ( ( buffer[i] >> 4 ) & 0x0F );             }         if (crc != ( buffer[5] & 0x0F )) { return 0; } else { return 1; }  } По-хорошему так:  Код struct BoolPack {  bool Hi0 :1;  bool Low0:1;  bool Hi1 :1;  bool Low1:1;  bool Hi2 :1;  bool Low2:1;  bool Hi3 :1;  bool Low3:1; }; void Checked(unsigned *Data, BoolPack *Paritets, size_t Count) {  unsigned char i;  unsigned char j;  unsigned char Buffer;  for (i=0; Count>0; --Count, ++Data, ++i, i^=0x03)  {   switch (i)   {    case 0: for (j=4, Buffer=*Data, Paritets->Low0=false; j>0; --j, Buffer>>=1)            {             Paritets->Low0^=Buffer&0x01;            }            for (j=4, Paritets->Hi0=false; j>0; --j, Buffer>>=1)            {             Paritets->Hi0^=Buffer&0x01;            }    break;    case 1: for (j=4, Buffer=*Data, Paritets->Low1=false; j>0; --j, Buffer>>=1)            {             Paritets->Low1^=Buffer&0x01;            }            for (j=4, Paritets->Hi1=false; j>0; --j, Buffer>>=1)            {             Paritets->Hi1^=Buffer&0x01;            }    break;    case 2: for (j=4, Buffer=*Data, Paritets->Low2=false; j>0; --j, Buffer>>=1)            {             Paritets->Low2^=Buffer&0x01;            }            for (j=4, Paritets->Hi2=false; j>0; --j, Buffer>>=1)            {             Paritets->Hi2^=Buffer&0x01;            }    break;    case 3: for (j=4, Buffer=*Data, Paritets->Low3=false; j>0; --j, Buffer>>=1)            {             Paritets->Low3^=Buffer&0x01;            }            for (j=4, Paritets->Hi4=false; j>0; --j, Buffer>>=1)            {             Paritets->Hi4^=Buffer&0x01;            }            ++Paritets;    break;   } } . Байты группируются по 4, каждой четвёрке соответствует свой байт паритетов. Поле Hi0 - партитет старшего полубайта пнулевого байта четвёрки, поле Low0 - партитет младшего полубайта нулевого байта четвёрки, поле Hi1 - партитет старшего полубайта первого байта четвёрки, поле Low1 - партитет младшего полубайта первого байта четвёрки, поле Hi2 - партитет старшего полубайта второго байта четвёрки, поле Low2 - партитет младшего полубайта второго байта четвёрки, поле Hi3 - партитет старшего полубайта последнего третьего байта четвёрки, поле Low3 - партитет младшего полубайта третьего байта четвёрки.

Автор: TarasProger 13.8.2015, 07:31

Можно ещё сложить значения паритетов в массив, индексируемый значеними байтов.  Код struct BoolPack {  bool Low3:1;  bool Hi3 :1;  bool Low2:1;  bool Hi2 :1;  bool Low1:1;  bool Hi1 :1;  bool Low0:1;  bool Hi0 :1; }; void Checked(unsigned *Data, BoolPack *Paritets, size_t Count) {  unsigned char i;  unsigned char Masks        [4]     = {0x3F, 0xCF, 0xF3, 0xFC};  unsigned char ParitetsMasks[4][256]={{0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0, 0x80, 0xC0},                                       {0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30, 0x20, 0x30},                                       {0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C, 0x08, 0x0C},                                       {0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03}};  for (; Count>0; ++Paritets)  {   for (i=0; (i<4)&&(Count>0); ++i, ++Data)   {    *Paritets&=Masks[i];    *Paritets|=ParitetsMasks[i][*Data];   } } . Здесь учтено, в каком именно порядке битовые поля отображены на биты, что обязательно при использовании масок и битовых операций в иных целях кроме подсчёта в цикле битов с определёнными значениями и вычислений по модулю степени двойки. Добавлено через 41 секунду Первый вариант конкетное отображение битовых полей на биты не учитывает.

Автор: TarasProger 13.8.2015, 07:58

Аппаратура последовательного порта, сетевой карты с разъёмом BNC, или сетевой карты под витой кабель, исспользующей на передачу ровно одну пару жил кабеля,  вполне справляется с передачей единичного бита, а кратность посылок восьми реализуется управлением этой аппаратурой, возможно даже программно или микропрограммно. При наличии битов чётнлости, паритета, или любых других дополниельных бит кратность оказывается другой. Но в принципе можно обеспечить такую кратность количества байт, чтоб снова получить кратность количества бит восьми, чтоб сформировать всю последовательность как есть в памяти. Например, пусть посылаются восьмибитные байты с паритетом на уровне полубайта. Тогда кратность 10. Но 5 байт равны как раз 40-ка байтам, что вполне кратно и восьми, и десяти. Тогда количество байт данных кратно 4-м, а 5-й байт содержит паритеты для всей четвёрки, но его биты можно перемешать с битами данных, разместив по одному после каждых четырёх бит данных. Если есть и чётность числа на уровне байта, и паритет на уровне полубайта, то получаем кратность 11, количество байт должно быть кратно 11, тогда количество бит будет кратно и 8-ми, и 11-ти: на каждые 8 байт данных приходится 3 байта дополнительной информации, перемешиваемых с данными так: 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность), 4 бита данных, 1 доплнительный (паритет старшего полубайта), 4 бита данных, 2 дополниельных (паритет младшего полубайта и чётность). При паритете на уровне полубайта и чётности числа в полубайте получам кратность количества бит 12-ти и кратность количества байт 3-м (3 байта - это 24 бита, кратно и 8-ми, и 12-ти), два дополниельных бита размещаются после каждых четырёх бит данных. Добавлено @ 08:00 Если иметь только паритет на уровне всего байта, то количество байт кратно 9-ти: 8 байт данных + 1 байт с паритетами. Обратите внимание: количество байт данных всё равно кратно степени двойки.

Автор: TarasProger 13.8.2015, 08:27

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

Автор: feodorv 13.8.2015, 10:16

Цитата(TarasProger @  13.8.2015,  06:15 ) Байты существуют в памяти конкретного компьютера, а не в линиях связи. Передаются именно биты, даже если их количество картно 8. Но паритет на уровне байта - это как минимум 9, значит и кратность будет такой же. TarasProger, у ТС есть последовательность 5 бит, при чем здесь байты? При чем здесь линии связи и всё остальное? Зачем всё это написанное? Вы окончательно запутываете тему.

Автор: xvr 13.8.2015, 13:16

Цитата(TarasProger @  13.8.2015,  07:58 ) Аппаратура последовательного порта, сетевой карты с разъёмом BNC, или сетевой карты под витой кабель, исспользующей на передачу ... Вы прослушали монолог 'О жизни битов' в исполнении TarasProger (бурные продолжительные аплодисменты)

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)