출처 : http://blog.naver.com/yongun24/10084551633

[MySQL 접속하기]
자신의 PC에서 MySQL 접속하기 : 
MySQL DB Server 접속은 MySQL의 명령어로 접속이 가능합니다.
접속하는 PC에 MySQL Client가 설치 되어 있지 않다면 http://www.mysql.com에서 받아서 운영체제에 맞는 것을 먼저 설치하여야 합니다.

가이드라인 서버에서 MySQL 접속하기 : 
Telnt,SSH로 서버 접속 후에 MySQL Client을 따로 설치 하실 필요 없이 바로 MySQL 접속 명령어로 MySQL DB Server로 접속이 가능합니다.

MySQL 접속 명령어 : 
mysql -hDB서버명 -uMySQL아이디 -pMySQL패스워드 데이타베이스명

MySQL 계정정보를 모른다면 [My Setting]에서 다시 확인 하세요.

[MySQL 백업하기]
가이드라인 홈페이지에서 백업 받기 : [My DB] 메뉴에서 웹에서 직접 백업을 받을 수 있습니다.

*MySQL 서버에 접속 하는 것이 아니라 Telnet으로 자신의 서버 계정으로 접속 후 백업 받고자 하는 폴더로 이동, 명령어 실행하시면 됩니다.

ex)

C:\Program Files\MySQL\MySQL Server 5.1\bin>mysqldump -uroot -proot123 FTA > FTA.sql

MySQL 명령어로 백업받기 : 
mysqldump -hDB서버명 -u유저명 -p패스워드 [백업할 테이터베이스명] > [저장할 파일명]
ex) mysqldump -hdb1.guideline.co.kr -uDBuser -pPassword MyDB > MyDB.sql 

특정 테이블만 백업 할 경우 : 
mysqldump -hDB서버명 -u유저명 -p패스워드 [테이타베이스명] [특정테이블명] > [저장할 파일명]
ex) mysqldump -hdb1.guideline.co.kr -uDBuser -pPassword MyDB MyTable > MyDB_MyTable.sql 

[MySQL 복구하기]
mysql -hDB서버명 -u유저명 -p패스워드 [복구할 테이터베이스명] < [저장된 파일명]
ex) mysql -hdb1.guideline.co.kr -uDBuser -pPassword MyDB < MyDB.sql 


[MySQL 패스워드변경] [MyDB] 메뉴에서 직접 변경 가능합니다.

가이드라인은 DB 서버와 WEB 서버를 분리해서 운영중이므로 반드시 DB 서버명을 꼭 입력하셔야 합니다.

[MySQL 공식 홈페이지] http://www.mysql.com
[MySQL Reference Manual] http://dev.mysql.com/doc/



[MySQL 테이블이 깨진 경우 복구 하는 방법]
MySQL 서버에 접속한 이후에 깨진 테이블명을 repair 명령어로 복구한다.
mysql> repair table 테이블명

