20130926

스마트 컨트롤러 게시물

20130926

사랑한다1234 2013. 9. 26. 10:14

______RFID_________________________________________________________________________________________________

ISO15693(RFID) Host Commands

<트랜스폰더, 태그>

<리더기>

ISO15693 Host Commands

Addressed

mode

Non-addressed

mode

Selected

Data Format and Protocol Frames

LENGTH n : Number of protocol bytes 1- n (6 - 255) incl. length byte and checksum
COM-ADR : 0..254 address of device in bus mode
The Reader can be addressed via COM-Adr 255 at any time!

STATUS / PROTOCOL-DATA: Includes the status message or protocol data from or to the Reader.

The data will be send always as MSB first if the Reader is

in the ISO15693Host Command

CRC16 : Cyclic redundancy check of the protocol bytes from 1 to n-2, as specified by CCITT-CRC16
Polynom x16 + x12 + x5 + 1
Start Value 0xFFFF

RFID 리더기에 HOST명령 전송

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/signal.h>

#define SPEED B38400
#define SPORT "/dev/ttyS1" //Serial Port2

unsigned short CRC16(unsigned char *, unsigned int);
void Handle_Serial_Sig(int);

volatile int iBreak = 0;

int main()
{

char cBuff[255];                       // 수신용 버퍼
int iDev = 0;                             // 장치 데스크립션
int iRet = 0;                             // 반환값

struct termios stOldState;         // 기존 Serial Port 상태 정보
struct termios stNewState;        // 새로운 Serial Port 상태 정보
struct sigaction stSigAct;         // 시그널 액션 설정

unsigned char Buff[] = {

       0x0D,
       0x00,
       0x71,
       0x00,
       0x30,
       0x00,
       0x00,
       0x00,
       0x0A,
       0x00,
       0x00,
       0xFF,
       0xFF

};

iDev = open(SPORT, O_RDWR | O_NOCTTY | O_NONBLOCK);// Serial Port Open

if( 0 > iDev)                       //시리얼 포트 Open Error
{
       perror(SPORT);
        exit(-100);

}

//시리얼 포트 설정 전에 시그널 핸들러 등록

bzero(&stSigAct, sizeof(stSigAct));
stSigAct.sa_handler = Handle_Serial_Sig;
sigaction(SIGIO, &stSigAct, NULL);

//SIGIO signal 을 수신하도록 설정
fcntl(iDev, F_SETOWN, getpid());//iDev(시리얼 포트) 소유자를 현재 프로세스로 바꿈
// SIGIO 발생은 소유자에게 알려지기 때문에...

// file descriptor를 비동기로 설정
fcntl(iDev, F_SETFL, FASYNC);

tcgetattr(iDev, &stOldState); // 현재 Serial Port 상태 저장 (백업해둠)

bzero(&stNewState, sizeof(stNewState)); // 구조체 초기화

stNewState.c_iflag = IGNPAR | ICRNL ;
stNewState.c_oflag = 0; // 수신된 데이터를 그대로 출력

stNewState.c_lflag = ICANON; // Canonical 통신 기법 사용
stNewState.c_cc[VMIN] = 1; // read시 리턴되기 위한 최소 문자 개수 지정
stNewState.c_cc[VTIME] = 0;

tcflush (iDev, TCIFLUSH); // 시리얼 포트수신 큐 초기화
tcsetattr(iDev, TCSANOW, &stNewState); //시리얼 포트에 새 속성 적용

*((unsigned short *)(&Buff[Buff[0]-2])) = CRC16(Buff, Buff[0]-2);

//원래 데이터에 체크섬 계산된값을 넣음

printf("%02X\n", Buff[0] );
printf("%02X\n", Buff[1] );
printf("%02X\n", Buff[2] );
printf("%02X\n", Buff[3] );
printf("%02X\n", Buff[4] );
printf("%02X\n", Buff[5] );
printf("%02X\n", Buff[6] );
printf("%02X\n", Buff[7] );
printf("%02X\n", Buff[8] );
printf("%02X\n", Buff[9] );
printf("%02X\n", Buff[10] );
printf("%02X\n", Buff[11] );
printf("%02X\n", Buff[12] );

write(iDev, Buff, Buff[0]); // 패킷전송

/*
while(1)
{
  if(1 == iBreak)
  {
   iRet = read(iDev, cBuff, 255); // 시리얼 포트로부터 데이터 수신
   cBuff[iRet] = 0;
   printf("[%s]:[%d]\n", cBuff, iRet);
   break;
  }
  else
  {
   sleep(2);

  }
  printf("Go Sleep\n");
}
*/
tcsetattr(iDev, TCSANOW, &stOldState); // 시리얼 포트의 원래 속성 복귀
close(iDev); // 시리얼 포트 닫음

return 0;

}

