很多年前用51的汇编语言写过, 看用不用的上.

;**********************************************
;  subroutine:
;        name:        Convert_Hex2EMcode
;        function:
;                convert hex data to em code
;        input:
;                gvUserBuf
;        output:
;                gvBuffer
;**********************************************
Convert_Hex2EMcode:
                mov        gvBuffer,#0ffh
                mov        r0,#gvBuffer+1
                mov        @r0,#01h
                mov        r1,#gvUserBuf
                mov        a,@r1
                mov        b,a
                mov        bitcount,#07h
                mov        bytecount,#05h
                mov        r4,#04h
ConvertEMcode_Loop1:
                mov        a,b
                rlc        a
                mov        b,a
                mov        a,@r0
                rlc        a
                mov        @r0,a
                djnz        bitcount,ConvertEMcode_Loop11
                mov        bitcount,#08h
                inc        r0
ConvertEMcode_Loop11:
                djnz        r4,ConvertEMcode_Loop1
                mov        a,@r1
                anl        a,#0f0h
                swap        a
                mov        c,PSW.0
                mov        a,@r0
                rlc        a
                mov        @r0,a
                djnz        bitcount,ConvertEMcode_Loop12
                mov        bitcount,#08h
                inc        r0
ConvertEMcode_Loop12:
                mov        r4,#04h
ConvertEMcode_Loop2:
                mov        a,b
                rlc        a
                mov        b,a
                mov        a,@r0
                rlc        a
                mov        @r0,a
                djnz        bitcount,ConvertEMcode_Loop21
                mov        bitcount,#08h
                inc        r0
ConvertEMcode_Loop21:
                djnz        r4,ConvertEMcode_Loop2
                mov        a,@r1
                anl        a,#0fh
                mov        c,PSW.0
                mov        a,@r0
                rlc        a
                mov        @r0,a
                djnz        bitcount,ConvertEMcode_Loop22
                mov        bitcount,#08h
                inc        r0
ConvertEMcode_Loop22:
                inc        r1
                mov        a,@r1
                mov        b,a
                mov        r4,#04h
                djnz        bytecount,ConvertEMcode_Loop1
                mov        a,gvBuffer+7
                swap        a
                rlc        a
                mov        gvBuffer+7,a
ConvertEMcode_Loop3:
                mov        r1,#gvUserBuf
                mov        r3,#00h
                mov        r5,#05h
ConvertEMcode_Loop31:
                mov        a,@r1
                swap        a
                anl        a,#0fh
                xrl        a,r3
                mov        r3,a
                mov        a,@r1
                anl        a,#0fh
                xrl        a,r3
                mov        r3,a
                inc        r1
                djnz        r5,ConvertEMcode_Loop31                ; get colume parity
                clr        c                                ; last bit is zero
                mov        a,r3
                rlc        a
                mov        r3,a                                ; get last parity
                mov        a,@r0
                anl        a,#11100000b
                orl        a,r3
                mov        @r0,a
                ret

1. #include <stdio.h>
   
2. 
   
3. typedef unsigned char uint8_t;
   
4. 
   
5. uint8_t col_check(const uint8_t* buffer)
   
6. {
   
7.         uint8_t check;
   
8.         uint8_t temp;
   
9.         check = *buffer++;
   
10.         check ^= *buffer++;
    
11.         check ^= *buffer++;
    
12.         check ^= *buffer++;
    
13.         check ^= *buffer;
    
14.         check ^= check >> 4;
    
15.         temp = check ^ (check >> 2);
    
16.         temp ^= temp >> 1;
    
17.         return ((check & 0x0f) << 1) | (temp & 0x01);
    
18. }
    
19. 
    
20. void code_create(const uint8_t* buffer, uint8_t* code)
    