[상위 버전으로 mysqldump시 한글이 깨어진다면]

  • MySQL 5.x 버전에 수록된 MySQL dump 10.x 버전 경우에는 mysqldump 시에
    한글문자 지정하는 옵션도 있습니다.(--default-character-set=euc_kr or euckr)

    가이드라인 DB 서버의 charset은 euc_kr 입니다.
    mysqldump -hDB서버명 -u유저명 -p패스워드 --default-character-set=euc_kr [백업할 테이터베이스명] > [외부로 저장할 파일명]
    직접 복구 해야할 DB 서버의 문자셋 확인 방법은 
    MySQL 접속을 하신 후에
    show variables like '%char%';
    명령어로 확인이 가능합니다.

    참조) mysql 버전 및 charset이 다른 경우는 설정을 확인 해 보셔야 합니다.
    예를들어서 mysql 5.x 버전으로 default-character-set=euckr 으로 되어 있을 수도 있습니다.



    * MySQL 테이블명 변경 방법
    명령어 : ALTER TABLE 테이블명 RENAME 새로운 테이블명;
    mysql>ALTER TABLE old_tablename RENAME new_tablename;
    ex)ALTER TABLE guideline rename new_guideline;

    컬럼 속성 수정
    명령어 : ALTER TABLE tablename MODIFY 컬럼이름 컬럼속성
    mysql> ALTER TABLE tablename MODIFY colname INT NOT NULL AUTO_INCREMENT 

    컬럼 이름 바꾸기
    mysql> ALTER TABLE tablename CHANGE colname newcolname INT NOT NULL AUTO_INCREMENT;

    컬럼 추가
    명령어 : ALTER TABLE tablename ADD 컬럼이름 컬럼속성
    mysql>ALTER TABLE bbs ADD name varchar(10);

    특정 컬럼 뒤에 새로운 컬럼 추가
    mysql> ALTER TABLE tablename ADD newcol varchar(10) AFTER num;

    컬럼 삭제
    mysql> ALTER TABLE tablename DROP colname;

    기존 컬럼을 지우고 맨 앞에 컬럼 추가
    mysql>ALTER TABLE tablename DROP newcol, ADD newcol VARCHAR(10) FIRST;

    PRIMARY KEY 속성 삭제
    mysql>ALTER TABLE test DROP PRIMARY KEY;

    테이블의 내용 전체 삭제
    mysql>TRUNCATE TABLE tablename;
    ;간략 추가 설명
    오라클에서 사용 SQL 확장으로 
    MySQL 5.0.3 버전 이전 경우는 DELETE문과 차이는 없습니다.
    MySQL 5.0 버전에는 차이가 있습니다. 트랜젹션 되지 않아 복구 불가능합니다.


  •    윈도우 기반 직렬통신

     윈도우 기반 직렬 통신을 위해 먼저 Virtual Serial Port Driver 프로그램을 설치했다. 크로스 연결된 2개의 가상 포트를 생성할 수 있다.

     



    설정이 끝나고 장치관리자를 보면 위와 같이 뜬다.

     직렬 통신 절차


     송신 프로그램
    #include <stdio.h>
    #include <iostream>
    #include <windows.h>
    using namespace std;

    int main(void)
    {
      char szPort[15];

      wsprintf(szPort, "COM%d"2);

      HANDLE m_hComm = NULL;
      m_hComm = CreateFile(szPort,
                GENERIC_READ | GENERIC_WRITE,
                0, NULL, OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL, NULL);    // 통신 포트 열기
      
      if(m_hComm == INVALID_HANDLE_VALUE)
      {
        printf("(!) Failed to create a Comm Device file");
        return FALSE;
      }
      DCB dcb;
      dcb.DCBlength = sizeof(DCB);

      GetCommState(m_hComm, &dcb);  // 기본 통신 상태 읽기

      // 통신 속도 상태 설정
      dcb.BaudRate = 9600;
      dcb.ByteSize = 8;
      dcb.Parity = 0;
      dcb.StopBits = 0;

      SetCommState(m_hComm, &dcb);

      // 통신 이벤트 객체 생성
      OVERLAPPED osWrite;
      osWrite.Offset = 0;
      osWrite.OffsetHigh = 0;
      osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

      char buf[100= "Hello world \r\n";
      while(1)
      {
        cout << "Input : ";
        cin >> buf;
        printf("send:%s\n", buf);
        WriteFile(m_hComm, buf, strlen(buf), NULL, &osWrite);  // 데이터 전송

        if((buf[0== '-'&& (buf[1== '1'))
          break;
        //Sleep(1000);
      }
      CloseHandle(m_hComm);

      return 0;
    }

     수신 프로그램
    #include <stdio.h>
    #include <windows.h>
    #include <iostream>
    using namespace std;

    int main(void)
    {
      char szPort[15];

      wsprintf(szPort, "COM%d"3);

      HANDLE m_hComm = NULL;
      m_hComm = CreateFile(szPort,
                GENERIC_READ | GENERIC_WRITE,
                0, NULL, OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL, NULL);  // 통신 포트 열기
      
      if(m_hComm == INVALID_HANDLE_VALUE)
      {
        printf("(!) Failed to create a Comm Device file");
        return FALSE;
      }
      DCB dcb;
      dcb.DCBlength = sizeof(DCB);

      GetCommState(m_hComm, &dcb);  // 기본 통신 설정 상태 읽기

      // 통신 속도 상태 설정
      dcb.BaudRate = 9600;
      dcb.ByteSize = 8;
      dcb.Parity = 0;
      dcb.StopBits = 0;

      SetCommState(m_hComm, &dcb);

      // 통신 이벤트 객체 생성
      OVERLAPPED osRead;
      osRead.Offset = 0;
      osRead.OffsetHigh = 0;
      osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

      DWORD size;
      char buf[100];
      while(1)
      {
        ReadFile(m_hComm, buf, 100&size, &osRead);  // 데이터 수신
        buf[size] = '\0';
        printf("recv:%s\n", buf);
        if((buf[0== '-'&& (buf[1== '1'))
          break;
      }
      CloseHandle(m_hComm);

      return 0;
    }
    // COM2, COM3는 가상 포트로 두 포트는 연결되어 있는 상태이다.
    // 송신 프로그램에서 전송할 문자를 입력한 뒤 엔터를 치면 데이터를 전송한다.
    // -1를 입력하면 송신 프로그램 수신 프로그램 모두 종료 된다.



       A/D 컨버터(Analog Digital Converter)

     AT91SAM7S256은 8채널 10비트 또는 8비트 분해능의 축자비교형 A/D 컨버터를 가지고 있다. 각 채널의 입력은 내부의 아날로그 멀티플렉서에 의하여 선택되며, 이들 8채널의 아날로그 입력신호 중에서 AD0~AD3은 병렬 I/O 포트와 겸용으로 사용하고 있고, AD4~AD7은 전용핀을 가지고 있다.

     A/D 컨버터에서 사용하는 클럭의 주파수는 ADC_MR 레지스터의 PRESCAL 필드에 의하여 MCK/2/(PRESCAL+1)로 결정되므로 MCK/2 ~ MCK/128의 범위가 된다. 10비트 분해능을 사용할 때는 A/D 클럭으로 5MHz 이하를 사용해야 하며, 8비트 분해능을 사용할 때는 A/D 클럭으로 8MHz 이하를 사용해야 한다.
     각 채널에서 10비트 또는 8비트 분해능으로 A/D 변환을 수행하는데는 ADC_MR 레지스터에서 SHTIM 필드로 지정한 샘플/홀드에 필요한 클럭 주기와 10주기의 A/D 변환 클럭 사이클이 소요 된다. 샘플/홀드 시간은 최소 600ns 이상이 필요하다.
    ex) 10비트 분해능 5MHz 클럭에서 최소 3주기의 샘플/홀드 시간과 10주기의 A/D 변환 시간이 소요  
          : 최대 384kSPS(sampling/sec)
           8비트 분해능 8MHz 클럭에서 최소 5주기의 샘플/홀드 시간과 10주기의 A/D 변환 시간이 소요  
          : 최대 533kSPS(sampling/sec)

     A/D 컨버터에는 외부 단자 ADVREF를 통하여 기준전압이 공급되어야 한다. 이 기준전압은 2.6V ~ VDDIN의 범위를 가져야 하며, 이에 따라 각 채널에서의 아날로그 신호 입력의 범위는 0.0V ~ ADVREF로 결정된다.

     8비트 분해능을 사용할 경우에는 이중에서 하위 8비트만 유효하며 사용하지 않는 상위 2비트는 0으로 읽혀진다.

     A/D 컨버터가 변환을 완료하면 상태 레지스터 ADC_SR 에서 EOCx 비트와 DRDY 비트가 1로 세트된다. 사용자 프로그램으로 ADC_CDRx 레지스터를 읽으면 EOCx 비트는 0으로 클리어되며, ADC_LCDR 레지스터를 읽으면 EOCx 비트와 DRDY 비트가 모두 0으로 클리어 된다.

     새로운 A/D 변환이 왼료될 때까지 ADC_CDRx 레지스터에 저장되어 있는 이전의 A/D 변환 결과를 읽지 않으면 오버런 에러가 되고 ADC_SR 레지스터에서 대응하는 채널의 OVREx 비트가 세트된다. 마찬가지로 ADC_LCDR 레지스터를 읽지 않아 오버런 에러가 발생하면 ADC_SR 레지스터에서 GOVRE 비트가 세트된다. 이들 에러 비트는 ADC_SR 레지스터를 읽으면 자동으로 클리어된다.

     A/D 변환 트리거는 여러 개의 채널을 사용하더라도 오직 1번만을 필요로 한다. 즉 A/D 변환을 시작하도록 트리거하면 동작이 허용된 모든 채널에서 A/D 변환이 시작된다.

     A/D 컨버터를 슬립 모드로 하면 클럭의 공급을 차단하고 동작을 저지시킴으로써 소비전력을 크게 절약할 수 있다. A/D 컨버터가 슬립 모드에 있더라도 A/D 컨버터 내부의 로직 회로는 정상으로 동작하여 모든 I/O 레지스터의 액세스가 가능하다.

     // ADC 예제 소스
    #include "MyArm.h"

    //--------- Global Variable�

    void Delayms(unsigned int ms) //Delay Function..

      volatile unsigned int count, countmax = (MASTERCLOCK / 10000) * ms;

      for(count = 0; count < countmax; count++);
    }

    void DBGU_write(char *d)
    {
      while(0 != *d)
      {
        while(0 == (DBGU_SR & 0x0002));
        DBGU_THR = *d;
        ++d;
      }
    }

    void intToChar(char *buf, unsigned int num)
    {
      int i, j;
      int target;    // 각 자리수
      int value = 1;  // 숫자 크기 확인
      
      while(value <= num)
      {
        value *= 10;
      }  
      
      for(i = 0, j = value/10 ; j >= 10 ; j /= 10)
      {
        target = num / j;
        num = num % j;
        buf[i++] = target + 48;    // buf에 문자값 저장
      }
      buf[i++] = num + 48;
      buf[i] = '\0';
    }

    int main(void)
    {  
      unsigned int data;
      unsigned int tmp;
      char buf[10];
      
      DBGU_CR = (1 << P2) | (1 << P3);  // TX,RX reset & disable
      
      // PMC setting
      PMC_PCER = (1 << PID4);

      // PIO setting
      PIO_PDR = (1 << P10);
      PIO_ASR = (1 << P10);
      
      // DBGU setting
      DBGU_MR = (1 << P11);        // No Parity
      DBGU_BRGR = 313;          // Baud rate = 9600
      DBGU_CR = (1 << P6);        // TX enable
      
      // ADC setting
      ADC_MR = (23 << P8) | (1 << P4) | (1 << P24);  // PRESCAL = 23(1Mhz), 8 bit Low Resolution, SHTIM = 1
      ADC_CHER = (1 << P4);              // Channel 4

      while(1)
      {
        ADC_CR = (1 << P1);            // Start Conversion
        while(0 == (ADC_SR & (1 << P16)));
        data = ADC_LCDR;
        intToChar(buf, data);
        DBGU_write(buf);
        DBGU_write("\r\n");
        Delayms(50);
        tmp = ADC_SR;
      }
      
      return 0;
    // End Main...
    // 변환 값 입력에 가변저항을 연결하여 저항을 바꿔가면서 입력값에 변화를 준다.
    // 이때 입력된 아날로그 신호에 대응하는 변환된 디지털 값들을 시리얼 통신을 이용하여 PC의 터미널에 보여준다.
    // ADC_CR 에 START 비트는 변환할 때마다 1로 세트 해주어야 한다.
    SVN (Subversion) 사용방법

    버전 관리작업을 하거나 , 공동작업, 복원, 등의 작업을 할때 소스가 엉키지 않고 서로 침범하지 않은 상태에서 개발이 가능합니다, 소스의 수정 및 변형을 추적할 수도 있고, 개발 인원들 간의 소스를 덮어 쓰는 일도 방지 할 수 있습니다. 

    이전의 개발 방식은 소스를 직접 수정하거나, 내려 받은 소스를 서버에 올리는 등의 작업을 이용하였지만. 이 방식은 개발자들이 많거나, 팀프로젝트로 진행을 할때 , 서로 파일이 엉키거나 수정한 부분을 덮어 쓰는 등의 문제 이 발생할 수가 있습니다. 

    그래서 버전관리 시스템인 SVN을 이용해서 프로젝트를 관리를 하는것입니다, 물론 개인적인 개발이나 혼자 개발하는 환경이라면 구지 사용해야 할 필요보다는 불편한 요소들이 더욱 많은것은 사실입니다. 

    SVN 저장소 만들기 
    SVN 저장소를 만들기 위해서는 SVN 을 컴파일 해야 합니다. 서브 버전의 최신 버전은 1.6.11 입니다. 
    다운로드는 아래 URL에서 받으면 됩니다. Binary , Source 를 받으시면 됩니다. 
    Tigris.org (http://subversion.tigris.org)
    http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=260&expandFolder=74

    컴파일 방법 (*nix)
    세부적인 컴파일 방법은 다루지 않고 기본적으로 사용가능한 환경 및 이용방법에 대해서만 다뤄 보도록 하겠습니다. 

    $ wget http://subversion.tigris.org/downloads/subversion-1.6.11.tar.gz
    $ tar zxvf subversion-1.6.11.tar.gz 
    $ cd subversion-1.6.11
    $ ./configure --prefix=/usr/local/svn --with-zlib --without-berkeley-db
    $ make
    $ make install

    위와 같이 진행을 하시면 SVN(subversion) 이 설치가 됩니다. 물론 위 사이트에서 바이너리 버전을 배포 하고 있으니 배포 버전을 사용하시거나 yum, yast(SuSE), apt-get 등의 패키지 관리 시스템 을 이용해서 설치 하셔도 무방합니다. 

    이제 저장 소를 만들어 보겠습니다. 저장소는 소스와 버전관리가 이루어지는 DB라고 말씀을 드리겠습니다. SVN을 이용해서 저장을 프로젝트를 진행을 하면 실제 파일들이 저장되는 구조가 아니라 각 revision 단위로 업데이트 내용 및 수정 내용, 추가 내용들이 DB에 저장되는 형태를 지니고 있습니다. 

    $ mkdir [저장소를 만들 경로]
    $ cd [저장소를 만들 경로]
    $ svnadmin create --fs-type fsfs [저장소]

    위와 같이 작업을 하시면 저장소가 만들어 지도록 되어 있습니다. 예를 들어 /home/lovelgw/project/에 저장소를 만들려면 아래와 같이 진행을 하시면 됩니다. 
    $ mkdir /home/lovelgw/project
    $ cd /home/lovelgw/project
    $ svnadmin create --fs-type fsfs repository

    이러면 경로 /home/lovelgw/project/repository 에 저장소가 만들어 집니다. 
    저장소를 만들었으니 이제 SVN을 이용할 수 있도록 서버를 설정하면 됩니다. 

    $ svnserve -d -r [저장소를 만등 경로]

    저장소를 만든 경로를 두에 적어 두시고 실행을 시키시면 서버가 설정이 됩니다. 방화벽 에서 3690 포트를 열어 주시면 외부에서 저장소에 접근할 수 있습니다. 

    $ netstat -na 
    Active Internet connections (servers and established)
    Proto Recv-Q Send-Q Local Address               Foreign Address             State 
    tcp        0      0 :::3690                     :::*                        LISTEN 

    위와 같이 3690 포트가 열려 있음을 확인 할 수 있습니다. 

    /etc/sysconfig/iptables 파일을 열어 Iptable 에 규칙을 추가해 줍니다. 
    -A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 3690 -j ACCEPT

    또는 그외 외부 방화벽을 사용하시면 외부 방화벽에서 포트를 열어 주시면 됩니다. 

    사용자 추가를 위해 저장소가 있는 디렉토리로 이동을 하시면 
    $ ls
    conf  dav  db  format  hooks  locks  README.txt
    위와 같이 디렉토리 및 파일들이 만들어져 있습니다. 

    $ vi conf/svnserve.conf 파일을 수정하여 줍니다. 
    [general]
    # 저장소 접근 권한 입니다. 
    anon-access = read
    # 익명 사용자에게 read 권한을 줍니다. 
    auth-access = write
    # 인증된 사용자에게 write 권한을 줍니다.
    password-db=passwd
    # 인증방식은 passwd 파일을 이용합니다. 
    realm = repository
    # 저장소 문구 입니다. 변경하시면 변경하신 문구가 나옵니다. 

    $ vi conf/passwd
    [users]
    아이디 = 비밀번호 

    위와 같이 설정하시면 저장소가 만들어 집니다. 

    이제 간단히 저장소를 설치/설정 하는 방법을 해보았는데 , 더욱 자세한 방법을 다루기에는 다른 문서를 찾아 보시는게 더욱 좋으실것 같습니다. 이제 SVN을 사용하기 위한 환경이 완성 되엇습니다. 
    이제 SVN에 기능 및 사용방법에 대해서 알아보도록 하겠습니다. 

    import : 저장소에 파일을 넣어주는것입니다. , 아무것도 없는곳에 이제 만들 준비를 하는 작업입니다. 
    $ svn import [import 대상] svn://[주소]/저장소
    위와 같이 하시면 대상에 들어 있는 목록 들이 vi에 표시가 되는데 vi를 닫고 c를 눌러 진행을 하시면 저장소에 자료들이 import 됩니다. 

    checkout : 서버에서 소스를 받아오는 과정입니다. 
    $ svn checkout svn://[주소]/저장소 [저장경로]
    위와 같이 하면 저장소에 있는 대상을 받아 올 수 있습니다. 물론 저장소만 관리하는게 아니라. release 등을 관리 할 수 있습니다. 

    update : 체크 아웃한 파일을 업데이트를 하는 것입니다. 전체를 받아오는것이 아닌 변경된 부분만 받아오도록 되어 있습니다. 
    $ svn update

    commit : 소스를 수정하고 저장소에 소스를 업데이트 하는 방법입니다. 
    $ svn commit 
    위 명령어는 저장소를 받은 디렉토리( 작업디렉토리)에서 이용을 하시면 됩니다. 

    add : 새로운 파일을 저장소에 추가하는 명령어 입니다. 
    $ svn add [파일]
    이 명령어를 사용한 후에는 commit 을 해주어야 실제적으로 저장소에 저장이 됩니다. 

    export : 순수 작업 파일만을 가져옵니다. 
    $ svn export svn://[주소]/[저장소] [저장 경로]

    위와 같이 하시면 소스관리를 할 수 있습니다. 각종 개발툴에서는 플러그인 형태 또는 소스 관리 기능으로 SVN을 지원하고 있습니다. 그외 더 많은 기능 더 유용한 사용법은 많으나 천천히 다뤄보도록 하겠습니다 ^^

    출처 :
    http://www.lovelgw.com/Blog/182
     intToChar() - 정수를 문자열로 바꿔주는 함수
    void intToChar(char *buf, int num)
    {
      int i, j;
      int target;    // 각 자리수
      int value = 1;  // 숫자 크기 확인
      
      while(value <= num)
      {
        value *= 10;
      }  
      
      for(i = 0, j = value/10 ; j >= 10 ; j /= 10)
      {
        target = num / j;
        num = num % j;
        buf[i++] = target + 48;    // buf에 문자값 저장
      }
      buf[i++] = num + 48;
      buf[i] = '\0';
    }

     atoi() - 문자열로 된 수를 정수형으로 바꿔주는 함수
    int atoi(char *c)      // Charter to Integer
    {
      int result = 0;
      int val = 1;
      int i;
      char *tmp = c;

      while(*tmp != '\0')
      {
        val *= 10;
        tmp++;
      }

      tmp = c;
      for(i = (val / 10) ; 1 <= i ; i /= 10)
      {
        result += ((*tmp - 48) * i);
        tmp++;
      }

      return result;
    }

       PIT(주기적인 시간간격 타이머)
     PIT(Periodic Interval Timer)는 운영체제의 스케쥴러에게 주기적인 인터럽트를 발생시키기 위하여 사용하는 타이머이다. 여기서는 효율적인 관리가 중요하며, 시간의 정확성을 높이기 위하여 슬로우 클럭이 아니라 마스터 클럭을 사용한다.

     주기적인 시간간격 타이머는 마스터 클럭을 16분주한 MCK/16의 주파수로 동작하며, 20비트 증가형 카운터 CPIV와 12비트 증가형 카운터 PICNT로 구성된다. 이것이 동작하려면 PIT_MR 레지스터에서 PITEN 비트를 인에이블시켜야 한다.
     
     20비트 카운터 CPIV는 0부터 증가하다가 PIT_MR 레지스터의 PIV 값에 이르게 되면 그 다음 주기에서 자동으로 0으로 클리어 되면서 12비트 카운터 PICNT를 1만큼 증가시키게 되며, 이는 또한 인터럽트를 요청할 수 있다. 따라서, 인터럽트 주기는 PIV+1클럭 사이클이 된다.

     PIT_MR 레지스터의 PIV 값을 변경하기 위하여 새로 라이트하더라도 카운터를 리셋하거나 리스타트하지는 않는다.

     CPIV 값이나 PICNT 값을 확인하기 위하여 PIT_PIVR 레지스터를 읽으면 PICNT 값이 0으로 클리어되고 PIT_SR 레지스터의 PITS 비트도 클리어되어 인터럽트 신호를 종료시킨다. 그러나, PIT_PIIR 레지스터를 읽으면 PICNT 값이나 PIT_SR 레지스터의 PITS 비트를 클리어하지 않는다.

     // PIT(Periodic Inteval Timer)
    #include "MyArm.h"

    #define INTERR    0x00000100
    #define LED      0x00000010 

    //--------- Global Variable?
    int c = 0;
    int cnt = 0;

    void DBGU_write(char *d)
    {
      while(0 != *d)
      {
        while(0 == (DBGU_SR & 0x0002));
        DBGU_THR = *d;
        ++d;
      }
    }

    void intToChar(char *buf, int num)
    {
      int i, j;
      int target;    // 각 자 리수
      int value = 1;  // 숫자 크기 확인
      
      while(value <= num)
      {
        value *= 10;
      }  
      
      for(i = 0, j = value/10 ; j >= 10 ; j /= 10)
      {
        target = num / j;
        num = num % j;
        buf[i++] = target + 48;    // buf에 문자값 저장
      }
      buf[i++] = num + 48;
      buf[i] = '\0';
    }

    void SysControlISR()
    {  
      unsigned int tmp;
      char tx[10];
      tmp = PIT_PIVR;        // Interrupt Reset
      cnt++;

      if(1000 == cnt)  
      {
        intToChar(tx, c);
        DBGU_write(tx);
        c++;
        cnt = 0;
      }
    }

    int main(void)
    {  
      DBGU_CR = (1 << P2) | (1 << P3);  // TX,RX reset & disable
      AIC_IDCR = (1 << P1);        // System Controller Interrupt Disable
      
      // PIO setting
      PIO_PDR = (1 << P9) | (1 << P10);  // PA9, PA10 Disable
      PIO_ASR = (1 << P9) | (1 << P10);  // PA9, PA10 Peripheral A select
      
      // DBGU setting
      DBGU_MR = (1 << P11);        // No Parity
      DBGU_BRGR = 313;          // Baud rate = 9600
      DBGU_CR = (1 << P6);        // TX enable
      
      // PIT setting
      PIT_MR = (0xBB7) | (1 << P25) | (1 << P24);    // PIV = 2999, PITIEN enable
      
      // AIC setting
      AIC_SMR[1= (1 << P5) | (1 << P2) | (1 << P0);  // Positive edge, Priority = 5;
      AIC_SVR[1= (unsigned int)SysControlISR;    // System Controller ISR
      AIC_IECR = (1 << P1);        // System Controller Interrupt Enable

      while(1)
      {

      }  
      
      return 0;
    // End Main...
    // 1초마다 숫자를 카운트해서 그 숫자를 시리얼 통신으로 전송하는 예제이다.
    // 인터럽트 처리 루틴에서 PIT_PIVR 값을 읽어서 인터럽트를 리셋을 해준다.
    // MASTERCLOCK에서 16분주 한 클럭으로 카운트를 하므로 PIV 값을 2999를 주면 1ms 가 만들어진다.(인터럽트는 PIV+1일 때 발생한다)
    // 48M / 16 = 3M -> 3M / 3000 = 1K  : 1초에 1000번을 카운트 함으로 1ms마다 인터럽트가 발생하게 된다.

     // MyArm.h
    //----------------------------------------------------------------------------------------------------------                              
    #define FIQ      0  //AIC = Advanced Interrupt Controller(FIQ)
    #define SYS      1  //SYS = System Controller
    #define PID2    2  //PIOA
    //#define PID3    3  //reserved
    #define PID4    4  //ADC = Analog to Digital Converter
    #define PID5    5  //SPI = Serial Peripheral Interface
    #define PID6    6  //US0 = USART0
    #define PID7    7  //US1 = USART1
    #define PID8    8  //SSC = Synchronous Serial Controller
    #define PID9    9  //TWI = Two-Wire Interface
    #define PID10    10  //PWMC= PWM Controller
    #define PID11    11  //UDP = USB Device Port
    #define PID12    12  //TC0 = Timer/Conuter 0
    #define PID13    13  //TC1 = Timer/Conuter 1
    #define PID14    14  //TC2 = Timer/Conuter 2
    /*            
    #define PID15    15  //reserved
    #define PID16    16
    #define PID17    17
    #define PID18    18
    #define PID19    19
    #define PID20    20
    #define PID21    21
    #define PID22    22
    #define PID23    23
    #define PID24    24
    #define PID25    25
    #define PID26    26
    #define PID27    27
    #define PID28    28
    #define PID29    29
    */

    #define PID30    30  //AIC = Advanced Interrupt Controller (IRQ0)
    #define PID31    31  //AIC = Advanced Interrupt Controller (IRQ1)
    //----------------------------------------------------------------------------------------------------------                              
    #define P0      0
    #define P1      1
    #define P2      2
    #define P3      3
    #define P4      4
    #define P5      5
    #define P6      6
    #define P7      7
    #define P8      8
    #define P9      9
    #define P10      10
    #define P11      11
    #define P12      12
    #define P13      13
    #define P14      14
    #define P15      15
    #define P16      16
    #define P17      17
    #define P18      18
    #define P19      19
    #define P20      20
    #define P21      21
    #define P22      22
    #define P23      23
    #define P24      24
    #define P25      25
    #define P26      26
    #define P27      27
    #define P28      28
    #define P29      29
    #define P30      30
    #define P31      31
    //----------------------------------------------------------------------------------------------------------                              
    //DBGU
    #define RXEN    4
    #define TXEN    6
    #define RSTSTA    8

    #define DRXD    9  //Debug Receive Data
    #define DTXD    10  //Debug Transmit Data

    #define RXRDY    0
    #define TXRDY    1
    //----------------------------------------------------------------------------------------------------------                              
    //PIO  = Parallel  Input/Output  Controller
    #define PIO_PER    (*(volatile unsigned int *) 0xFFFFF400) //PIO  Enable               Register
    #define PIO_PDR    (*(volatile unsigned int *) 0xFFFFF404) //PIO  Disable              Register
    #define PIO_OER    (*(volatile unsigned int *) 0xFFFFF410) //PIO  Output     Enable         Register
    #define PIO_ODR    (*(volatile unsigned int *) 0xFFFFF414) //PIO  Output     Disable        Register
    #define PIO_IFER  (*(volatile unsigned int *) 0xFFFFF420) //PIO  Glitch  Input  Filter  Enable  Register
    #define PIO_SODR  (*(volatile unsigned int *) 0xFFFFF430) //PIO  Controller   Set    Output Data Register
    #define PIO_CODR  (*(volatile unsigned int *) 0xFFFFF434) //PIO  Controller   Clear   Output Data Register
    #define PIO_IER    (*(volatile unsigned int *) 0xFFFFF440) //PIO  Interrupt   Enable        Register
    #define PIO_IDR    (*(volatile unsigned int *) 0xFFFFF444) //PIO  Interrupt   Disable        Register
    #define PIO_ISR    (*(volatile unsigned int *) 0xFFFFF44C) //PIO  Interrupt   Status        Register
    #define PIO_PUDR  (*(volatile unsigned int *) 0xFFFFF460) //PIO  Pull-Up   Disable        Register
    #define PIO_PUER  (*(volatile unsigned int *) 0xFFFFF464) //PIO  Pull-Up   Enable        Register
    #define PIO_ASR    (*(volatile unsigned int *) 0xFFFFF470) //PIO  Peripheral  A  Select      Register
    #define PIO_BSR    (*(volatile unsigned int *) 0xFFFFF474) //PIO  Peripheral  B  Select      Register
    //----------------------------------------------------------------------------------------------------------                      
    //AIC  = Advance Interrupt Controller
    #define AIC_SMR    ( (volatile unsigned int *) 0xFFFFF000)  //(Address of) AIC Source Mode       Register
    #define AIC_SVR    ( (volatile unsigned int *) 0xFFFFF080)  //(Address of) AIC Vector         Register
    #define AIC_IECR  (*(volatile unsigned int *) 0xFFFFF120)  //AIC  Interrupt  Enable  Command    Register
    #define AIC_IDCR  (*(volatile unsigned int *) 0xFFFFF124)  //AIC  Interrupt  Disable  Command    Register
    #define AIC_ICCR  (*(volatile unsigned int *) 0xFFFFF128)  //AIC  Interrupt  Clear  Command    Register
    //----------------------------------------------------------------------------------------------------------
    //DBGU  = Debug Unit
    #define DBGU_CR    (*(volatile unsigned int *) 0xFFFFF200)  //DBGU  Control              Register
    #define DBGU_MR    (*(volatile unsigned int *) 0xFFFFF204)  //DBGU  Mode              Register
    #define DBGU_SR    (*(volatile unsigned int *) 0xFFFFF214)  //DBGU  Status              Register
    #define DBGU_RHR  (*(volatile unsigned int *) 0xFFFFF218)  //DBGU  Receive    Holding        Register
    #define DBGU_THR  (*(volatile unsigned int *) 0xFFFFF21C)  //DBGU  Transmit  Holding        Register
    #define DBGU_BRGR  (*(volatile unsigned int *) 0xFFFFF220)  //DBGU  Baud Rate  Generator Control  Register
    #define DBGU_IER  (*(volatile unsigned int *) 0xFFFFF208)  //DBGU  Interrupt  Enable        Register
    #define DBGU_IDR  (*(volatile unsigned int *) 0xFFFFF20C)  //DBGU  Interrupt  Disalbe        Register
    #define DBGU_IMR  (*(volatile unsigned int *) 0xFFFFF210)  //DBGU  Interrupt  Disalbe        Register
    //----------------------------------------------------------------------------------------------------------
    //TC  = Timer Counter
    #define TC0_CCR    (*(volatile unsigned int *) 0xFFFA0000)  //TC  Channel    Control        Register
    #define TC0_CMR    (*(volatile unsigned int *) 0xFFFA0004)  //TC  Channel    Mode        Register
    #define TC0_CV    (*(volatile unsigned int *) 0xFFFA0010)  //TC  Counter    Value        Register
    #define TC0_RA    (*(volatile unsigned int *) 0xFFFA0014)  //TC  Register A            Register
    #define TC0_RB    (*(volatile unsigned int *) 0xFFFA0018)  //TC  Register B            Register
    #define TC0_RC    (*(volatile unsigned int *) 0xFFFA001C)  //TC  Register C            Register
    #define TC0_SR    (*(volatile unsigned int *) 0xFFFA0020)  //TC  Status              Register
    //----------------------------------------------------------------------------------------------------------
    //PM  = Power Management Controller
    #define PMC_PCER  (*(volatile unsigned int *) 0xFFFFFC10)  //PMC Syetem Clock Enable         Register
    #define PMC_PCDR  (*(volatile unsigned int *) 0xFFFFFC14) //PMC System clock Disable        Register
    #define MASTERCLOCK 48000000
    //----------------------------------------------------------------------------------------------------------


     // 타이머 카운터를 이용해서 LED 컨트롤
    #include "MyArm.h"

    #define INTERR    0x00000100
    #define LED      0x00000010 

    //--------- Global Variable

    void Delayms(unsigned int ms) //Delay Function..

      volatile unsigned int count, countmax = (MASTERCLOCK / 10000) * ms;

      for(count = 0; count < countmax; count++);
    }

    int main(void)
    {  
      int flag = 1;  // flag
      int cnt = 0;  // count flag

      // PMC setting
      PMC_PCER = (unsigned int)1 << PID12;  // Peripheral 12 clock Enable
      
      // PIO setting
      PIO_PDR = (1 << P0) | (1 << P1);    // PA0, PA1 PIO disable  
      PIO_BSR = (1 << P0) | (1 << P1);    // Peripheral B select
      
      // TC setting
      TC0_CCR = (1 << P0) | (1 << P2);    // Software Trigger, Counter Clock Enable
      TC0_CMR = (1 << P15) | (1 << P16) | (1 << P19) | (1 << P24) | (1 << P27) | (1 << P10)
     | (1 << P2); // (MCK / 32), Waveform mode
      TC0_RA = 0x0000;
      TC0_RB = 0xF906;
      TC0_RC = 0xFFFF;
      
      while(1)
      {
        if(flag)
        {
          TC0_RA += 0xFF;
          TC0_RB -= 0xFF;
          cnt++;
          if(cnt >= 250)
          {
            flag = 0;
          }
        }
        else
        {
          TC0_RA -= 0xFF;
          TC0_RB += 0xFF;      
          cnt--;
          if(cnt <= 0)
          {
            flag = 1;
          }
        }
        Delayms(10);
      }
      
      return 0;
    // End Main....
    // 타이머 카운터를 이용하여 2개의 클럭 신호를 만들어 낸다. 한쪽 LED는 밝은 상태에서 점차 어두워지고, 다시 점차 밝아지는 동작을 반복한다. 나머지 한쪽은 그 반대로 동작한다.
    // 처음에는 저번 시간과 같은 방법으로 셋팅을 했는데 TIOB0으로 신호가 나오지 않았다. 나중에 EEVT 필드 값을 01로 셋팅하자 TIOB0으로 신호가 나오기 시작했다. TIOB0으로 디폴트로 입력으로 설정 되어 있는 것 같았다.
    // TCCLKS 필드를 (MASTERCLOCK / 2) 로 셋팅 했을 때, 출력이 동기화가 되지 않았다. 한쪽이 어두워지면 한쪽은 밝아져야 하는데, 한쪽 출력이 먼저 일어나고 그 다음 다른쪽이 출력되는걸로 보였다. 이는 TCCLKS 필드를 (MASTERCLOCK / 32) 즉 카운터 클럭을 낮추니 TIOA0과 TIOB0에서 제대로된 신호가 나왔다.

    ARM

    타이머 카운터0
    AT91SAM7S256에는 동일한 구조와 기능의 16비트 타이머/카운러채널 (TC0~TC2)를 가지고 있다. 이들 3개의 채널은 서로 독립적으로 동작하며 이벤트카운트, 주파수 측정, 시간간격측정,시간지연, 펄스 발생 PWM출력등의 기능을 수행할 수 있다.

    실습
    TC0를 이용하여 파형발생 모드로 led를 깜박이기

    사용레지스터

    채널 콘트롤 레지스터 클럭을 인가할때 사용한다.


    채널 모드 설정 wave=1로 하면 파형출력 모드를 사용한다.

    파형 모드 설정

    ACPA  RA 값을 비교하여 TIOA를 설정한다.
    ACPC RC 값을 비교하요 TIOA를 설정한다.


    TC0_CV 실시간으로 카운터 값을 저장한다.
    TC0_RA 실시간을로 RA값을 저장한다.
    TC0_RC 실시간을로 RC값을 저장한다.



    분주비



    #include "MyArm.h"

    #define MASTERCLOCK 48000000
    #define INTERR    0x00000100
    #define LED      0x00000010 

    //--------- 전역 변수

    void Delayms(unsigned int ms) //딜레이 함 수..

      volatile unsigned int count, countmax = (MASTERCLOCK / 10000) * ms;

      for(count = 0; count < countmax; count++);
    }

    int main(void)
    {  
      // PMC setting
      PMC_PCER = (unsigned int)1 << PID12;  // 장치 PID12번에 클럭 공급
      
      // PIO setting
      PIO_PDR = (1 << P0) | (1 << P1);    // PA0, PA1 Disable
      PIO_BSR = (1 << P0) | (1 << P1);    // PA0, PA1 장치 B Select
      
      // TC setting
      TC0_CCR = (1 << P0) | (1 << P2);    // TC enalbe
      TC0_CMR = (1 << P15) | (1 << P16) | (1 << P19) | (1 << P2);  // RA compare set, RC compare clear, clock=48Mhz/1024
      TC0_RA = 0x000F;
      TC0_RC = 0xF000;
      
      while(1)
      {

      }
      
      return 0;
    // End Main....
    // 타이머 카운터를 이용하여 일정 클럭 신호를 만들어서, LED로 확인해 보는 예제이다.

    1. 1바이트는 8개의 비트로 이루어집니다. 255 8개 비트 전체가 1인 경우이고, 1은 최하위 1비트만 1인 경우입니다. 문자 ch의 켜진 비트 개수는 몇 개입니까? 켜진 비트는 1로 설정된 비트의 다른 표현입니다.

    대문자 ‘A’의 값은 65이고 6번째와 1번째 비트가 켜져 있습니다.


     Character.h
    #ifndef CHARACTER_H
    #define CHARACTER_H

    class Character
    {
    public:  
      // 생성자
      Character();
      Character(char c);

      // 소멸자
      ~Character();

      void setChar(char c);
      char getChar() const;
      int bitCount() const;

    protected:
      char data;
    };

    #endif

     Character.cpp
    #include "Character.h"

    void Character::setChar(char c)
    {
      data = c;
    }

    char Character::getChar() const
    {
      return data;
    }

    int Character::bitCount() const
    {
      int cnt = 0;
      int tmp = 1;

      for(int i = 0 ; i < 8 ; ++i)
      {
        if(data & tmp)
        {
          ++cnt;
        }
        tmp <<= 1;
      }
      return cnt;
    }

     main.cpp
    #include "Character.h"
    #include <iostream>
    using namespace std;

    int main()
    {
      char c;

      cout << "문자 입력: ";
      cin >> c;

      Character ch(c);
      cout << "켜진 비트의 개수: " << ch.bitCount() << endl;
      cout << "값: " << (int)ch.getChar() << endl;
      
      return 0;
    }


    2. 정수 N이 소수입니까?


     Integer.h
    #ifndef INTEGER_H
    #define INTEGER_H

    class Integer
    {
    public:
      // 생성자
      Integer();
      Integer(int num);

      // 소멸자
      ~Integer();

      // 멤버 함수
      void setNum(int num);
      int getNum() const;
      int sumNum() const;
      bool isPrime() const;  // 소수 여부 확인 해주는 함수

    protected:
      int num;
    };

    #endif

     Integer.cpp
    #include "Integer.h"

    void Integer::setNum(int num)
    {
      this -> num = num;
    }

    int Integer::getNum() const
    {
      return num;
    }

    int Integer::sumNum() const
    {
      int result;
      int tmp = num;

      result = tmp / 100;    // 100자리
      tmp %= 100;
      result = result + (tmp / 10);  // 100자리 + 10자리
      tmp %= 10;
      result += tmp;    // 100자리 + 10자리 + 1자리

      return result; 
    }

    // 소수 여부 확인 해주는 함수
    bool Integer::isPrime() const
    {
      int i;

      if(2 == num)
      {
        return true;
      }
      else if(num % 2 == 0)
      {
        return false;
      }

      for(i = 3 ; i <= num ; i += 2)
      {
        if(num % i == 0)
        {
          break;
        }
      }
      if(i == num)
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    Integer::Integer()
    {
      setNum(0);
    }

    Integer::Integer(int num)
    {
      setNum(num);
    }

    Integer::~Integer()
    {

    }

     main.cpp
    #include "Integer.h"
    #include <iostream>
    using namespace std;

    int main()
    {
      int num;

      cout << "정수 입력: ";
      cin >> num;

      Integer i(num);

      if(i.isPrime())
        cout << "결과 : 소수" << endl;
      else
        cout << "결과 : 합성수" << endl;
      
      return 0;
    }



    3. 로또 번호 생성 프로그램


     Lotto.h
    #ifndef LOTTO_H
    #define LOTTO_H

    class Lotto
    {
    public:
      // 생성자
      Lotto();

      // 소멸자
      ~Lotto();

      // 멤버 함수
      void createRandom();
      void printNum() const;

    protected:
      int num[6];

      bool sameNum(const int *arr, int size, int num) const;

    };

    #endif

     Lotto.cpp
    #include "Lotto.h"
    #include <iostream>
    #include <stdlib.h>
    using namespace std;

    bool Lotto::sameNum(const int *arr, int size, int num) const
    {
      for(int i = 0 ; i < size ; ++i)
      {
        if(arr[i] == num)
        {
          return 1;
        }
      }
      return 0;
    }

    void Lotto::createRandom()
    {
      int tmp;
      
      for(int i = 0 ; i < 6 ; ++i)
      {
        tmp = (rand() % 45) + 1;
        while(sameNum(num, i + 1, tmp))
        {
          tmp = (rand() % 45) + 1;
        }
        num[i] = tmp;
      }
    }

    void Lotto::printNum() const
    {
      for(int i = 0 ; i < 6 ; ++i)
      {
        cout.width(2);
        cout << num[i] << " ";
      }
      cout << endl;
    }

    Lotto::Lotto()
    {
      createRandom();
    }

    Lotto::~Lotto()
    {

    }


     main.cpp
    #include "Lotto.h"
    #include <iostream>
    #include <time.h>
    #include <stdlib.h>
    using namespace std;

    int main()
    {
      int cnt;

      srand((unsigned int)time(NULL));

      cout << "Enter the Game count: ";
      cin >> cnt;

      cout << "========================" << endl;
      for(int i = 0 ; i < cnt ; ++i)
      {
        Lotto l;
        l.printNum();  
      }
      cout << "========================" << endl;

      return 0;
    }



    Cross Toolchains

    We provide a set of apt-able tools built from standard Debian binutils and gcc sources.

    We are currently working on keeping the tools synchronised with Debian, and maintaining installable sets for unstable, testing and lenny. Builds are still handled manually so are sometimes out of date. If you have any trouble finding current packages in the main repository, you may find something useful in Hector Oron's toolchain download area.
    Please check Toolchain Wiki page for the latest news on the matter.

    The cross-toolchains can not yet be built in Debian proper because there is no mechanism for the autobuilders to understand cross-dependencies. We are working on dealing with this problem so that crosstools can become standard debian packages, but until that is done you need to add the emdebian repository to your sources.list.
    If you install emdebian-tools, and run emsetup -a arch it will add suitable sources.list entries for you. Be sure to edit /etc/apt/sources.list.d/ files and add your Debian suite.
    To set things up manually edit /etc/apt/sources.list to add one of the lines below.

    #
    # -- Emdebian sources.list entries
    #
    # deb http://www.emdebian.org/debian/ unstable main
    # deb http://www.emdebian.org/debian/ testing main
    deb http://www.emdebian.org/debian/ lenny main

    Then do apt-get update to update your local lists.

    Once you have that then install whichever version of the tools you want. e.g:
    apt-get install libc6-armel-cross libc6-dev-armel-cross binutils-arm-linux-gnueabi gcc-4.3-arm-linux-gnueabi g++-4.3-arm-linux-gnueabi
    will install the gcc-4.3 C and C++ toolchain for armel cross-compiling.

    For details on how to build your own tools see also how to build your own toolchain.

    출처 : http://www.emdebian.org/

    + Recent posts