?????

한번씩 STM칩을 만지는데

그때마다 flash 읽기 방지를 까먹는다ㅋㅋ;

아래 그림에 Read Out Protection을 설정하면

Flash 읽기를 방지할 수 있다.

Level 0 : 읽기, 쓰기 모두 가능

Level 1 : 쓰기 가능, 읽기 불가능

Level 2 : 모두 불가능

Level 2는 돌이킬 수 없기에 매우매우 고심하여 셋팅해야 한다

특별한 경우 아니면 Level 1만 해도 충분하지 않을까 싶다ㅋ

자료를 찾아보니 저걸 뚫고 해킹하는 것들도 있던데....

다음에 또 기회가 되면 해봐야겠다ㅋ

--- 모드별 핀사양

--- USBISP MK2 Supported Devices

<ISP Mode>

ATmega1280 ATmega1281 ATmega1284P ATmega1284 ATmega128A ATmega128RFA1 ATmega128 ATmega162 ATmega164A ATmega164PA ATmega164P ATmega165A ATmega165PA ATmega165P ATmega168A ATmega168PA ATmega168P ATmega168 ATmega169A ATmega169PA ATmega169P ATmega16A ATmega16HVBrevB ATmega16HVB ATmega16M1 ATmega16U2 ATmega16U4 ATmega16 ATmega2560 ATmega2561 ATmega324A ATmega324PA ATmega324P ATmega3250A ATmega3250P ATmega3250 ATmega325A ATmega325P ATmega325 ATmega328P ATmega328 ATmega3290P ATmega3290 ATmega329A ATmega329PA ATmega329P ATmega329 ATmega32A ATmega32C1 ATmega32HVBrevB ATmega32HVB ATmega32M1 ATmega32U2 ATmega32U4 ATmega32 ATmega48A ATmega48PA ATmega48P ATmega48 ATmega640 ATmega644A ATmega644PA ATmega644P ATmega644 ATmega6450A ATmega6450P ATmega6450 ATmega645A ATmega645P ATmega645 ATmega6490A ATmega6490P ATmega6490 ATmega649A ATmega649P ATmega649 ATmega64A ATmega64C1 ATmega64M1 ATmega64 ATmega8515 ATmega8535 ATmega88A ATmega88PA ATmega88P ATmega88 ATmega8A ATmega8U2 ATmega8 ATtiny13A ATtiny13 ATtiny1634 ATtiny167 ATtiny2313A ATtiny2313 ATtiny24A ATtiny24 ATtiny25 ATtiny261A ATtiny261 ATtiny26 ATtiny4313 ATtiny43U ATtiny44A ATtiny44 ATtiny45 ATtiny461A ATtiny461 ATtiny48 ATtiny828 ATtiny84A ATtiny84 ATtiny85 ATtiny861A ATtiny87 ATtiny88 AT90CAN128 AT90CAN32 AT90CAN64 AT90PWM161 AT90PWM1 AT90PWM216 AT90PWM2B AT90PWM316 AT90PWM3B AT90PWM81 AT90USB1286 AT90USB1287 AT90USB162 AT90USB646 AT90USB647 AT90USB82 ATA6285 ATA6286

<PDI Mode>

ATxmega128A1U ATxmega128A1 ATxmega128A3U ATxmega128A3 ATxmega128A4U ATxmega128B1 ATxmega128B3 ATxmega128C3 ATxmega128D3 ATxmega128D4 ATxmega16A4U ATxmega16A4 ATxmega16C4 ATxmega16D4 ATxmega192A3U ATxmega192A3 ATxmega192C3 ATxmega192D3 ATxmega256A3BU ATxmega256A3B ATxmega256A3U ATxmega256A3 ATxmega256C3 ATxmega256D3 ATxmega32A4U ATxmega32A4 ATxmega32C4 ATxmega32D4 ATxmega384C3 ATxmega384D3 ATxmega64A1U ATxmega64A1 ATxmega64A3U ATxmega64A3 ATxmega64A4U ATxmega64B1 ATxmega64B3 ATxmega64C3 ATxmega64D3 ATxmegaD4

<TPI Mode>

ATtiny4 ATtiny5 ATtiny9 ATtiny10 ATtiny20 ATtiny40

아래 예제 소스이다.

메인에서

Data1 배열을 함수

AES_ECB_Encrypt(Data1, Key, EncBuff, Len); 

를 사용하여 암호화 된 데이터가 EncBuff에 저장되고

암호화된 데이터를 함수
AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len); 

