[내장형]이동현_7월14일_일일보고서

◎임베디드 C

◇연결 리스트

 □read()/write() 복습

▷read(int fd, char *buffer, int size);

▷write(int fd, char *buffer, int size);

첫 번째 인자는 파일을 가르키는 디스크립터 나타낸다. 두 번째 인자는 읽거나 기록할 데이터의 주소를 불러온다. 세 번째 인자는 크기를 나타낸다.

☆node.h파일

※if에 0을 넣게 되면 양방향 연결리스트를 사용하고, if에 1을넣으면 단방향이다. 1을 넣어서 단방향으로 하였다.

☆저수준을 이용한 쓰기모드 파일을 생성하기

#include<stdio.h>
#include<fcntl.h>  //oflag 사용
#include<sys/types.h> //pmode 사용
#include<sys/stat.h>  //pmode 사용
#include"node.h"

int main()
{
  int ifd,icount;
  NODE sttemp;
  
  ifd = open("a.dat",O_CREAT|O_WRONLY|S_IWRITE|O_TRUNC);
  if(ifd<0)
  {
    printf("Can't open file a.dat\n");
    exit(-1);
  }
  for(icount = 0; icount < 5; icount++)
  {
    printf("값을 입력하시오 : ");
    scanf("%d",&sttemp.iNum);
    write(ifd,&sttemp.iNum,sizeof(sttemp));
  }
  close(ifd);
  return 0;

<결과>

 

※a.dat파일을 Hexaview로 뿌리면 little endian으로 들어 가 있는 값들이 보인다. 여기서 40147EC0는 Next 포인터의 값인데 의미가 없어서 쓰레기값이다. 총41바이트가 사용되는데 1바이트는 개행문자‘\n'이기 때문에 40바이트를 사용한다고 보면된다.

☆저수준을 이용한 읽기모드로 열어서 연결리스트 만들기

 

#include<stdio.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<stdlib.h>
#include"node.h"

int main()
{
  int ifd,icount;
  NODE stp_temp, *stp_node,*stp_head;
  int iret;
  

  ifd = open("a.dat",O_RDONLY);
  if(ifd <0)
  {
    printf("Can't open file a.dat\n");
    exit(-1);
  }
  stp_node =(NODE *) malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next = 0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  if(iret != 0)
  {
    stp_head = stp_node;
  }
  

//=1st================================================================
  stp_node = (NODE *)malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next =0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  else
  {
    stp_node ->next = stp_head;
    stp_head = stp_node;
  }

//=2st================================================================
  stp_node = (NODE *)malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next =0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  else
  {
    stp_node ->next = stp_head;
    stp_head = stp_node;
  }
    
//=3st================================================================
  stp_node = (NODE *)malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next =0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  else
  {
    stp_node ->next = stp_head;
    stp_head = stp_node;
  }
//=4st================================================================
  stp_node = (NODE *)malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next =0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  else
  {
    stp_node ->next = stp_head;
    stp_head = stp_node;
  }  
//=5st================================================================
  stp_node = (NODE *)malloc(sizeof(NODE));
  if(stp_node == 0)
  {
    perror("stp_node error");
    exit(-1);
  }
  iret = read(ifd,&stp_temp,sizeof(NODE));
  stp_node->next =0;
  if(iret == 0)
  {
    free(stp_node);
    printf("iret error\n");
    exit(-1);
  }
  else
  {
    stp_node ->next = stp_head;
    stp_head = stp_node;
  }
  close(ifd);
  return 0;
}

※malloc함수를 이용하여 stp_node크기를 동적할당을 받는다.

◎ARM

 

#define PIOA_PER  (*(volatile unsigned int *)0xFFFFF400)
#define PIOA_OER  (*(volatile unsigned int *)0xFFFFF410)
#define PIOA_PPUDR  (*(volatile unsigned int *)0xFFFFF460)
#define PIOA_CODR  (*(volatile unsigned int *)0xFFFFF434)  //clear output data register
#define PIOA_SODR  (*(volatile unsigned int *)0xFFFFF430)  //set output data register

#define CLCD_RS (1<<8)//0x100
#define CLCD_RW (1<<9)//0x200
#define CLCD_EN (1<<10)//0x400
#define CLCD_BS (0xFF<<16)//0xFF0000
#define CLCD_INST_CD (0x01<<16) //Clear Display
#define  CLCD_DELAY for(icount =0; icount  < 1000000;icount++)
void OUT_INIT(void)
{
  // Configure the pin in output 핀들은 ARM에 내보내는 출력용으로 사용
  PIOA_OER = CLCD_BS |CLCD_EN|CLCD_RS|CLCD_RW;
  // Set the PIO controller in PIO mode instead of peripheral mode 핀사용을 할것인가 말것인가
  PIOA_PER = CLCD_BS |CLCD_EN|CLCD_RS|CLCD_RW;
  // Disable pull-up 풀업을 off
  PIOA_PPUDR  = CLCD_BS |CLCD_EN|CLCD_RS|CLCD_RW;
}

int main(void)
{  
  volatile unsigned int icount;
  OUT_INIT();

    
  PIOA_CODR =CLCD_EN;   //LCD 비활성화
  PIOA_CODR = CLCD_RS;  //명령 레지스터를 선택
  PIOA_CODR = CLCD_RW;  //write선택
  CLCD_DELAY;           //최소 40ns 시간 지연
  PIOA_SODR = CLCD_EN;  //LCD 활성화
  CLCD_DELAY;           //최소 230ns 의 시간 지연
  PIOA_SODR = CLCD_INST_CD; //bus에 화면을 지우라는 명령이 들어간다.
  PIOA_CODR =CLCD_EN;   //다시 LCD 비활성화
  CLCD_DELAY;

  while(1);
  return 0;
}

※delay 40ns는tsu1은 쓰기위해서 최소한 40ns 이상의 시간을 기다린다.

※delay 230ns유지는  Enable이 high에서 최소 230ns(nano second)를 유지해야된다.

 

◎Network

 ◇fork()

  프로세스가 fork 함수를 만나면 현재 실행 중인 프로세스의 이미지를 그대로 복사해서 새로운 프로세스를 만든다. 프로세스의 이미지를 복사한다는 의미는 프로세스의 코드 부분은 물론, 전역변수, 지역변수 등 모든 실행 환경을 그대로 복사하는 것을 말한다. 이때 새로 생성된 프로세스를 자식 프로세스라 하고, fork 함수를 호출해서 자식 프로세스를 생성하는 프로세스를 부모 프로세스라고 한다.

 
부모와 자식 프로세스 간에 유일하게 다른 부분이 있다면 fork 함수를 호출하고 그 결과를 반환 받는 변수이다.

pid_t pid

pid = fork(void);

fork 함수가 복사하는 이미지에는 변수 pid도 포함된다. 그런데 fork 함수의 반환 값은 부모 프로세스와 자식 프로세스가 서로 다르다. 그래서 부모 프로세스의 변수 pid에는 자식 프로세스의 식별자가 저장되고, 자식 프로세스의 변수 pid에는 0이 저장된다.

 하나의 프로그램으로 부모 프로세스와 자식 프로세스의 역할을 모두 구현해야한다. 때문에 프로세스에서 fork 함수를 호출한 후 반환되는 값을 보고 현재 프로세스가 부모 프로세스의 역할을 해야 하는지, 자식 프로세스의 역할을 해야 하는지를 구분하는 코딩이 필요하다.

pid_t pid;

pid = fork();

if(pid >0)

{

     //부모 프로세스가 실행하는 코드

}

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

else if(pid == 0)

{

     //자식 프로세스가 실행하는 코드

}

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

else if(pid == -1)

{

     //오류 발생에 대비하는 코드

}

=====================================
※fork()는 부모와 자식 메모리 공간은 별개로 존재한다. 데이터가 들어 있는 메모리 공간만 복사된다.

※ 프로그램 ┒

    소켓    ┡ 공유 (복사 x)

    파일    ┙

※fork()를 선언하기 전에 부모프로세서의 PID는 쓰레기값이 들어있다.

※PID로 부모와 자식 프로세스를 구분한다.

☆fork()

#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

int global_var = 0; //전역 변수 선언

int main()
{
  pid_t ret,child;
  int local_var = 0;  //지역 변수 선언

  ret = fork();
  if(ret < 0)
  {
    printf("fork() error");
    exit(1);
  }
  else if(ret == 0) 
  {
    global_var++;
    local_var++;
    printf("Child - my PID : %d parent's PID : %d\n",getpid(),getppid());
  }
  else 
  {
    sleep(10);   //테스트를 위한 10초대기

    global_var += 5;
    local_var += 5;
    printf("PARENT - my PID  %d child's PID : %d\n",getpid(),ret);
  }
  printf("\t global_var : %d\n",global_var);
  printf("\t local_var : %d\n", local_var);

  return 0;
}

<결과>

※자식프로세서에서 부모 PID값은 return 값을 나타낸 것이다.

※getpid()는 자신의 pid를 호출.

※getppid()는 부모 프로세서pid를 알고 싶을 때 사용(현재 실행중인 프로세스의 부모 pid)

※실행파일의 프로세스 상태를 보려면 ‘파일명 &ps -u’ 명령을 실행한다.

☆./fork_test &ps -u 명령 사용

※STAT에서 Z는 좀비 프로세서이다. 좀비 프로세서는 자식프로세서에서 발생. 

 

♧좀비 프로세스
- 프로세스 종료 후 메모리상에서 사라지지 않은 프로세스 

♧좀비 프로세스 생성 이유
- 자식 프로세스가 종료하면서 반환된 값 0을 커널이 부모 프로세스에 전달한 후 자식 프로세스를 소멸시킴. - 반환값을 부모 프로세스에 전달하지 못한 경우 자식 프로세스는 좀비로 존재.
- 부모 프로세스가 커널에게 종료된 자식 프로세스의 리턴값을 전달 요청을 해야만 커널이 리턴값 전달 가능함

 

♧종료된 자식 프로세스의 리턴값 요청 함수 

 -wait함수

 

※성공시 종료된 자식 프로세스 ID, 실패시 -1 리턴

- status : 포인터 status가 가리키는 변수에 자식 프로세스 종료시 리턴하거나 exit 함수 호출시 전달한 인자값이 저장됨
- 매크로함수 WEXITSTATUS(status)로 종료시 리턴값이나 exit() 인자로 넘겨진 값 확인
- 호출 시점에 종료된 자식 프로세스가 없으면 blocking 상태에 빠짐

☆wait함수를 이용한 fork프로그램

#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

int global_var = 0; //전역 변수 선언

int main()
{
  pid_t ret,child;
  int local_var = 0;  //지역 변수 선언
  int state;

  ret = fork();
  if(ret < 0)
  {
    printf("fork() error");
    exit(1);
  }
  else if(ret == 0) 
  {
    global_var++;
    local_var++;
    printf("Child - my PID : %d parent's PID : %d\n",getpid(),getppid());
  }
  else  
  {

    global_var += 5;
    local_var += 5;
    printf("PARENT - my PID  %d child's PID : %d\n",getpid(),ret);
  
    child = wait(&state); 
    printf("\n child PID = %d \n",child);
    printf("\t return value : %d \n",WEXITSTATUS(state));

    sleep(10);  //좀비 프로세스 있는지 확인할 시간벌기 위한 대기
  }
  printf("\t global_var : %d\n",global_var);
  printf("\t local_var : %d\n", local_var);

  return 0;
}

<결과>

※좀비 프로세서가 사라진 것을 볼 수 있다!!