아그리 입니다.. 풋..

다항식의 종류

여기에 표시하지는 않았지만 더 많은 CRC 종류들이 있다.

• 적어도 다섯 종류의 서로 다른 CRC-16, CRC-32, CRC-64가 존재하고 널리 사용된다.
• CRC-64, CRC-128, CRC-256도 존재하고 표준화되어 있지만 널리 사용되지는 않는다.

다음은 ITU-IEEE 문법으로 쓴 다양한 CRC 다항식들이다.

CRC-Table과 생성함수와의 관계

CRC table 다항식이 결정되면 같은 값이 나온다. 따라서 원하는 다항식에서 부터 table값을 만들어 사용 한다.

만드는 방법은 

1. 프로그램 시작하면서 생성함수를 실행하여 RAM의 변수영역에 CRC 데이터를 만든다.

2. 다른 OS나 환경에서 C프로그램으로 table을 만들어 코드를 원하는 프로그램 소스에 추가 한다. 

    이 경우는 CRC table이 이미 생성되어 있기 때문에 생성 함수는 타겟 프로그램에는 필요 없어 진다. 

아래의 CRC table C소스를 프로젝트에 추가하여 수신 처리에서 CRC을 계산하는데 사용하면 된다.

각 다항식과 비트수에 따른 생성 함수 및 table 소스들이다. 주의 할점은 같은 비트라고 방정식리 틀리면 다른 테이블 값이 나오므로 적용하려는 방정식을 확인 해야 한다. 즉, 방정식이 같은면 다음 예의 테이블 값을 그대로 복사해서 적용하면 된다. 경우에 따라 표준화 되어 있는 몇가지 방정식은 이미 방정식 까지 표준화 되었음을 이해 해야 한다. 특히 네트워크 관련 CRC는 그렇다.

  
1.  CRC-8


x⁸ + x² + x + 1

static byte crctable[256] = {
    0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
    0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
    0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
    0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
    0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
    0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
    0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
    0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
    0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
    0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
    0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
    0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
    0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
    0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
    0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
    0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
    0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
    0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
    0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
    0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
    0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
    0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
    0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
    0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
    0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
    0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
    0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
    0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
    0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
    0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
    0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
    0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
};

========== table 생성 ===============

static byte crctable[256];

/*
   Generate a table for a byte-wise 8-bit CRC calculation on the polynomial:
   x^8 + x^2 + x^1 + x^0
*/

void make_crc_table( void ) {
    int i, j;
    unsigned long poly, c;
    /* terms of polynomial defining this crc (except x^8): */
    static const byte p[] = {0,1,2};

    /* make exclusive-or pattern from polynomial (0x07) */
    poly = 0L;
    for ( i = 0; i < sizeof( p ) / sizeof( byte ); i++ ) {
        poly |= 1L << p[i];
    }

    for ( i = 0; i < 256; i++ ) {
        c = i;
        for ( j = 0; j < 8; j++ ) {
            c = ( c & 0x80 ) ? poly ^ ( c << 1 ) : ( c << 1 );
        }
        crctable[i] = (byte) c;
    }
}

========== 사용하기 ===============

#define CRC8_INIT_VALUE        0x0000
#define CRC8_XOR_VALUE        0x0000

void CRC8_InitChecksum( unsigned char &crcvalue ) {
    crcvalue = CRC8_INIT_VALUE;
}

void CRC8_Update( unsigned char &crcvalue, const byte data ) {
    crcvalue = crctable[crcvalue ^ data];
}

void CRC8_UpdateChecksum( unsigned char &crcvalue, const void *data, int length ) {
    unsigned char crc;
    const unsigned char *buf = (const unsigned char *) data;

    crc = crcvalue;
    while( length-- ) {
        crc = crctable[crc ^ *buf++];
    }
    crcvalue = crc;
}

void CRC8_FinishChecksum( unsigned char &crcvalue ) {
    crcvalue ^= CRC8_XOR_VALUE;
}

unsigned char CRC8_BlockChecksum( const void *data, int length ) {
    unsigned char crc;

    CRC8_InitChecksum( crc );
    CRC8_UpdateChecksum( crc, data, length );
    CRC8_FinishChecksum( crc );
    return crc;
}

=================================================================================================================

x⁸ + x⁵ + x⁴ + 1

이것처럼 계산을 하면 되는데 이를 어떻게 고속으로 계산 하라. 비트 단위로 오는 하드웨어에서나 하는거지...

미리 계산하여 테이블을 만들고 바로 찾아가면 8비트 단위로 나온다. 고속으로

CRC-8  Table

