20151020 엄민웅 armCortex3 TIM, asm MEMORY_MODIFY

arm Cortex3 수업

PA0 의 LED는 인터럽트 방식으로 1초마다 깜빡 거리고, PC12의 LED는 폴링 방식으로 5초마다 깜빡 거리는 프로그램.

#include <stm32f10x.h>
 
unsigned short TimeValue;
 
void  TIM2_IRQHandler(void)
{
    if(TIM_GetITStatus(TIM2,TIM_IT_Update) != RESET)
    {
        // Timer Interrupt 가 처리하는 내용
        GPIOA->ODR ^= (uint32_t)0x01;
        
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update); // Clear the interrupt flag
        TimeValue++;
    }
}
 
void Delay_s(unsigned short T)
{
    TimeValue = 0;
    while(T > TimeValue);
}
 
void PA0_out(void)
{
    /* Configure all the GPIOA in Input Floating mode */
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
}
 
 
void PC12_out(void)
{
    /* Configure all the GPIOA0 in Input Floating mode */
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
}
 
void TIM2_init(void)
{
    /******************************************************************/
    /* TIM2CLK = 72 MHz( APB1은 원래 36MHz 인데 분주를 해서 사용하므로 */
    /* 36*2 = 72MHz 가 된다. )                                                                  */
    /* 시간의 기본단위 :S(초)-->nS.uS.mS.S.                                              */
    /* 72000000/60000=1200 즉 1초에 1200번 클럭이 발생하므로  ARR       */
    /* 레지스터를 1199+1 번에 한번 인터럽트가 발생하도록 설정하면 1초에      */
    /* 한번 인터럽트가 발생된다.                                                              */
    /******************************************************************/
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    
    /* TIM2 Initialize */   
    TIM_TimeBaseStructure.TIM_Period = (1200-1); 
    TIM_TimeBaseStructure.TIM_Prescaler = (60000-1);
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM2,&TIM_TimeBaseStructure);
}
 
void NVIC_init(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    /* Enable TIM2 global interrupt with Preemption Priority 0 and Sub Priority as 2 */
    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}
 
int main(void)
{
    // 사용할 기능 : GPIOA0, TIM2
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA| RCC_APB2Periph_GPIOC, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    PA0_out();
    PC12_out();
    TIM2_init();
    NVIC_init();
    
    TIM_Cmd(TIM2, ENABLE);        // Timer 활성화
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);    // Timer Interrupt 활성화
    
    while(1)
    {
        // PC12에  연결된 LED를 5초 간격으로 깜빡이게 하고, 
        //PA0에 연결된 LED를 1초 간격으로 깜빡이는 프로그램을 작성 하시오.
        
        GPIOC->ODR ^= (uint32_t)0x1000;
        Delay_s(5);
    }
}

오후 수업.

p78 자바형식

자바는 클래스 기반으로 만들기 때문에 클레스를 무조건 만들어야 한다

자바도 앤트리 포인트가 메인함수이다.

ex) 자바 기본틀 (파일 이름 smart.java)

class smart

{

public static void main(void)

{

System.out.println("Test");

}

}

클래스 밖에 메소드를 선언하면 애러

접근 가능하도록 public을 써야 하고, 객체를 생성 안했는데 메인함수를 써야 하니까 static을 써야 한다.

javac smart.java 이렇게 컴파일 하면 smart.class 파일 생성되고,

java smart.class 이렇게 실행 하면 된다.

옛날 방식 요즘엔 이클립스를 쓴다고 한다. (비주얼스튜디오처럼, 우리가 처음부터 비주얼 스튜디오만 썼으면 cl 이런거 몰랐을 것이다.)

p.100

실행할때 컴파일 되는 언어를 인터프리터 언어 ex)파이션

p114. 파이션 LED PWM 코딩 실습 

어셈블리 수업 

금일 실습 전체 소스코드 (MEMORY_MODIFY 추가)

#include<stdio.h>
#include<string.h>
 