를 사용하면 DecBuff에 데이터가 나온다.

CBC 방식에 암호화 복호화 키 값은 좀 더 찾아봐야겠다.

예제)

// 여기부터 쭉 그냥 복사 시작 ------------------------------------------------------

#include  <stdio.h>
#include  <string.h>

#ifdef AES256
#define KEYLEN      32
#elif defined(AES192)
#define KEYLEN      24
#else
#define KEYLEN      16  //Key Length in unsigned chars
#endif

#define Nr          (KEYLEN/8+3)*2      //The number of rounds in AES Cipher.
#define KEYEXPSIZE  (Nr+1)*16
#define BLOCKLEN    16

#define SWAP(T,A,B)         {T=A; A=B; B=T;}
#define ROTATE(T,A,B,C,D)   {T=A; A=B; B=C; C=D; D=T;}


static const unsigned char SBox[256]=
{
    //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};


static const unsigned char SBoxInvert[256]=
{
    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};




//-----------------------------------------------------------------------------
//The lookup-tables are marked CONST so they can be placed in read-only storage instead of RAM
//The numbers below can be computed dynamically trading ROM for RAM -
//This can be useful in (embedded) bootloader applications, where ROM is often limited.
//-----------------------------------------------------------------------------
void GetSBox(unsigned char * TA)
{
    TA[0]=SBox[TA[0]];
    TA[1]=SBox[TA[1]];
    TA[2]=SBox[TA[2]];
    TA[3]=SBox[TA[3]];
}




//This function produces 4*(Nr+1) round keys. The round keys are used in each round to decrypt the states.
void KeyExpansion(unsigned char * ExpKey, unsigned char * Key)
{
    int I, T;
    unsigned char TA[4];                 //Used for the column/row operations
    static const unsigned char Rcon[11]= //The round constant word array, Rcon[I], contains the values given by X to th e power (I-1) being powers of X (X is denoted as {02}) in the field GF(2^8)
    {
        0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36
    };

    memcpy(ExpKey, Key, KEYLEN);

    //All other round keys are found from the previous round keys.
    for (I=KEYLEN; I<KEYEXPSIZE; I+=4)
    {
        memcpy(TA, ExpKey+I-4, 4);

        if (I % KEYLEN==0)
        {
            T=TA[0];
            TA[0]=TA[1];
            TA[1]=TA[2];
            TA[2]=TA[3];
            TA[3]=T;

            GetSBox(TA);

            TA[0]^=Rcon[I/KEYLEN];
        }
        #if defined(AES256)
        if (I % KEYLEN==16) GetSBox(TA);
        #endif
        ExpKey[I+0]=ExpKey[I-KEYLEN+0]^TA[0];
        ExpKey[I+1]=ExpKey[I-KEYLEN+1]^TA[1];
        ExpKey[I+2]=ExpKey[I-KEYLEN+2]^TA[2];
        ExpKey[I+3]=ExpKey[I-KEYLEN+3]^TA[3];
    }
}



//This function adds the round key to state.
//The round key is added to the state by an XOR function.
void AddRoundKey(unsigned char (*State)[4], unsigned char* ExpKey, unsigned char Round)
{
    int I, J;

    for (I=0; I<4; I++)
        for (J=0; J<4; J++) State[I][J]^=ExpKey[Round*4*4 + I*4 + J];
}



//The SubBytes Function Substitutes the values in the state matrix with values in an S-box.
void SubBytes(unsigned char (*State)[4])
{
    int I;

    for (I=0; I<4; I++) GetSBox(State[I]);
}



//The ShiftRows() function shifts the rows in the state to the left.
//Each row is shifted with different offset.
//Offset = Row number. So the first row is not shifted.
void ShiftRows(unsigned char (*State)[4])
{
    unsigned char T;

    ROTATE(T, State[0][1], State[1][1], State[2][1], State[3][1]);

    SWAP(T, State[0][2], State[2][2]);
    SWAP(T, State[1][2], State[3][2]);

    ROTATE(T, State[0][3], State[3][3], State[2][3], State[1][3]);
}



void InvShiftRows(unsigned char (*State)[4])
{
    unsigned char T;

    ROTATE(T, State[3][1], State[2][1], State[1][1], State[0][1]);

    SWAP(T, State[0][2], State[2][2]);
    SWAP(T, State[1][2], State[3][2]);

    ROTATE(T, State[0][3], State[1][3], State[2][3], State[3][3]);
}




int XTime(int X)
{
    return ((X<<1) & 0xFF) ^ (((X>>7)&1)*0x1B);
}



//MixColumns function mixes the columns of the state matrix
void MixColumns(unsigned char (*State)[4])
{
    int I, T1, T2;

    for (I=0; I<4; I++)
    {
        T1=State[I][0];
        T2=State[I][0]^State[I][1]^State[I][2]^State[I][3];
        State[I][0]^=XTime(State[I][0]^State[I][1])^T2;
        State[I][1]^=XTime(State[I][1]^State[I][2])^T2;
        State[I][2]^=XTime(State[I][2]^State[I][3])^T2;
        State[I][3]^=XTime(State[I][3]^T1)^T2;
    }
}



//Used to multiply numbers in the field GF(2^8)
int Multiply(int X, int Y)
{
    return ((Y>>0&1)*X)^
           ((Y>>1&1)*XTime(X))^
           ((Y>>2&1)*XTime(XTime(X)))^
           ((Y>>3&1)*XTime(XTime(XTime(X))))^
           ((Y>>4&1)*XTime(XTime(XTime(XTime(X)))));
}


//MixColumns function mixes the columns of the state matrix.
//The method used to multiply may be difficult to understand for the inexperienced.
//Please use the references to gain more information.
void InvMixColumns(unsigned char (*State)[4])
{
    int  I, A, B, C, D;

    for (I=0; I<4; I++)
    {
        A=State[I][0];
        B=State[I][1];
        C=State[I][2];
        D=State[I][3];

        State[I][0] = Multiply(A, 0x0E) ^ Multiply(B, 0x0B) ^ Multiply(C, 0x0D) ^ Multiply(D, 0x09);
        State[I][1] = Multiply(A, 0x09) ^ Multiply(B, 0x0E) ^ Multiply(C, 0x0B) ^ Multiply(D, 0x0D);
        State[I][2] = Multiply(A, 0x0D) ^ Multiply(B, 0x09) ^ Multiply(C, 0x0E) ^ Multiply(D, 0x0B);
        State[I][3] = Multiply(A, 0x0B) ^ Multiply(B, 0x0D) ^ Multiply(C, 0x09) ^ Multiply(D, 0x0E);
    }
}




//The SubBytes Function Substitutes the values in the state matrix with values in an S-box.
void InvSubBytes(unsigned char (*State)[4])
{
    int I, J;

    for (I=0; I<4; I++)
        for (J=0; J<4; J++) State[J][I]=SBoxInvert[State[J][I]];
}



void Cipher(unsigned char (*State)[4], unsigned char * ExpKey)
{
    int Round;

    //Add the First round key to the state before starting the rounds.
    AddRoundKey(State, ExpKey, 0);

    //There will be Nr rounds.
    //The first Nr-1 rounds are identical.
    //These Nr-1 rounds are executed in the loop below.
    for (Round=1; Round<Nr; Round++)
        {
        SubBytes(State);
        ShiftRows(State);
        MixColumns(State);
        AddRoundKey(State, ExpKey, Round);
        }

    //The last round is given below.
    //The MixColumns function is not here in the last round.
    SubBytes(State);
    ShiftRows(State);
    AddRoundKey(State, ExpKey, Nr);
}



void InvCipher(unsigned char (*State)[4], unsigned char* ExpKey)
{
    int Round;

    //Add the First round key to the state before starting the rounds.
    AddRoundKey(State, ExpKey, Nr);

    //There will be Nr rounds.
    //The first Nr-1 rounds are identical.
    //These Nr-1 rounds are executed in the loop below.
    for (Round=Nr-1; Round>0; Round--)
        {
        InvShiftRows(State);
        InvSubBytes(State);
        AddRoundKey(State, ExpKey, Round);
        InvMixColumns(State);
        }

    //The last round is given below.
    //The MixColumns function is not here in the last round.
    InvShiftRows(State);
    InvSubBytes(State);
    AddRoundKey(State, ExpKey, 0);
}



//-----------------------------------------------------------------------------
//          ECB
//-----------------------------------------------------------------------------
void AES_ECB_Encrypt(unsigned char * Input, unsigned char * Key, unsigned char * Output, int Length)
{
    unsigned char ExpKey[KEYEXPSIZE];

    memcpy(Output, Input, Length);
    KeyExpansion(ExpKey, Key);
    Cipher((unsigned char (*)[4])Output, ExpKey);
}


void AES_ECB_Decrypt(unsigned char* Input, unsigned char* Key, unsigned char* Output, int Length)
{
    unsigned char ExpKey[KEYEXPSIZE];

    memcpy(Output, Input, Length);
    KeyExpansion(ExpKey, Key);
    InvCipher((unsigned char (*)[4])Output, ExpKey);
}



//-----------------------------------------------------------------------------
//          CBC
//-----------------------------------------------------------------------------
void XorWithIv(unsigned char * Buff, unsigned char * Iv)
{
    int I;
    for (I=0; I<BLOCKLEN; I++) Buff[I]^=Iv[I];
}


void AES_CBC_Encrypt(unsigned char * Output, unsigned char * Input, int Length, unsigned char * Key, unsigned char * Iv)
{
    int I, Extra;
    unsigned char ExpKey[KEYEXPSIZE];

    Extra=Length % BLOCKLEN;
    KeyExpansion(ExpKey, Key);

    for (I=0; I<Length; I+=BLOCKLEN)
        {
        XorWithIv(Input, Iv);
        memcpy(Output, Input, BLOCKLEN);
        Cipher((unsigned char (*)[4])Output, ExpKey);
        Iv=Output;
        Input+=BLOCKLEN;
        Output+=BLOCKLEN;
        }

    if (Extra)
        {
        memcpy(Output, Input, Extra);
        Cipher((unsigned char (*)[4])Output, ExpKey);
        }
}


void AES_CBC_Decrypt(unsigned char * Output, unsigned char * Input, int Length, unsigned char * Key, unsigned char * Iv)
{
    int I, Extra;
    unsigned char ExpKey[KEYEXPSIZE];

    Extra=Length % BLOCKLEN;
    KeyExpansion(ExpKey, Key);

    for (I=0; I<Length; I+=BLOCKLEN)
        {
        memcpy(Output, Input, BLOCKLEN);
        InvCipher((unsigned char (*)[4])Output, ExpKey);
        XorWithIv(Output, Iv);
        Iv=Input;
        Input+=BLOCKLEN;
        Output+=BLOCKLEN;
        }

    if (Extra)
        {
        memcpy(Output, Input, Extra);
        InvCipher((unsigned char (*)[4])Output, ExpKey);
        }
}

// 여기까지 쭉 복사 끝 --------------------------------------------------------------


// 여기부터 메인 예제 ---------------------------------------------------------------

int main(int argc, char *argv[]) {
    int  I, Len;
    unsigned char Data[]={0x00, 0x0A, 0x11, 0x45, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0xF1, 0x21, 0xAA, 0x03, 0xFF};
    unsigned char Data1[]={0x00, 0x0A, 0x12, 0x44, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0x91, 0x34, 0x1A, 0xBB, 0xFF};
    unsigned char Data2[]={0x00, 0x0A, 0x13, 0x64, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0x84, 0x01, 0x1C, 0xC1, 0xFF};
    unsigned char Key[]={0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x47, 0x77, 0x11, 0x1E, 0x3c};
    unsigned char EncBuff[80];
    unsigned char DecBuff[80];
 
    printf("Testing AES128\n\n");
 
    Len = 16;
 
    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data[I]);
    
    // 암호화
    AES_ECB_Encrypt(Data, Key, EncBuff, Len);
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");


    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data1[I]);
    
    // 암호화
    AES_ECB_Encrypt(Data1, Key, EncBuff, Len);
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");


    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data2[I]);
    AES_ECB_Encrypt(Data2, Key, EncBuff, Len);
 
    // 암호화
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");
 
    return 0;

}