const char  tableCRC_8[]  = {
  0, 49, 98, 83, 196, 245, 166, 151, 185, 136, 219, 234, 125, 76, 31, 46, 67, 114, 33, 16,
  135, 182, 229, 212, 250, 203, 152, 169, 62, 15, 92, 109, 134, 183, 228, 213, 66, 115, 32, 17,
  63, 14, 93, 108, 251, 202, 153, 168, 197, 244, 167, 150, 1, 48, 99, 82, 124, 77, 30, 47,
  184, 137, 218, 235, 61, 12, 95, 110, 249, 200, 155, 170, 132, 181, 230, 215, 64, 113, 34, 19,
  126, 79, 28, 45, 186, 139, 216, 233, 199, 246, 165, 148, 3, 50, 97, 80, 187, 138, 217, 232,
  127, 78, 29, 44, 2, 51, 96, 81, 198, 247, 164, 149, 248, 201, 154, 171, 60, 13, 94, 111,
  65, 112, 35, 18, 133, 180, 231, 214, 122, 75, 24, 41, 190, 143, 220, 237, 195, 242, 161, 144,
  7, 54, 101, 84, 57, 8, 91, 106, 253, 204, 159, 174, 128, 177, 226, 211, 68, 117, 38, 23,
  252, 205, 158, 175, 56, 9, 90, 107, 69, 116, 39, 22, 129, 176, 227, 210, 191, 142, 221, 236,
  123, 74, 25, 40, 6, 55, 100, 85, 194, 243, 160, 145, 71, 118, 37, 20, 131, 178, 225, 208,
  254, 207, 156, 173, 58, 11, 88, 105, 4, 53, 102, 87, 192, 241, 162, 147, 189, 140, 223, 238,
  121, 72, 27, 42, 193, 240, 163, 146, 5, 52, 103, 86, 120, 73, 26, 43, 188, 141, 222, 239,
  130, 179, 224, 209, 70, 119, 36, 21, 59, 10, 89, 104, 255, 206, 157, 172
};

이것을 바로 프로그램에 복사하여 사용하면 된다.


2.  CRC-16

CRC-16   CCITT

x¹⁶ + x¹² + x⁵ + 1


#define CRC16_INIT_VALUE    0xffff
#define CRC16_XOR_VALUE        0x0000


============ 만들기  ==========================
static unsigned short crctable[256];

/*
   Generate a table for a byte-wise 16-bit CRC calculation on the polynomial:
   x^16 + x^12 + x^5 + x^0
*/

void make_crc_table( void ) {
    int i, j;
    unsigned long poly, c;
    /* terms of polynomial defining this crc (except x^16): */
    static const byte p[] = {0,5,12};

    /* make exclusive-or pattern from polynomial (0x1021) */
    poly = 0L;
    for ( i = 0; i < sizeof( p ) / sizeof( byte ); i++ ) {
        poly |= 1L << p[i];
    }

    for ( i = 0; i < 256; i++ ) {
        c = i << 8;
        for ( j = 0; j < 8; j++ ) {
            c = ( c & 0x8000 ) ? poly ^ ( c << 1 ) : ( c << 1 );
        }
        crctable[i] = (unsigned short) c;
    }
}