void Handle_Serial_Sig(int Arg)
{
printf("Receive SIGIO Signal\n");
iBreak = 1;
}

#define CRC_POLYNOM 0x8408
#define CRC_PRESET 0xFFFF

unsigned short CRC16(unsigned char *DATA, unsigned int cnt)

{

unsigned short crc = CRC_PRESET;
unsigned int i;
unsigned int j;

/* cnt = number of protocol bytes without CRC */
for (i = 0; i < cnt; i++)
{

  crc ^= DATA[i];
  for (j = 0; j < 8; j++)
  {
      if (crc & 0x0001)
       crc = (crc >> 1) ^ CRC_POLYNOM;
       else
       crc = (crc >> 1);
  }

}
return crc;

}

____________________________________________________________________________________________________________________

______ASM_________________________________________________________________________________________________

Monitor (원하는 메모리 영역 보기)

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

#define MAX_PROGRAM_SIZE 0x10000 // 64k

typedef struct _context
{

int efl;
int eip;
int edi;
int esi;
int ebp;
int esp;
int ebx;
int edx;
int ecx;
int eax;

}context;

typedef struct _cmd
{
void *vpCmd;
void (*fP)(void);

}cmdmap;

void    hexaview(unsigned char *, unsigned int);
void    Printf_REG(context *);
void    STST(context *);
void    LDST(context *);
int       ASKY(void);
unsigned char MD(void *);   // Memory Display Function By Assembly
void    MM(void *, char);  // Memory Modify Function By Assembly
void    Viewer(void);
void    Code_View(void);
void    Data_View(void);
void    Stack_View(void);
int      My_strcmp(void *, void *);
void    Quit(void);

static unsigned char ucMem[MAX_PROGRAM_SIZE*2];
//static unsigned char *ucpMem;
static unsigned char *ucpMem_end;
static unsigned char *ucpCode;
static unsigned char *ucpData;
static unsigned char *ucpStack;

cmdmap stCmd_List[] = {

        { "CODE"   ,  Code_View },
        { "DATA"    ,  Data_View   },
       { "STACK" ,  Stack_View },
        { "Q"         , Quit            },
        { 0             ,   0               }

};

int main()
{

context stReg = {0,};
int A = 0x12345678;

ucpMem_end              = ucMem+(MAX_PROGRAM_SIZE*2);
(unsigned int)ucpCode = ((unsigned int)(ucMem+MAX_PROGRAM_SIZE)& 0xFFFF0000);
ucpData                      = ucpCode + 0x2000;
ucpStack                 = ucpCode + MAX_PROGRAM_SIZE;

printf("Mem : %08X\n", ucMem);
printf("CODE : %08X\n", ucpCode);
printf("DATA : %08X\n", ucpData);
printf("STACK: %08X\n", ucpStack);

while(1)
{
Viewer();
}

printf("EAX Return : %d\n", ASKY());
printf("MD : 0x%X\n", MD(&A));

MM( &A, 0xFF);

printf("MM : 0x%X\n", A);

//hexaview((unsigned char *)&A, 160);

Printf_REG(&stReg);

STST(&stReg);
Printf_REG(&stReg);

getchar();

LDST(&stReg);
printf("Kernel panic\n");
*/

return 0;

}

void Printf_REG(context *stpReg)
{
printf("___________________________________________________\n\n");
printf(" EAX : 0x%08X  ECX : 0x%08X \n", stpReg->eax, stpReg->ecx);
printf(" EDX : 0x%08X  EBX : 0x%08X \n", stpReg->edx, stpReg->ebx);
printf(" ESP : 0x%08X  EBP : 0x%08X \n", stpReg->esp, stpReg->ebp);
printf(" ESI : 0x%08X  EDI : 0x%08X \n", stpReg->esi, stpReg->edi);
printf(" EIP : 0x%08X  EFL : 0x%08X \n", stpReg->eip, stpReg->efl);
printf("___________________________________________________\n\n");
}