실행 화면

확인 사이트

http://aes.online-domain-tools.com/

내부 CRC 사용

CRC32/MPEG-2 방식

소스)

- 함수

uint32_t crc_compute(uint32_t * start_addr, uint32_t size)

{

    uint32_t crc_code;

    uint32_t i = 0;

    // Enable CRC

    __HAL_RCC_CRC_CLK_ENABLE();

    CRC->CR |= CRC_CR_RESET;

    while(i < size)

    {

        CRC->DR = start_addr[i];

        i++;

    }

    crc_code = CRC->DR;

    // Disable CRC

    __HAL_RCC_CRC_CLK_DISABLE();

    return crc_code;

}

- 사용

    uint32_t tbuf[2] = {0x1A2B3C4D, 0x1A2B3C4D};

    tempp = crc_compute(&tbuf, 2);

    -->tempp 값 = 0xF7461111

https://crccalc.com/

회로에서 LED나 부저등등 전압이나 전류에 맞게 저항을 달게된다.

아래 예제를 통해 저항을 계산해본다.

직렬에서 전체 전류값은 동일, 전압값은 바뀜

D1 에 2V, 10mA가 흐른다고 치면

(통상 LED들은 2V에 5~20mA를 사용)

R1 에 3V, 10mA가 흘러야하니