/*
  Table of CRC-16's of all single-byte values (made by make_crc_table)
*/
static unsigned short crctable[256] = {
    0x0000,    0x1021,    0x2042,    0x3063,    0x4084,    0x50a5,    0x60c6,    0x70e7,
    0x8108,    0x9129,    0xa14a,    0xb16b,    0xc18c,    0xd1ad,    0xe1ce,    0xf1ef,
    0x1231,    0x0210,    0x3273,    0x2252,    0x52b5,    0x4294,    0x72f7,    0x62d6,
    0x9339,    0x8318,    0xb37b,    0xa35a,    0xd3bd,    0xc39c,    0xf3ff,    0xe3de,
    0x2462,    0x3443,    0x0420,    0x1401,    0x64e6,    0x74c7,    0x44a4,    0x5485,
    0xa56a,    0xb54b,    0x8528,    0x9509,    0xe5ee,    0xf5cf,    0xc5ac,    0xd58d,
    0x3653,    0x2672,    0x1611,    0x0630,    0x76d7,    0x66f6,    0x5695,    0x46b4,
    0xb75b,    0xa77a,    0x9719,    0x8738,    0xf7df,    0xe7fe,    0xd79d,    0xc7bc,
    0x48c4,    0x58e5,    0x6886,    0x78a7,    0x0840,    0x1861,    0x2802,    0x3823,
    0xc9cc,    0xd9ed,    0xe98e,    0xf9af,    0x8948,    0x9969,    0xa90a,    0xb92b,
    0x5af5,    0x4ad4,    0x7ab7,    0x6a96,    0x1a71,    0x0a50,    0x3a33,    0x2a12,
    0xdbfd,    0xcbdc,    0xfbbf,    0xeb9e,    0x9b79,    0x8b58,    0xbb3b,    0xab1a,
    0x6ca6,    0x7c87,    0x4ce4,    0x5cc5,    0x2c22,    0x3c03,    0x0c60,    0x1c41,
    0xedae,    0xfd8f,    0xcdec,    0xddcd,    0xad2a,    0xbd0b,    0x8d68,    0x9d49,
    0x7e97,    0x6eb6,    0x5ed5,    0x4ef4,    0x3e13,    0x2e32,    0x1e51,    0x0e70,
    0xff9f,    0xefbe,    0xdfdd,    0xcffc,    0xbf1b,    0xaf3a,    0x9f59,    0x8f78,
    0x9188,    0x81a9,    0xb1ca,    0xa1eb,    0xd10c,    0xc12d,    0xf14e,    0xe16f,
    0x1080,    0x00a1,    0x30c2,    0x20e3,    0x5004,    0x4025,    0x7046,    0x6067,
    0x83b9,    0x9398,    0xa3fb,    0xb3da,    0xc33d,    0xd31c,    0xe37f,    0xf35e,
    0x02b1,    0x1290,    0x22f3,    0x32d2,    0x4235,    0x5214,    0x6277,    0x7256,
    0xb5ea,    0xa5cb,    0x95a8,    0x8589,    0xf56e,    0xe54f,    0xd52c,    0xc50d,
    0x34e2,    0x24c3,    0x14a0,    0x0481,    0x7466,    0x6447,    0x5424,    0x4405,
    0xa7db,    0xb7fa,    0x8799,    0x97b8,    0xe75f,    0xf77e,    0xc71d,    0xd73c,
    0x26d3,    0x36f2,    0x0691,    0x16b0,    0x6657,    0x7676,    0x4615,    0x5634,
    0xd94c,    0xc96d,    0xf90e,    0xe92f,    0x99c8,    0x89e9,    0xb98a,    0xa9ab,
    0x5844,    0x4865,    0x7806,    0x6827,    0x18c0,    0x08e1,    0x3882,    0x28a3,
    0xcb7d,    0xdb5c,    0xeb3f,    0xfb1e,    0x8bf9,    0x9bd8,    0xabbb,    0xbb9a,
    0x4a75,    0x5a54,    0x6a37,    0x7a16,    0x0af1,    0x1ad0,    0x2ab3,    0x3a92,
    0xfd2e,    0xed0f,    0xdd6c,    0xcd4d,    0xbdaa,    0xad8b,    0x9de8,    0x8dc9,
    0x7c26,    0x6c07,    0x5c64,    0x4c45,    0x3ca2,    0x2c83,    0x1ce0,    0x0cc1,
    0xef1f,    0xff3e,    0xcf5d,    0xdf7c,    0xaf9b,    0xbfba,    0x8fd9,    0x9ff8,
    0x6e17,    0x7e36,    0x4e55,    0x5e74,    0x2e93,    0x3eb2,    0x0ed1,    0x1ef0
};


3.  CRC-32

이것은 이미 사용한 예시 프로그램이 있고, 첨부 파일을 참고하면 된다.

C 언어의 문자형 변수 char 


crc32.cpp - CRC을 만든다.

(1) main() 함수의 초기에 테이블을 만든다.

#define k_poly            ((unsigned int)(0xedb88320))
#define k_crc_table_size    (256)

unsigned int gg_a_crc_table[k_crc_table_size];


char g_comBuff[1024];

typedef unsigned int u32;
typedef struct {
     u32  crc;
     u32  type;
     u32  dlength;
     u32  data[1024];
     // . . .     
} ;

int main(int argc, char* argv[])
{
   int cnt;

    fn_init_crc_table(); // CRC32 초기화 - CRC Table 작성

   makePacket( (PacketStruct *) g_comBuff, (void *) "hello", (int) 6); // 패킷을 만든다.

   send(g_comBuff);

   // . . .
}

void
fn_init_crc_table()
{
    short    i_table;
    
    for (i_table = 0; i_table < k_crc_table_size; i_table++)
    {
        unsigned int    result = 0;
        short    i_bit;
        
        for (i_bit = 0; i_bit < 8; i_bit++)
        {
            unsigned int    bit = ((i_table  & (1 << i_bit)) != 0);
            
            if ((bit ^ (result & 1)) != 0)
                result = (result >> 1) ^ k_poly;
            else
                result >>= 1;
        }
        
        gg_a_crc_table[i_table] = result;
    }
    
} /* end of fn_init_crc_table */

(2) 테이블을 이용하여 패킷을 만들 때, 데이터로 부터 계산 한다.