void hexaview(unsigned char *ucP, unsigned int iSize)
{

int iCnt;
int iLoop;
int iRemainder;

printf("------------------------------------"
    "-------------------------------------\n");
printf("Address                       Hexa"
    "                            ASCII \n");
printf("         ");

for(iCnt = 0; iCnt < 16; ++iCnt )
{
  printf("%02X ", iCnt);
}
putchar('\n');

printf("------------------------------------"
    "-------------------------------------\n");

/*
if( 0 == iSize%16 )
{
  iSize = iSize/16;
}
else
{
  iSize = (iSize/16)+1;
}
*/
if(0 == iSize)
{
  return;
}
else
{
  iRemainder = iSize%16;
  iSize = iSize/16;
}

for( iLoop = 0 ;iLoop < iSize; ++iLoop)
{
  printf("%08X ", ucP);     //주소 출력

  for(iCnt = 0; iCnt < 16; ++iCnt )
  {
   printf("%02X ", MD(ucP+iCnt)); //hexa값 출력
  }

  for(iCnt = 0; iCnt < 16; ++iCnt )   //아스키코드 값 출력
  {
   if(0 == MD(ucP+iCnt))
   {
    printf(".");
   }
   else if(32 > MD(ucP+iCnt))
   {
    printf(".");
   }
   else if(127 < MD(ucP+iCnt))
   {
    printf(".");
   }
   else
   {
    printf("%c", MD(ucP+iCnt));
   }
  }

putchar('\n');
ucP = (ucP + 16);

}

if(0 == iRemainder)
{
  printf("------------------------------------"
    "-------------------------------------\n");
  return;
}
printf("%08X ", ucP);     //주소 출력

for(iCnt = 0; iCnt < iRemainder; ++iCnt )
{
  printf("%02X ", MD(ucP+iCnt)); //hexa값 출력
}

for(iCnt = 0; iCnt < (16-iRemainder); ++iCnt ) //빈자리 공백으로 ...
{
printf(" ");
}

for(iCnt = 0; iCnt < iRemainder; ++iCnt )   //아스키코드 값 출력
{
  if(0 == MD(ucP+iCnt))
  {
   printf(".");
  }
  else if(32 > MD(ucP+iCnt))
  {
   printf(".");
  }
  else if(127 < MD(ucP+iCnt))
  {
   printf(".");
  }
  else
  {
   printf("%c", MD(ucP+iCnt));
  }
}
putchar('\n');
printf("------------------------------------"
    "-------------------------------------\n");

}

void Viewer(void)
{

unsigned char ucBuff[31];
int iRet;
unsigned int uiCnt;

cmdmap *stpCmd = stCmd_List;

printf("명령어를 입력하시오!\n");
iRet = read(0, ucBuff, 30); // 명령어를 입력받음
ucBuff[iRet-1] = 0;

uiCnt = 0;
while(0 != ucBuff[uiCnt])
{

   if('z' >= ucBuff[uiCnt])
   {
          if('a' <= ucBuff[uiCnt] )   // 입력받은 값이 소문자라면...
          {
              ucBuff[uiCnt] = ucBuff[uiCnt] -32;

              //알파벳 소문자 값에서 32를 빼서 대문자로 바꿔줌
          }
}
   ++uiCnt;

}

while(1)
{

  if( 0 == stpCmd->fP)
  {
       break;
  }

  if(0 == strcmp(stpCmd->vpCmd, ucBuff ) ) //명령어와 멤버값이 일치하면...
  {
       (stpCmd->fP)(); //해당함수 호출
       break;
  }

  ++stpCmd;

}

void Code_View(void)
{
hexaview(ucpCode, 160); // 코드영역을 헥사뷰로 출력
}

void Data_View(void)
{
hexaview(ucpData, 160);// DATA영역을 헥사뷰로 출력
}

void Stack_View(void)
{
hexaview(ucpStack-159, 160);// 스택영역을 헥사뷰로 출력
}

void Quit(void)
{
printf("프로그램을 종료합니다.\n");
exit(0);//q 입력받으면 종료
}