V = I R 공식에 의해서

3 = 0.01 * R1

R1 = 3 / 0.01

R1 = 300 Ω

이렇게 저항 값을 구할 수 있다.

저번 시간까지는 기본 소스 준비까지 했고

이번에는 연습용 보드에 LED를 켜고 꺼볼 것이다.

1. 소스 작성

GPIO1 이라고 적힌 LED를 제어할 것인데 P1.2 핀과 연결되어 있다.

아직 허접이라서 ATmega128 계열과 PIC16F.... 시리즈 몇 개만 만져보고

8bit MCU 별거 있겠나 하고 봤더니.... GG.

포스팅 끝내겠습니다. 감사합니다.

하고 싶었지만 LED 제어만 하고 접기로 마음을 다시 먹었다.ㅠㅠ

데이터시트에 Pin 배열과 I/O 제어를 보았다.

- Pin 배열

위 그림처럼 핀 배열이 되어 있고

저기 13번 Pin에 P1.2 가 보인다!!

- I/O Port Structure and Operation 파트

와우 쏼라쏼라~  나는 친절한 구글번역기를 좋아한다.

어라? Quasi-bidirectional 모드???? 뭔 처음 보는 모드이다.

밑에 설명을 보니 Input도 되고 Output도 되기도 하는 모드라고 한다.