통신패킷 설정 :

PacketStruct *makePacket(PacketStruct *pkt, void *data, int leng)
{
     unsigned int  datalength;
   
     // 데이터 포멧하기
     pkt->dlength = leng;
     memcpy((void*) &pkg->data, data,leng);
     pkt->type= 0x00100020;

     datalength =  sizeof (PacketStruct) - sizeof(u32);
     unsigned short int rcrc = (u32) fn_calc_memory_crc32( (void *) &pkt->type, datalength);
     pkt->crc = rcrc;
     return pkt; 
}


unsigned int
fn_calc_memory_crc32(void *p, unsigned int n_bytes)
{
    fnm_assert_stmt(n_bytes > 4);
    
    return(fn_calc_memory_chunk_crc32(p, n_bytes, k_initial_crc_value));
    
} /* end of fn_calc_memory_crc32 */

static unsigned int
fn_calc_memory_chunk_crc32(void *p, unsigned int n_bytes, unsigned int crc)
{
    unsigned char    *p_uc   = (unsigned char*)p;
    unsigned int   result  = ~crc;
    
    while (n_bytes-- > 0)
    {
        result = (result >> 8) ^ gg_a_crc_table[(result ^ *p_uc++) & 0xff];
    }
    
    return(~result);
    
} /* end of fn_calc_memory_chunk_crc32 */

==============================================================================

CRC-32     IEEE-802.3

x³² + x²⁶ + x²³ + x²² + x¹⁶ + x¹² + x¹¹ + x¹⁰ + x⁸ + x⁷ + x⁵ + x⁴ + x² + x + 1

#define CRC32_INIT_VALUE 0xffffffffL

#define CRC32_XOR_VALUE 0xffffffffL



static unsigned long crctable[256];



/*

 Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:

 x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x^1+x^0.



 Polynomials over GF(2) are represented in binary, one bit per coefficient,

 with the lowest powers in the most significant bit. Then adding polynomials

 is just exclusive-or, and multiplying a polynomial by x is a right shift by

 one. If we call the above polynomial p, and represent a byte as the

 polynomial q, also with the lowest power in the most significant bit (so the

 byte 0xb1 is the polynomial x^7+x^3+x^1+x^0), then the CRC is (q*x^32) mod p,

 where a mod b means the remainder after dividing a by b.



 This calculation is done using the shift-register method of multiplying and

 taking the remainder. The register is initialized to zero, and for each

 incoming bit, x^32 is added mod p to the register if the bit is a one (where

 x^32 mod p is p+x^32 = x^26+...+x^0), and the register is multiplied mod p by

 x (which is shifting right by one and adding x^32 mod p if the bit shifted

 out is a one). We start with the highest power (least significant bit) of

 q and repeat for all eight bits of q.



 The table is simply the CRC of all possible eight bit values. This is all

 the information needed to generate CRC's on data a byte at a time for all

 combinations of CRC register values and incoming bytes.

*/



void make_crc_table( void ) {

 int i, j;

 unsigned long c, poly;

 /* terms of polynomial defining this crc (except x^32): */

 static const byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};



 /* make exclusive-or pattern from polynomial (0xedb88320L) */

 poly = 0L;

 for ( i = 0; i < sizeof( p ) / sizeof( byte ); i++ ) {

 poly |= 1L << ( 31 - p[i] );

 }



 for ( i = 0; i < 256; i++ ) {

 c = (unsigned long)i;

 for ( j = 0; j < 8; j++ ) {

 c = ( c & 1 ) ? poly ^ ( c >> 1 ) : ( c >> 1 );

 }

 crctable[i] = c;

 }

/*

 Table of CRC-32's of all single-byte values (made by make_crc_table)

*/

static unsigned long crctable[256] = {

 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,

 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,

 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,

 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,

 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,

 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,

 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL,

 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,

 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L,

 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,

 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L,

 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,

 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L,

 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,

 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,

 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,

 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL,

 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,

 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L,

 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,

 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL,

 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,

 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL,

 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,

 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,

 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,

 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L,

 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,

 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L,

 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,

 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L,

 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,

 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL,

 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,

 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,

 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,

 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL,

 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,

 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL,

 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,

 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L,

 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,

 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L,

 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,

 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,

 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,

 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L,

 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,

 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL,

 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,

 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L,

 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,

 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL,

 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,

 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,

 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,

 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L,

 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,

 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L,

 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,

 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L,

 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,

 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L,

 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL

};

더보기

이미지 펌 : http://www.bodnara.co.kr/bbs/article.html?imode=view&D=7&cate=19&d_category=1&num=71174&mn=2&refresh_cnt=1

이 그림 마냥..찬공기는 아래로 내려오고.. 