#define CMDSIZE 20
#define MAX_PRG_SIZE (64*1024)
#define MEMSIZE (MAX_PRG_SIZE*2)
#define MASK_CODE 0xFFFF0000
 
typedef struct _CONTEXT
{
    unsigned int efl;
    unsigned int eip;    
    unsigned int edi;
    unsigned int esi;
 
    unsigned int ebp;
    unsigned int esp;
    unsigned int ebx;
    unsigned int edx;
    unsigned int ecx;
    unsigned int eax;
 
} CONTEXT;
 
typedef struct _comn
{
    char *cpCmd;
    void (*fp)(void);
 
} COMN;
 
 
//전역변수 선언 위치
static CONTEXT old_state;
void *vpMEM_start;
void *vpMEM_end;
void *vpCODE;
void *vpDATA;
void *vpSTACK;
 
 
void STST(CONTEXT *);
void LDST(CONTEXT *);
void hexaview(void * vP, unsigned int uiLen);
void PRINT_R(void);
void MEMORY_CLEAR(void);
void MEMORY_MODIFY(void);
void PRINT_ADDRESS(void);
void LOAD(void);
void VIEW_CODE(void);
void VIEW_DATA(void);
void VIEW_STACK(void);
void PRINT_HELP(void);
void PRO_QUIT(void);
 
 
 
COMN stCmd_map[] = {
        {"R", PRINT_R},
        {"P", PRINT_ADDRESS},
        {"MC", MEMORY_CLEAR},
        {"MM", MEMORY_MODIFY},
        {"LOAD", LOAD},
        {"CODE", VIEW_CODE},
        {"DATA", VIEW_DATA},
        {"STACK", VIEW_STACK},
        {"H", PRINT_HELP},
        {"Q", PRO_QUIT},
        {"QUIT", PRO_QUIT},
        {NULL, 0}
    }; //메시지 맵 기법
 
 
 
int main()
{
    char cInput[CMDSIZE];
    int iRet;
    int iCnt;
    COMN *stpCmd;
 
    if(0 == (vpMEM_start = (void *)malloc(MEMSIZE)) )
    {
        return 0;
    }
    
    vpCODE =  (void*) ( ( (int)vpMEM_start & MASK_CODE) + MAX_PRG_SIZE) ;
    vpMEM_end = (void*)( (int)vpMEM_start + MEMSIZE - 1) ;
    vpDATA = (void *)( (int)vpCODE + 0x2000);
    vpSTACK = (void *)( (int)vpMEM_end - (16*16)+1);
 
    STST(&old_state); // push &old_state . call _STST
    
    printf("Moniter Program Start! \n");
    
    while(1)
    {
        putchar('>');
        iRet = read(0, cInput, CMDSIZE);
        if(1 == iRet)
        {
            continue;
        }
        cInput[iRet - 1] = 0;
        //printf("%s", cInput);
        
         //소문자를 대문자로 변경
        for(iCnt = 0; iCnt < iRet-1; iCnt++)
        {
            if(cInput[iCnt] >=97 &&cInput[iCnt] <= 122)
            {
                cInput[iCnt] -= 32;
            }
        }
        
        stpCmd = stCmd_map;
        while(0 != (stpCmd->fp))
        {
            if(0 == strcmp(cInput, stpCmd->cpCmd))
                break;
            
            ++stpCmd;
        }
        
        if(0 != stpCmd->fp)
        {
            (stpCmd->fp)();
            putchar('\n');
        }
        else
        {
            PRINT_HELP();
            putchar('\n');
        }
 
        
    }
 
 
 
    return 0;
}
 
 
void hexaview(void * vP, unsigned int uiLen)
{
    unsigned int uiCnt, uiLine;    
    
    printf("============================================================================\n");
    printf("  Address                     Hexa                             ASCII        \n");
    printf("----------------------------------------------------------------------------\n");    
    
    for (uiLine = 0 ; uiLine < uiLen ; uiLine = uiLine + 16)
    {
        printf(" %08X  ", vP);
 
        for (uiCnt = 0; uiCnt < 16; uiCnt++)
        {
            printf("%02X ", *((unsigned char *)vP));
            vP = (char *)vP + 1;
        }
        putchar(' ');
 
        vP = (char *)vP - 16;
        for (uiCnt = 0; uiCnt < 16; uiCnt++)
        {
            if (32 > *((unsigned char *)vP)) // space 는 아스키 코드로 32
            {
                putchar('.'); 
            }
            else if (127 < *((unsigned char *)vP)) 
            {
                putchar('.');
            }
            else
            {
                printf("%c", *((unsigned char *)vP));
            }
 
            vP = (char *)vP + 1;
        }
        putchar('\n');
    }
 
    return;
}
 
 
void PRINT_R(void)
{
    printf("eax [%08X]\t", old_state.eax);
    printf("ebx [%08X]\n", old_state.ebx);
    printf("ecx [%08X]\t", old_state.ecx);
    printf("edx [%08X]\n", old_state.edx);
 
    printf("esi [%08X]\t", old_state.esi);
    printf("edi [%08X]\n", old_state.edi);
 
    printf("ebp [%08X]\t", old_state.ebp);
    printf("esp [%08X]\n", old_state.esp);
    printf("eip [%08X]\t", old_state.eip);
 
    printf("efl [%08X]\n", old_state.efl);
 
    return;
}
 