자세한건 친절한 구글번역기에 복붙.....

우선 LED 제어에는 Push-pull 만 사용하면 되니, 통과ㅋㅋㅋㅋ

High, Low 신호는 P1 Register를 사용하면 된다.

P1M1 과 P1M2 에 위의 표를 참고하여 Register를 설정하면 된다.

이제 본 소스

#include "Include\N76E003.h"

void main()

{

volatile unsigned int vuiCount;        // 시간 지연용 변수

P1M1 = 0x00;

P1M2 = 0x04;

P12 = 0;

for(vuiCount=0; vuiCount<60000; vuiCount++);    // 시간 지연

while(1)

{

P12 = 1;

for(vuiCount=0; vuiCount<60000; vuiCount++);    // 시간 지연

P12 = 0;

for(vuiCount=0; vuiCount<60000; vuiCount++);    // 시간 지연

}

}

컴파일 후, 

다운로드를 해야하는데, 그 전에 설정을 해야한다.

전 포스팅에서 Keil 용 Driver를 설치 했다면 위와 같이 뜰 것이다.

다운로드 누르면 완료!!

LED 켰으면 게임 끝 아닙니까?ㅋㅋㅋㅋ

예제 소스도 제공해 주니 이제 마음껏 주물럭 주물럭 하자!!

이번에 Nuvoton을 다루게 되었다.

모델은 N76E003 으로 8051 계열이다.

처음으로 8051 계열을 접하게 되어서 할 수 있을랑가 모르것다...;;

모르니 그냥 맨땅에 헤딩이지ㅋㅋㅋㅋ

그럼 ㄱㄱ

--- 준비물

 - NuTiny-SDK-N76E003 V2.0 보드 1개

 - Nu-LINK-PRO 1개

1. 컴파일러 설치

Nuvoton에서 지원하는 컴파일러는 총 4가지로

- Keil  :  부분유료? Hex 파일이 2Kbyte? 까지만 무료로 사용 가능하다고 한다

           내가 검색 능력이 딸려서 그런가 정확하게는 못 찾았다.

- IAR  :  유료라고 한다.

- CooCox  : 무료다!! 그런데 사이트 접속이 안된다... 나만 안되나.. 서버 닫았나..?

- Rowley Associates  :  왠지 처음보는 이름이라 무료인줄 알고 설치 후, 사이트 여기저기를 휘젓다가

                              유료라고 적혀 있길래 지웠다.

--> 그래서 테스트용이니 Keil 설치.

위에 두개를 받아서 설치

2. uVision 실행 후, 새 프로젝트 생성

3. 적당한 위치에 프로젝트 저장

4. 타겟 디바이스 선택

 - Legacy Device Database 선택하고

 - N76E003 모델을 사용하니 이 모델 선택하고

 - Use Extended .... 이건 모르니 우선 패스ㅋㅋㅋㅋㅋ

 - OK 굿.