더보기

히트파이프는 주로 구리로 만들어지는데 내부에는 기화가 잘되는 물질이 들어가있는 관으로 구성되어있습니다.

히트파이프의 한쪽에 열을 받으면 내부물질이 기화하고 다른쪽 으로 열을 전달합니다.
다른쪽에서 열을 발산하고나면 다시 액체로 돌아가 열을 효과적으로 전달할수 있습니다.
히트파이프에대한 자세한 원리는 '히트파이프에 대한 고찰'(브레인박스) 에 잘 나와있으니 참고하시기 바랍니다.

자, 다시 본론으로 돌아와서 히트파이프로 발산된 열은 노트북의 쿨링팬에 의해 외부로 방출하게 됩니다. 그래서 노트북의 팬이있는 곳의 배기구에 손을 데어보면 뜨끈한 바람이 나오는것을 확인할수 있습니다. 즉, 내부는 더뜨겁다는말이 되겠죠.
그리고 쿨링팬 아래쪽의 흡입구는 외부의 차가운 공기를 흡입시켜 히트파이프의 냉각을 도와줍니다.

더보기

출처 : http://withnotebook.tistory.com/55

자아...  계속.. 

우선 노트북의 열이 어디쯤 모여 있는지 알것있다.. 

당연 LCD 말고 바닥면이겠지.. 

그럼 어떻게 해야되겠는가..?

바닥면에 열을 분산시킬수있는 곳에 둬야 하는것이다.. 

어떻게 해야할까???

 위 사진 처럼 두고 쓰거나.. 

아래 사진의 템을 써서 사용하면 된다.. 

가격??? 싸면 1만원정도 하고 비싸면 8만원정도 한다.. 

쿨링효과는 확실히 있다.. 나도 쓰고있으니깐.. 

---

위에 어쩌고 저쩌고 하지만.. 

다음 사항만 지키면 별 문제 없다.

이정도?? 

이불에서 사용하는건 영상매체의 영향으로 많이들 그리 사용하는데.. 노트북의 주요 구성품의 수명을 줄이는 이 뿐이다.. 

가급적 그리 쓰지말자.

여기까지 환경적인 요소.. 이상한글이 많이포함 됬지만 여기서 위로 10줄만 필요한거다.. 적작 3줄일걸?? ㅎㅎ

---

이번엔 사용할때이다.

노트북중에 가장 약한 부분.. LCD다.. 

이건 외부적인 충격만 피하면된다.. 

그 다음이 HDD 인데.. 

떨구면 죽을 확률 90%이상.. 

요즘 SDD 로 바꾸면 죽을일 없지만.. 

HDD는 쉽게 죽는다.

데스크탑용 3.5인치의 수명은 10만시간이지만

노트북용 2.5인치의 수명은 5만시간이다.

무려 반이나 적다.. 

그런데도 A/S 가 구리다.. 

왜냐..

노트북을 분해하는 동시에 A/S는 물건너가기 떄문에.. 

하드디스크의 수명... 어떻게 보는가..

아래 그림은 한번쯤을 봤을것이다.. 

빨간 줄이 난잡하게 펼쳐져있을것이다.. 

난잡할수록 하드디스크의 속도는 느리다.. 

하드디스크의 구조는 아래그림 인데.. 

데이터는 섹터 부분에 저장된다.. 

그 저장된 섹터 부분에 헤드가 왓다리 갔다리 하면서 읽는건데.. 데이터가 여기저기 뿔뿔이 흩어져있다면?? 

헤드의 이동량은 많아지고.. 이동량이 많으면 그많큼 느려지는것이다.

 

처음 하드디스크를 샀을 때는 매우 빠른것을 느낄수 있을것이다. 

그때부터는 섹터 1번지부터 차근히 데이터를 적어가기때문이다..

그후 나중에 파일을 지우고 쓰고 지우고 쓰고.. 

번지수에 맞게 헤드를 움직이니 당연히 느려지는것이다.. 

그래서 위위의 빨간 줄이 팍팍 가있는것이고.. 

위에조각모음은 파일을 정리해준다기보다는 저장된 파일을 논리적으로 연결해주는것이다. 

예를 들면...

이렇게 데이터가 저장되어있다.. 

바르게 고쳐보자.. 

동해물과 나는 자랑스러운 백두산이 굳게 다짐합니다. 마르고 길이보전하세.태극기앞에 무궁한 영광을 위하여  대한으로 몸과마음을 바쳐 대한사람 충성을 다할것을 

금방되겠는가??

자 그럼 이렇게되어잇다.

