Доброго всем времени суток. Возникла следующая проблема: есть прога,считающая контрольную сумму по алгоритму CRC16/CITT. Хотелось бы проверить,совпадает ли результат её работы с расчетами этой суммы..как-нибудь по-другому,например,ручками,на бумажке карандашиком   
Вот.Просто что-то я никак не соображу,как задать какие-либо данные,чтобы знать их двоичный код и потом проверить,т.е. поделить ручками на бумажке.
Заранее спасибо,
PS работаю в билдере версии 6.
код:
Файл CRC.cpp


файл CRC.h

Демидрол, j, обычно контрольную сумму для определенного буфера дает производитель дивайса. 
а так - ну дык у тебя же алгоритм написан - вот и действуй.

я понимаю логику как считать.И на небольших примерах могу смастерить.Только не знаю,как задать какую-нить штуку в datablock, чтобы знать,какой двоичный код ей соответствует,т.е. посчитать что-либо могу,только хочу знать что считать, т.е. какой двоичный код по алгоритму гонять.  

т.е. хочется получить совет,как мне узнать двоичный код комбинации,находящейся в            char *datablock,только и всего..наверное    

Это сообщение отредактировал(а) Демидрол - 23.9.2008, 13:28

Уважаемые Знатоки,внимание,ВОПРОС:
сидел тут и разбирался с алгоритмом CRC вообще,информацию искал и накнылся в сети на информацию,что в строке  

вместо 0x8000 используется 0xA001. Верно ли это?

И еще хотелось бы спросить,потому как мыслей умных не хватает и мозга:

1) если рассчитывать данную вещь,то во многих источниках пишется,что сообщение дополняется количеством нулей,причем это количество равно степени полинома,в данном случае,16. Верно ли это?

2) степень кода выражения CRC будет равна степени полинома, используемого в алгоритме, в данном случае - 15? Я сделал тестовый пример,получил выражение, степень которого равна 14.Это ошибка или нет? В качестве теста писпользовал строку "123456789", которой соответствует комбинация 29В1. Получил 5349h. Может,я где-то напортачил? Или все правильно, просто для того,чтобы код дописать в сообщение нужно в его голову дописать несколько нулей,чтобы получилось выражение 16-й степени?

3) в данном случае речь идет о полиноме 0х1021, но это полином х12 + х5 + 1, а в теории-то должен быть полином 0х11021, который и соответствует теоритическому х16 + х12 + х5 + 1. Что с этим делать и как поступить?

Вот, почитал руками. Результат явно не совпадает с тем,что получилось в программе   
10100110110001000000000000000
10001000000100001
00101110110101001000000000000
    101110110101001000000000000
    10001000000100001
    001100110100001010000000000
        1100110100001010000000000
        10001000000100001
        0100010100011010100000000
          100010100011010100000000
          10001000000100001
          000000100010010110000000
                      100010010110000000
                      10001000000100001
                      000000010111000010
                                    10111000010

а по программе должно получиться 101001101001001   


Это сообщение отредактировал(а) Демидрол - 23.9.2008, 15:39

Двусмысленно      
Для этих целей есть чтандартные утилиты. Созданые именно для этих целей. Гугл в руки.

отлично.жаль,что я так уже и поступил,качнул утилиту для расчета СКС-16.
считает,она правда,в HEX-формате и надо ей задать исходные данные имнно в этом формате.
Проблема остается неизменной:как узнать,какой код в 16-й системе или двоичной,не важно,соответствует выражению, имеющему тип char*   

нашел я то,что искал,а именно какой код соответствуетт комбинациям в datablock.
Оказалось,считает прога неправильно.   
Может,кто сталкивался с темой расчета CRC подскажет,как правильно рассчитывать сию вещь, потому как в сети нашел много примеров,в которых используется код,отличающийся от моего лишь названиями...Помогите,пожалуйста,а то   

Нет


Нет

Нет. Она будет не больше 16 (степень полинома - 16, а не 15)

Строке "123456789" соответствует CRC 29B1

Откуда   

Без сомнения

Не надо, у тебя исходная строка "123456789" уже 72 бита, куда уж больше   

CRC16 подразумевает полином 16й степени, при этом x16 соотвествует 0x10000, что лежит за границей типа short (16 бит) и обрабатывается отдельно и явно условием crc&0x8000

Что то у тебя короткий входной вектор, явно не 72 бита   
Вот твой вектор:
hex: 31 32 33 34 35 36 37 38 39
bin: 00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000 00111001
считай   