5. Ok ㄱㄱ

스타트 어셈 파일인듯...

6. main.c 생성

오 드뎌 소스 작성할 수 있다!!

7. 헤더파일 및 샘플 코드

www.nuvoton.com 사이트에 들어가서 해당 제품에 Resources를 들어가 보면 아래와 같이

뜬다. 위에 3개를 다 받자.

첫번째 것은 N76E003 데이터시트로 이 놈의 사용법이 다 적혀있지...

두번째 것은 헤더파일이랑 샘플이 있다.

세번째 것은 Keil에서 Nu-Link로 바로 연결되게하는 드라이버인 듯 하다.

(밑에 2개도 받아야되나.... 우선 패스ㅋㅋㅋ)

- N76E003_BSP_Keil_C51_V1.0.5 를 받아 압축을 풀면 아래와 같은 목록이 뜬다

Include만 복사해서 연습 프로젝트 폴더에 붙여 넣자!

8. 코딩 ㄱㄱ

좀 어렵겠지만 코딩을 하고 Build 를 하면 끝ㅋ

#include "Include\N76E003.h"

void main()

{

while(1)

{

}

}

다음은 LED 하나를 켜봐야겠다.

ㄴㅇㅁㄴㅇ

USB 정리.zip

[ USB Speciation v1.1, v2.0 ]

USB ORG - USB 개발자라면 한번씩 가보고 관련자료를 찾아볼수 있음.

http://www.usb.org

USB 스펙 영문 사이트 - OTG나 유용한 자료가 많이 있으니 함 가보세요.

http://www.beyondlogic.org

USB 스펙 한글 사이트

http://www.surym.pe.kr/swiki/wiki.php/USBSPEC

[ USB 관련 개발자 및 회사 사이트 ]

한국 시스템 프로그래머 사이트라고 합니다. - 디바이스 드라이버 관련 세미나를 합니다.

http://www.kosr.org/

하제소프트 - 유명한 곳이죠, 이봉석 대표-요즘은 WinCE쪽으로 많이 하시는것 같네요.

http://www.hajesoft.co.kr/

데브구루 - PC측 디바이스 드라이버 전문회사라고 하네요.(제가 devpia랑 무슨 관련이 있냐고 물으니, 왈 "아무관련없슴다."^^;)

http://www.devguru.co.kr

디바이스 온라인 - 데브구루에서 운영하는 디바이스드라이버 개발자 커뮤니티

http://www.driveronline.org

허브넷 - 개발자 두분이 운영하시는 곳 같네요.

http://www.hybtech.co.kr/

샘플칩 - 이곳도 USB전문이라고 하여 오랫동안 했다고 하네요. AVR+PDIUSBD12 칩으로 EVM보드판매 및 교육도 합니다.

http://www.samplechip.co.kr

이하는 devguru사이트에 있는 참고사이트를 가져온 것입니다.

링크하면 언제 서버에서 사라질지 알지 못하는 관계로 이곳에 직접 실었습니다.

저작권(?)에 문제가 있다면 알려주세염. 그러나 대부분 PC측 디바이스 드라이버 관련 내용임.

USB 디바이스 드라이버 제작하려면 뭐, 알아둬야 되는데... 흠.. 넘 방대한 지식이 필요한가염?

MS 공식 드라이버 개발 사이트  - MSDN 참 방대한 데이타가 있습니다. 영어에 좀만 용기를 갖는다면, 내집드나들듯이 다녀야겠죠.^^;
http://www.microsoft.com/whdc

설명:  Windows Platform Development Window Device Driver 개발을 위한
공식 사이트.  Windows Device Driver 개발자들에게 필요한 자료가 많이 있음.

System Internals 
http://www.sysinternals.com
설명: Windows 9x 와 Windows NT/2K 내부에 관한 정보를 가진 사이트. Device Driver
관련 소스코드와 기술문서가 많고, Driver 관련 유틸리티도 무료로 배포한다.
 
NT Kernel Resources 
http://www.ntkernel.com
설명: Windows Kernel 에 대한 여러가지 문서및 유틸리티 프로그램이 제공
 
Windows Driver Developer’s Digest
http://www.WD-3.com
설명: Walter Oney 가 편집장으로 있고, Windows Driver Programming 에 관한
기사를 다룬다.
 
OSR Online
http://www.osronline.com
설명: OSR 에서 만드는 Windows Device Driver 개발 사이트
드라이버 개발에 관한 풍부한 자료가 있다. 