21. {
    
22.         uint8_t check_col;
    
23.         uint8_t check_row;
    
24.         uint8_t temp;
    
25.         check_col = col_check(buffer);
    
26.         *code++ = 0xff;
    
27.        
    
28.         temp = *buffer++;
    
29.         check_row = temp ^ (temp >> 2);
    
30.         check_row ^= (check_row >> 1);
    
31.         *code = 0x80; // fill 1
    
32.         *code |= temp >> 1; // fill 4
    
33.         *code &= 0xf8; // all 5
    
34.         *code |= (check_row & 0x10) >> 2; // fill 1
    
35.         *code++ |= (temp >> 2) & 0x03; // fill 2
    
36.        
    
37.         *code = temp << 6; // fill 2
    
38.         *code |= (check_row & 0x01) << 5; // fill 1
    
39.         temp = *buffer++;
    
40.         check_row = temp ^ (temp >> 2);
    
41.         check_row ^= (check_row >> 1);
    
42.         *code |= temp >> 3; // fill 4
    
43.         *code &= 0xfe; // all 7
    
44.         *code++ |= (check_row & 0x10) >> 4; // fill 8
    
45.        
    
46.         *code = temp << 4; // fill 4
    
47.         *code |= (check_row & 0x01) << 3; // fill 1
    
48.         temp = *buffer++;
    
49.         check_row = temp ^ (temp >> 2);
    
50.         check_row ^= (check_row >> 1);
    
51.         *code++ |= temp >> 5; // fill 3
    
52.        
    
53.         *code = temp << 3; // fill 1
    
54.         *code &= 0x80; // all 1
    
55.         *code |= (check_row & 0x10) << 2; // fill 1
    
56.         *code |= (temp & 0x0f) << 2; // fill 4
    
57.         *code &= 0xfc; // all 6
    
58.         *code |= (check_row & 0x01) << 1; // fill 1
    
59.         temp = *buffer++;
    
60.         check_row = temp ^ (temp >> 2);
    
61.         check_row ^= (check_row >> 1);
    
62.         *code++ |= temp >> 7; // fill 1
    
63.        
    
64.         *code = temp << 1; // fill 3
    
65.         *code &= 0xe0; // all 3
    
66.         *code |= check_row & 0x10; // fill 1
    
67.         *code++ |= temp & 0x0f; // fill 4
    
68.        
    
69.         *code = (check_row & 0x01) << 7; // fill 1
    
70.         temp = *buffer++;
    
71.         check_row = temp ^ (temp >> 2);
    
72.         check_row ^= (check_row >> 1);
    
73.         *code |= temp >> 1; // fill 4
    
74.         *code &= 0xf8; // all 5
    
75.         *code |= (check_row & 0x10) >> 2; // fill 1
    
76.         *code++ |= (temp >> 2) & 0x03; // fill 2
    
77.        
    
78.         *code = temp << 6; // fill 2
    
79.         *code |= (check_row & 0x01) << 5; // fill 1
    
80.         *code |= check_col;
    
81. }
    
82. 
    
83. int main(int argc, char *argv[])
    
84. {
    
85.         uint8_t buffer[5] = {0x30, 0x00, 0xf9, 0x49, 0x89};
    
86.         uint8_t res[8];
    
87.         code_create((const uint8_t*)buffer, (uint8_t*)res);
    
88.         printf("0x%02x ", res[0]);
    
89.         printf("0x%02x ", res[1]);
    
90.         printf("0x%02x ", res[2]);
    
91.         printf("0x%02x ", res[3]);
    
92.         printf("0x%02x ", res[4]);
    
93.         printf("0x%02x ", res[5]);
    
94.         printf("0x%02x ", res[6]);
    
95.         printf("0x%02x ", res[7]);
    
96.         return 0;
    
97. }
    

复制代码

Cfree+GCC测试通过！

QQ截图20151001020753.jpg (16.72 KB, 下载次数: 0)

下载附件

2015-10-1 02:05 上传

本帖最后由 LBQ691477940 于 2015-10-1 10:23 编辑