хм,а тогда возник вопрос: если строка будет состоять например, только из одной цифры один, "1", ей соответствует 00110001, а как тогда получиться код 16-й степени?
Или операция xOr будет произведена только над старшими восемью битами полинома, а остальные допишутся как были в полиноме? Непонятно......  

Кстати,посчитал для строки "123456789",получил :
001100010011001000110011001101000011010100110110001101110011100000111001
10001000000100001
101110010010001010110011001101000011010100110110001101110011100000111001
    1110010010001010110011001101000011010100110110001101110011100000111001
    10001000000100001
    0110110010011010010011001101000011010100110110001101110011100000111001
      110110010011010010011001101000011010100110110001101110011100000111001
      10001000000100001
      010100010010010000011001101000011010100110110001101110011100000111001
        10100010010010000011001101000011010100110110001101110011100000111001
        10001000000100001
        00101010010110001011001101000011010100110110001101110011100000111001
            101010010110001011001101000011010100110110001101110011100000111001
            10001000000100001
            001000010111001001001101000011010100110110001101110011100000111001
                1000010111001001001101000011010100110110001101110011100000111001
                10001000000100001
                0000110111011001101101000011010100110110001101110011100000111001
                        110111011001101101000011010100110110001101110011100000111001
                        10001000000100001
                        010101011000101111000011010100110110001101110011100000111001
                          10101011000101111000011010100110110001101110011100000111001
                          10001000000100001
                          00100011000001110000011010100110110001101110011100000111001
                              100011000001110000011010100110110001101110011100000111001
                              10001000000100001
                              000001000000110010011010100110110001101110011100000111001
                                        1000000110010011010100110110001101110011100000111001
                                        10001000000100001
                                        0000100110000011110100110110001101110011100000111001
                                                100110000011110100110110001101110011100000111001
                                                10001000000100001
                                                000100000010110110110110001101110011100000111001
                                                      100000010110110110110001101110011100000111001
                                                      10001000000100001
                                                      000010010111110100110001101110011100000111001
                                                              10010111110100110001101110011100000111001
                                                              10001000000100001
                                                              00011111110000111001101110011100000111001
                                                                    11111110000111001101110011100000111001
                                                                    10001000000100001
                                                                    01110110000011000101110011100000111001
                                                                      1110110000011000101110011100000111001
                                                                      10001000000100001
                                                                      0110010000001000001110011100000111001
                                                                        110010000001000001110011100000111001
                                                                        10001000000100001
                                                                        010000000000000011110011100000111001
                                                                          10000000000000011110011100000111001
                                                                          10001000000100001
                                                                          00001000000100010110011100000111001
                                                                                  1000000100010110011100000111001
                                                                                  10001000000100001
                                                                                  0000100100000110111100000111001
                                                                                          100100000110111100000111001
                                                                                          10001000000100001
                                                                                          000110000111111110000111001
                                                                                                110000111111110000111001
                                                                                                10001000000100001
                                                                                                010010111110110010111001
                                                                                                  10010111110110010111001
                                                                                                  10001000000100001
                                                                                                  00011111110010011111001
                                                                                                        11111110010011111001
                                                                                                        10001000000100001
                                                                                                        01110110010111110001
                                                                                                          1110110010111110001
                                                                                                          10001000000100001
                                                                                                          0110010010101110101
                                                                                                            110010010101110101
                                                                                                            10001000000100001
                                                                                                            010000010100110111
                                                                                                              10000010100110111
                                                                                                              10001000000100001
                                                                                                              00001010100010110
                                                                                                                     1010100010110

что-то это ни разу не 29В1....  

Это сообщение отредактировал(а) Демидрол - 26.9.2008, 15:58

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

По идее надо дописать слева нули.

Увы, проверить у меня терпения не хватит   Советую сначала разобраться каким битам переменной crc соотвествуют какие степени полинома, и как представляется входной полином (какими битами вперед). 
Я как то этими вопросами никогда не интересовался   

ммм.....пардон за такой глупый вопрос,но не сталкивался ещё с этим:
как дописать в DataBlock в конец полученный код? Это нужно в файле проверки....По идее,если вычеслить CRC для модифицированного DataBlock, то долже получиться 0.
Допустим, char* DataBlock = "1".
Вызываю функцию для рассчета CRC, получаю int res. Как мне записать res в конец DataBlock?