(1)동해물과 (A)나는 자랑스러운 (2)백두산이 (G)굳게 다짐합니다. (3)마르고 닮도록 (6)길이보전하세. (B)태극기앞에 (D)무궁한 영광을 위하여 (C)조국과 민족의  (5)대한으로 (E)몸과 마음을 바쳐 (4)대한사람 (F)충성을 다할것을 

이러면 좀 알기 쉬운가??

앞에 숫자나 알파벳으로 문자열의 순서를 넣었다.. 정리가 쉬울것이다. 

근데 MAC OSX의 파일 관리는 이렇다고한다..

애국가같은경우에는 

(1)동해 물과 백두산이 마르고 닳도록 

하느님이 보우하사 우리나라 만세. 

(a)무궁화 삼천리 화려강산 

대한 사람, 대한으로 길이 보전하세

(2)남산 위에 저 소나무, 철갑을 두른 듯 

바람서리 불변함은 우리 기상일세. 

(a)(3)가을 하늘 공활한데 높고 구름 없이 

밝은 달은 우리 가슴 일편단심일세. 

(4) 이 기상과 이 맘으로 충성을 다하여 

괴로우나 즐거우나 나라 사랑하세. 

(a)

같은 내용의 데이터는 다른데에서 그대로 사용.. 

타임머신 백업이 이런구조라고 하는군.. 

암튼.. 

이처럼 조각난 데이터에 각 주소를 넣어 순서를 놓는것이다. 그래서 조금이나마 빠르게 처리가 가능한것이다.

그렇다면 컴퓨터가 느려지면 포멧을 하며 되지 않겠는가.. 

그렇다.. 포멧을 하고 다시 시작하면 빨라진다.. 

근데.. 하지만 또 금방 느려진다.. 이유는 하드디스크의 섹터에 잔여 데이터가 남아있어서 그렇다. 어떤데이터?? NULL 데이터 이다.. 

데이터의 주소만 홀라당 지운 빠른 포멧.. 걍 덥어쓰는거다.. 그래서 기존의 데이터는 이도 저도 아닌 NULL데이터다.. 

이 NULL은 아무것도 아닌 데이터인데..  있긴있지만 없는거나 마찬가지의 존재이다..

그렇다면 어떻게 해야되나..  LOW Level Format를 해야한다.

이것은섹터의 데이터를 0000 으로 바꿔 버리는것이다.

그럼 애초에 로우레벨포멧을 하면 되지 않는가?? 

이것은 하드의 전체 섹터를 0을 바꾸는것으로 섹터 전부 바꾸게되고... 그래서 괭장히 느리다.

그리고 컴퓨터의 전원이 불안정하면 하드디스크의 회전도 불안해지고.. 그러다가 배드 섹터가 생기는것이다. 

논리적 배드 섹터.. 이럴경우에는 재 포멧으로 지울수 있지만 헤더가 때려서 생긴 물리적 배드섹터는 답이없다.. 

컴터 몇번 포멧해가면서 파티션 나누고.. 따로 보관해두고.. 날리가 아니다.. ㅡㅡ;; 

자 다시..

아무리 포멧을 잘한다 해도 하드디스크는 물리적으로 구동한다.. 즉.. 액추에이터가 모터이다.. 

모터의 수명이 즉 하드디스크의 수명.. 이게 아까 말한 10만시간 5만시간 이라는것이다.

노트북의 하드디스크는 데스크탑보다 작다.. 그러므로 모터도 작다.. 수명도 작다.. ㅡㅡ;; 쬐그만시키...

머.. 말다했지.. 컴터를 최대한 굴리지 않으면된다.. 

노트북의 리소스를 최대한 램영역에서 동작하게 하고.. 하드디스크의 구동을 억제 시켜야한다..

하지만 윈도우에서는 가상 메모리라고 하드디스크의 영역을 잡아먹는다.. 

임시 데이터를 하드디스크에 썻다 지웠다 한다는 말이다.. 이건 앞서 얘기했던 섹터의 분리가 되는것이다.

즉, 메모리를 많이 잡아먹는 프로그램은 피하라는것이다. 

아.. 도스용게임 제일 좋겠군.. 640kb의 상주메모리가 필요하니.. 음.. 얼마나 남는거야?? ㅎㅎ

빌게이츠의 명언이 떠오른다.

"인간이 삶면서 필요한 컴퓨터 메모리는 640kb면 충분하다."  ㅡㅡ;