多谢各位，昨晚我也搞掂了，也是有很多行语句呀
void clqo()//行列奇偶位计算 并将五个字节的十六进制转为卡的9个头及奇偶位共64位即 八个字节的十六进制数据
{
        uchar kk;
        for(kk = 0;kk < 5;kk++)//将五个字节的十六进制分开半个字节
        {
                Buf_RF_Data[kk * 2 + 0] = ID_Code[kk] >> 4;
                Buf_RF_Data[kk * 2 + 1] = ID_Code[kk] & 0x0F;       
        }               
        for(kk = 0;kk < 10;kk++)//计算每半个字节的奇偶位
        {
                Buf_RF_Data[kk] &= 0x0F; //先屏蔽高4位
                if(((Buf_RF_Data[kk] >> 3) + (Buf_RF_Data[kk] >> 2) + (Buf_RF_Data[kk] >> 1) + (Buf_RF_Data[kk] & 0x01)) % 2)
                {
                        Buf_RF_Data[kk] <<= 1;
                        Buf_RF_Data[kk] |= 1;
                }
                else //为偶数个 1 则补 0
                {
                        Buf_RF_Data[kk] <<= 1;
                }
        }
        for(kk = 4;kk > 0;kk--)//列奇偶位
        {
                Buf_RF_Data[kk] &= 0x1F; //先屏蔽高3位
                if(((Buf_RF_Data[0] >> kk) + (Buf_RF_Data[1] >> kk) + (Buf_RF_Data[2] >> kk) + (Buf_RF_Data[3] >> kk) + (Buf_RF_Data[4] >> kk)
                + (Buf_RF_Data[5] >> kk) + (Buf_RF_Data[6] >> kk) + (Buf_RF_Data[7] >> kk) + (Buf_RF_Data[8] >> kk) + (Buf_RF_Data[9] >> kk)) % 2)
                {
                        Buf_RF_Data[10] |= 1;
                        Buf_RF_Data[10] <<= 1;
                }
                else //为偶数个 1 则补 0
                {
                        Buf_RF_Data[10] <<= 1;
                }       
        }       
        Buf_RF_Data[0] <<= 2;
        Buf_RF_Data[0] |= 0x80;
        Buf_RF_Data[0] |= Buf_RF_Data[1] >> 3;
       
        Buf_RF_Data[1] <<= 5;
        Buf_RF_Data[1] |= Buf_RF_Data[2];
       
        Buf_RF_Data[2] <<= 3;
        Buf_RF_Data[2] |= Buf_RF_Data[4] >> 2;
       
        Buf_RF_Data[3] = Buf_RF_Data[4] << 6;
        Buf_RF_Data[3] |= Buf_RF_Data[5] << 1;
        Buf_RF_Data[3] |= Buf_RF_Data[6] >> 4;
       
        Buf_RF_Data[4] = Buf_RF_Data[6] << 4;
        Buf_RF_Data[4] |= Buf_RF_Data[7] >> 1;
       
        Buf_RF_Data[5] = Buf_RF_Data[7] << 7;
        Buf_RF_Data[5] |= Buf_RF_Data[8] << 2;
        Buf_RF_Data[5] |=  Buf_RF_Data[9] >> 3;
       
        Buf_RF_Data[6] = Buf_RF_Data[9] << 5;
        Buf_RF_Data[6] |= Buf_RF_Data[10];
       
        for(kk = 7;kk > 0;kk--)
        {
                Buf_RF_Data[kk] = Buf_RF_Data[kk - 1];
        }
        Buf_RF_Data[0] = 0xFF;                //9个头中的前8个1
        Buf_RF_Data[8] = Buf_RF_Data[9] = Buf_RF_Data[10] = 0;//这个可以不清 0
}

LBQ691477940 发表于 2015-10-1 10:08
多谢各位，昨晚我也搞掂了，也是有很多行语句呀
void clqo()//行列奇偶位计算 并将五个字节的十六进制转为 ...

计算奇偶校验用异或更快更省空间