Windows Driver Development news group
http://msdn.microsoft.com/newsgroups/default.aspx?dg=microsoft.public.development.device.drivers
설명: 전반적인 Windows 드라이버 개발에 관한 뉴스 그룹
 
OSR Hosted Newsgroups
http://www.osronline.com/page.cfm?name=ListServer
설명: 일반적인 드라이버 개발, 파일 시스템 드라이버 개발, WinDbg 들에 관한 게시판 ,
회원 가입 후. 사용 가능함
 
Designed for Windows" Logo Program newsgroup
http://msdn.microsoft.com/newsgroups/default.aspx?dg=microsoft.public.windowsxp.winlogo
설명: Designed for Windows" Logo 인증에 관한 뉴스 그룹
 
Debug Tools for Windows newsgroup
http://msdn.microsoft.com/newsgroups/default.aspx?dg=microsoft.public.windbg
설명: WinDbg 디버깅 툴에 관한 뉴스 그룹
 
VxD Driver Development newsgroup
http://groups.google.co.kr/groups?hl=ko&lr=&ie=UTF-8&oe=UTF-8&newwindow=1&group=comp.os.ms-windows.programmer.vxd
설명: OSR 에서 만드는 Windows Device Driver 개발 사이트
드라이버 개발에 관한 풍부한 자료가 있다. 
 
NTFS.com
http://www.ntfs.com/
설명: Ntfs , FAT 등의 File System 관련 자료가 있음
 
Bo Branten's website
http://www.acc.umu.se/~bosse/
설명: Filte System Driver 개발에 필요한 여러가지 정보가 있는 사이트.
ntifs.h 도 있음
 
PCAUSA
http://www.pcausa.com/
설명:  Network driver 개발에 관한 풍부한 자료가 있는 사이트
 
Wincap
http://winpcap.polito.it/
설명: Windows 에서 network packet 를 캡쳐하거나 분석하기 위한 open source
라이브러리
 
Jan Axelson's Lakeview Research - USB Complete를 쓴 유명한 사람이죠.
http://www.lvr.com
설명: embedded systems, USB, parallel port, and RS-232 and RS-485 serial 에
관한 자료가 있음
 
PS/2 Mouse/Keyboard Interface
http://www.computer-engineering.org/
설명: PS/2 Mouse/Keyboard Interface 의 설명 및 Protocol 설명 

ATA (IDE/EIDE), Serial ATA (SATA), ATAPI
http://www.ata-atapi.com/
설명: ATA 와 ATAPI interfaces 에 관한 자료가 있는 사이트  Internals

http://www.internals.com/
설명: Windows 9x/NT/2K 내부의 Undocumented 한 내용이 있는 사이트
 
Iczelion's Win32 Assembly Homepage
http://spiff.tripnet.se/~iczelion
설명: Windows Assembly 자료가 풍부한 사이트
 
Microprocessor Resources
http://www.x86.org
설명: DDJ Magazine 의 Microprocessor 자료
 
ReactOS
http://www.reactos.com/
설명: Windows NT 계열의 O/S 와 호환성을 가지는 O/S 만드는 Open Source
개발사이트
 
Codeguru 사이트의 system 관련자료 - 제가 VC++ MFC 하면서 자주 다니며 도움을 얻는 곳입니당.
http://www.codeguru.com/system/
설명: 직접 사용할 수 있는 시스템 관련 소스 및 유틸리티

출처 : http://hasu0707.tistory.com/220

I. USB Descriptor 정의

v  DEVICE DESCRIPTOR 정의 및 종류

1. USB Descriptor 정의

* USB는 대표적인 PnP (Plug & Play)를 지원하는 인터페이스

   => 디바이스에 대한 정보 및 설정 사항을 알기 위해 Descriptor를 읽어 와야 함

   => Host가 Device에게 Device에 대한 정보를 요구하고, Device가 자신의 정보를 전달 이 때 사용하는 정보 의미

* 연결된 디바이스의 종류를 알게 되고, 디바이스의 특성에 맞게 데이터 전송 양을 조절 할 수 있음

* USB Enumeration (열거) 과정에서 중요하게 사용

2. USB Descriptor 종류

(1) Device Descriptor              : 디바이스에 대한 일반정보, 단 하나의 descriptor존재

(2) Configuration Descriptor      : 하나 또는 이상의 Descriptor 기술 가능

                                                    : 여러 가지의 인터페이스 기술 가능

                                                    : 인터페이스 또한 여러 개의 End-Point 정의 기술 가능