이건 무어의 법칙[Moore's Law]으로 깨진지 오래이다.. 

머.. 빌게이츠가 그런말을 해서 이런 이론이 나올수도 있었을것이다.

여튼.. 

---

하드디스크의 수명관리..

1. 야동을 받지말아라..

    : 즉 P2P를 쓰지말라는것이다. 당나귀나, 프루나, 토렌토 이것들은 컴터의 하드디스크에 데미지를 팍팍 먹인다.

2. 노트북을 심하게 흔들지마라..

   : 하드디스크가 동작중에 스핀모터가 나갈경우가 있다.. 소수이지만..

3. 항상 40%이상의 비어있는 용량을 유지해라.. 

  : 300 기가면 한 120기가정도 남겨두자..

4. 하드디스크는 왠만하면 3년이내에 교체 한번하자.. 

  : 컴터 느리다고 하면 걍 하드 용량 같더라도 새걸로 장만해라.. 

    기존하드는 외장형로 쓰고 말야..ㅎㅎ

---

전체 적으로 머.. 이정도?? ㅎㅎ

예전에 02년도 김정화가 찍은 센스Q 노트북 아직도 집에서 쓰여지고있다.. 

어떻게관리하냐고??

가끔 뜯어서 물청소하고 말린다.. 드라이기로.. ㅋㅋ

그리고 하드디스크는 없어서 교환을 못하고있다..ㅜㅜ

암튼 이렇다.. ㅎㅎ

이 블로그는 혼자 지꺼리는거니깐.. 마춤법(그래 틀린거다 이노마!!) 틀렸네 어쩠네 하지마쇼 

반말로 하네 어쩌네도 하지말고.. ㅎㅎ

그럼.. (__*

 

 

  

출처 : 

http://www.ktechno.co.kr/pictech/motor02.html

1. 토크란 무엇인가?

모터 등의 선택시에 필요하게 되는 파라미터 가운데서 "토크"라고 하는 것이 있다. 
이 토크(torque)란, 회전력이라고도 표현할 수 있는데, 물체를 동작시키려 할 때에 필요로 하는 힘을 표현한 것이다.

물체를 동작시킬 때의 필요한 토크는 아랫 그림과 같이 가속기간과 등속운동 기간에서 다르다. 

아랫 그림과 같은 삼륜차를 실례로, 동륜(動輪)의 축에 필요한 토크를 구하는 방법을 설명한다. 




가속기간 토크

  Tm=Ta+L

등속운동기간
Tm=L
Tm: 동륜축의 토털 토크
Ta: 가속 토크
L: 마찰부하 토크

이것을 윗 그림의 구체적인 물체에서 계산에 의해 구하려면 다음과 같이 한다.

Ta=J/g×2πf/t         Ta: 가속토크(kg·cm) 
                              J: 부하관성 모멘트(kg·cm²)
                              g: 중력가속도(980cm/sec²)
J=WD²/8                  f: 동륜의 등속운전속도(회전/sec) 
                              t: 가속기간의 시간(sec) 
                             W: 물체의 전체중량(kg) 
L=μWD/4              μ: 마찰계수(0.09) 
                             D: 동륜의 직경(cm)

3. 실제의 사례

다음과 같은 실제 삼륜차에서 구해 보기로 한다.

W: 2kg       D:5cm           f: 2회전/sec         t: 0.5sec

J=2×5×5/8=6.25(kg·cm²)
Ta=6.25/980×6.28×2/0.5=0.16(kg·cm)
L=0.09×2×5/4=0.225(kg/cm)

여기서 가속기간과 등속기간의 토크는 아래와 같이 된다.

Tm(가속)=0.16+0.225=385(g·cm)
Tm(등속)=225(g·cm)

4. 모터의 선택법

위의 실례에 적당한 모터는 어떤 것이 될까?
우선 필요한 기동 토크는 385(g·cm)이지만, 안전율을 1.5배 정도로 보고, 600(g·cm) 이상으로 한다.

앞 페이지의 모터 카탈로그로에서 보면 기동 토크가 600(g·cm)를 넘는 것은 RS540 뿐이다. 그러나 이것으로는 모터 자체가 너무 크고 배터리나 모터의 중량을 가미하면 2kg의 전체 중량을 훨씬 넘어 버린다.
그러면 어떻게 하면 좋을까? 
그렇다... 기어를 사용한다. 동륜축에 기어를 부착하여 감속시키는 방법이다. 그렇게 하면 모터의 토크를 기어에 비례하여 감속시킬 수 있다.
간단한 공작 실험을 한다면 모형점에서도 기어 세트를 구입할 수 있는데, 예를 들면 모터는 RE260이고, 기어 세트에서 기어비가 40:1이나 65:1인 경우, 40:1로 했을 때, RE260의 기동 토크는 50~90이므로 기어 후에는 2000부터 3600까지 할 수 있어, 필요한 600(g·cm)은 충분히 구동할 수 있다는 계산이다.

또, 등속 운전시에는 RE260의 적정 부하토크가 10∼15(g·cm)이므로 40배하며, 역시 400부터 600(g·cm)의 토크를 낼 수 있으므로 필요한 225×1.5배=338(g·cm)를 충분히 구동할 수 있다.

그러나, 가속기간의 최종 단계 무렵에는 모터의 적정 부하시의 토크로 구동하는 것이 되는 셈이므로, 600(g·cm)의 토크를 내기 위해서는 모터의 적정 부하시의 토크로 15g·cm 이상의 토크가 필요하기 때문에 1.5V로 구동하는 것은 사실 역부족이다.
따라서 모터에 가하는 전압은 3V로 하게 된다. 
즉, 모터가 낼 수 있는 있는 토크는 속도가 높아지면 반비례하여 내려가는 점에 주의할 필요가 있다.

회전수는 충분한가?
적정 부하시의 RE260의 회전수는 5000∼10100이므로 이 40분의 1은 125∼252 회전/분이므로, 2회전/sec 즉 120회전/분을 충분히 커버할 수 있다.

이 관계를 그림으로 나타낸 것이 아랫 그림인데, 황색의 범위가 필요하게 되는 토크와 회전수의 범위로 되지만, 이것이 모터의 적정부가 동작의 범위내에 들어가 있으면 문제없이 구동할 수 있는 것이다.

5. 기어 세트의 예

실제로 실험에서 사용하는 기어 세트의 예를 다음 표에 나타낸다.

기어 명칭	저속 기어비	고속 기어비	사용 모터
하이스피드박스	11.6:1	18:1	RE260 RE140
하이파워박스	41.7:1	64.8:1	RE260 RE140
웜기어박스	216:1	336:1	RE260 RE140
유성 기어박스	4:1~400:1까지 14종		RE260 RE140

고립된 강체의 회전운동 상태는 그대로 유지된다. 강체의 회전운동 상태를 변화시키는 요인을 돌림힘이라고 부르며, 같은 돌림힘에 대해서도 물체에 따라서 회전운동 상태가 변화하는 정도는 다르다. 물체의 회전운동 상태는 각속도 ω 로, 회전운동 상태에 변화가 일어나는 정도는 각가속도 α로 정량화되며, 물체의 각가속도와 물체에 가해진 총돌림힘 τ사이에는

                 τ = I dω/dt = I α                                      (1) 

즉, 정비례 관계가 성립하는데 이 비례상수가 물체의 관성 모멘트 I 이다.

여러 개의 입자로 구성되어 있으면서 입자 사이의 상대적인 위치가 고정되어 있는 계의 경우, 어떤 축에 대한 관성 모멘트는

                 I = ∑ miri2             (i 는 입자의 지표)                (2) 
                     i

이고, 여기서 m_i 는 i 번째 입자의 질량이고 r_i 는 축으로부터 그 입자까지의 직선거리이다.

질량이 균일하게 분포되어 있는 강체의 경우에는 이를

                 I = ∫ r2 dm                                             (3) 

라고 쓸 수 있는데, 여기서 ρ 는 강체의 밀도이고, r 은 축으로부터의 거리이다. 대칭적인 물체의 경우에는 관성 모멘트를 비교적 쉽게 계산할 수 있는데, 이때 관성 모멘트는 같은 물체의 경우라도 어떤 축을 회전축으로 하느냐에 따라서 달라지므로, 관성 모멘트를 얘기할 때는 반드시 축을 함께 나타내야만 한다. 관성 모멘트 계산의 한 예로, 반지름 R 인 원판의 경우에 판에 수직한 중심 축을 회전축으로 할 때는 식(3)에서

                dm = ρ2πr2dr , ρ=M/πR2                                            (4)

로 쓸 수 있으므로,

                 I = (1/2)MR2                                               (5)

이 된다. 그림에 몇 가지 대칭적인 물체의 관성 모멘트를 나타내었다.









관성 모멘트의 편리한 특성으로 어떤 한 축에 대한 관성 모멘트 I₁ 을 알면, 그 축과 평행한 다른 축을 회전축으로 했을 때의 관성 모멘트 I₂ 를 알 수 있다.

                 I2 = I1 + Mr2                                               (6)

여기서 M 은 물체의 총 질량, r 은 두 축간의 거리이다. 이 관계를 평행축 정리(parallel axis theorem)라고 부르며 평행한 축들 사이에서만 성립된다. 평행축 정리를 적용하는 한 예로 경사진 면을 굴러 내려오는 쇠공의 경우와 같이, 면과의 접점을 지나면서 면에 평행한 회전축에 대한 쇠공의 관성 모멘트는 식(6)과, 중심 축에 대한 쇠공의 관성 모멘트가 (2/5)MR² 인 것으로부터

                 I = (2/5)MR2 + Mr2 = (7/5)MR2                               (7)

이 된다.