void MEMORY_CLEAR(void)
{
    memset(vpMEM_start, 0x00, MEMSIZE);
 
    return;
}
 
void MEMORY_MODIFY(void)
{
    unsigned int uiADD;
    unsigned int uiVal;
    
    while(1)
    {
        printf("메모리 주소를 입력하세요 (%d ~ %d) : ", vpMEM_start, vpMEM_end);
        scanf("%x", &uiADD);
        fflush(stdin);
        if( uiADD < (unsigned int)vpMEM_start)
        {
            printf("출력할 수 없는 주소 공간입니다. 다시 입력 하십시오.\n");
            continue; 
        }
 
        if( uiADD > (unsigned int)vpMEM_end)
        {
            printf("출력할 수 없는 주소 공간입니다. 다시 입력 하십시오.\n");        
            continue; 
        }
 
        break;
    }
 
    
    hexaview((void *)uiADD, 16);
    putchar('\n');
 
    printf("변경하고 싶은 값(16진수)을 입력하세요 : ");
    scanf("%x", &uiVal);
    fflush(stdin);    
 
    *((unsigned int*)uiADD) = uiVal;
 
    putchar('\n');
    hexaview((void *)uiADD, 16);
 
    
    return;
}
 
void PRINT_ADDRESS(void)
{
    //printf("Code Start Address : [%08X]\n", vpCODE);
    
    printf("Dynamic Memory area : [%08X] ~ [%08X] <%d KBytes>\n", vpMEM_start , vpMEM_end, ((int)vpMEM_end-(int)vpMEM_start+1)/1024 );
    return;
}
 
void LOAD(void)
{
    memset(vpCODE, 0xFF, 16*16);
    memset(vpDATA, 0xEE, 16*16);
    memset(vpSTACK, 0xDD, 16*16);
    
    return;
}
 
void VIEW_CODE(void)
{
    hexaview(vpCODE, 16*16);
    return;
}
 
 
void VIEW_DATA(void)
{
    hexaview(vpDATA, 16*16);
    return;
}
 
void VIEW_STACK(void)
{
    hexaview(vpSTACK, 16*16);
    return;
}
 
void PRINT_HELP(void)
{
    printf("R    : Register Value Display\n");
    printf("P    : Memory Status Display\n");
    printf("MC    : Memory Clear\n");
    printf("LOAD    : Program Load\n");
    printf("CODE    : Code Area Display\n");
    printf("DATA    : Data Area Display\n");
    printf("STACK    : Stack Area Display\n");    
    printf("H    : Help Message Display\n");
    printf("QUIT(Q)    : Exit Program\n");
    return;
}
 
void PRO_QUIT(void)
{
    free(vpMEM_start);
    exit(0);
    return;
}
 

mm실습 결과 화면