(3) Interface Descriptor           : 인터페이스 내용기술, Alternate 셋팅을  가질 수 있음

(4) Endpoint Descriptor           : pipe, endpoint0은 descriptor가 존재하지 않음

(5) String Descriptor               : unicode format, vender이름, 디바이스 이름, serial number

3. USB Descriptor 구조

Ⅱ. USB Descriptor 분류

1. Device Descriptor

▪ Device의 모든 것을 표현

▪ USB Device는 단지 하나의 Device Descriptor를 가질 수 있음

▪ Device Descriptor는 Device에서 지원하는 USB Revision 명시

▪ 적절한 USB 드라이버를 읽어올 시에 사용되는 Product ID와 Vendor ID 명시

▪ Device가 가질 수 있는 가능한 Configuration 수 명시

▪ Configuration의 값은 얼마나 많은 Configuration Descriptor로 분기할 수 있는지 나타냄

2. Configuration Descriptor

▪ 여러 개의 다른 Configurations을 가질 수 있음 ex) 외장 HDD PWR

▪ Power 소모량 및 Device가 Self-Powered인지 Bus Powered인지, 가지고 있는 Interface 수 등의 정보를 포함

▪ Device가 Enumerate될 때 Host는 Device Descriptor를 읽고 어떤 Configuration이 활성화 될 것인지를 결정

▪ 한번에 한가지 Configuration만 가능

3. Interface Descriptor

▪ Device의 한가지 Feature를 나타내는 기능적 그룹화 과정 또는 Header로 보일 수 있음

Ex) Fax / Scanner / Printer가 되는 Multi-Function Device 시 Fax, Scanner, Printer각 기능별로 Interface Descriptor 존재

▪ Configuration Descriptor와는 달리 한번에 하나의 Interface Descriptor만 활성화 해야한다는 등의 제한 없음

▪ Interface의 수를 나타내는 bInterfaceNumber Field, Interface에 Setting을 변화시킬 수 있는 bAlternateSetting Field가 존재

4. Endpoint Descriptor

▪ End-Point (Control Endpoint를 제외)를 설명하는데  사용

▪ End-Point 0는 항상 Control Endpoint로 사용되며 어떤 Descriptor의 Request이전에 이미 설정

▪ Host는 이들 Descriptor로부터 받은 정보를 Bus의 Band Width를 정하는 데 사용

▪ Device가 어떠한 Endpoint를 지원하여도 Endpoint Description 상에 명시 되어 있지 않을 시 Endpoint 사용 불가

   => Endpoint를 이용한 Data 전송 통로인 Pipe를 Host가 생성해주지 않음

Ⅲ. USB Enumeration

1. USB Enumeration 정의

■ USB Enumeration

▪ USB host의 역할 중 하나인 Bus의 상태를 주기적으로 계속 확인

▪ 새로운 Device (Client device)가 Bus 에 연결되었는지 또는 Device가 Bus에서 제거되었는지 확인

▪ 새로운 Device가 Bus에 연결되면 host는 Device에 Control Packet을 보내는 것으로 Enumeration 시작

▪ Control Packet 전송은 Device의 Endpoint 0을 통해서 이루어 짐

▪ Enumeration과정 중 Device & Host의 주 역할

             - Device :  Host의 요구에 따라 Device descriptor를 제공

             - Host     :  Descriptor를 기반으로 적절한 Device Driver를 로드 하여 USB Device를 설정

2. USB Enumeration 순서

(1) USB DEVICE 장치 연결 안 됨

(2) USB DEVICE 장치 Cable을 통한 연결 상태

(3) USB HOST 측 Data Address 임시 할당 상태

(4) 임시 Data Address를 통한 Device Descriptor 요청

(5) Host 측에서 송신 된 Device Descriptor 요청 수신

(6) 임시 Data Address를 통한 Device Descriptor 전송

(7) Host 측에서 송신 된 Device Descriptor 요청 수신

▪ Device Descriptor 내부 8번째 byte 값을 통하여 Descriptor 저장을 위한 16진수 byte 공간 할당

▪ 할당 이후부터는 해당 주소로 Device 호출 (Device 할당 주소 외의 명령은 무시)

(8) Data Address를 통한 Device Descriptor 요청 및 수신

(9) Data Address를 통한 Device Descriptor 전송

(10) Device Descriptor를 제외한 나머지 Descriptor 요청 및 수신

(11) Data Address를 통한 나머지 Descriptor 전송 및 Enumeration 종료