회원가입 ID/PW 찾기

지식 창고 : 자작품, 강좌, 설계 팁/노하우, 회로도 등

1) 지식 창고는 본인이 작성한 콘텐츠(팁/노하우/리소스/강좌 등)을 무료 혹은 가상화폐인 납포인트를 통해 공유하는 공간입니다.
2) 본인이 작성한 콘텐츠에 대해서만 지식 창고에 등록할 수 있으며, 저작권에 위배되는 콘텐츠는 사전경고 없이 삭제될 수 있습니다.
3) 콘텐츠 구매 및 첨부파일 다운로드는 회원그룹 '연구원' 이상 가능하오니, 경험치를 쌓아 진급한 후에 이용 부탁드립니다.
4) 무료 콘텐츠의 본문은 구매절차 없이 즉시 이용할 수 있으며, 판매 납포인트가 있는 콘텐츠는 구매 후 이용할 수 있습니다.
5) 콘텐츠 판매에 따른 납포인트 수익은 지정한 비율(50%)에 따라 판매자에게 지급하며, 납포인트 수익을 통해 진급을 빨리할 수 있습니다.
6) 구매 후 평가를 하면 구매 납포인트의 20%를 돌려 드립니다.

콘텐츠 수 739

ATMEGA128 리모컨으로 FND 동작

마이크로프로세서 구매수 0 2010.01.27 13:10:22
판매자 까까 판매 납포인트 무료 평점 1.0점 / 총 1명 참여
/*********************************************************************************
Project : NEC형식의 7Segment(FND)를 리모콘을 이용하여 제어하기
Version : Test 1.0
Date    : 2009-05-17
Author  :         허승호                          

작동완전 잘됨...테스트 버젼이라서 쏘스가 엉망..ㅋ 

동작 동영상 링크 : http://blog.naver.com/ka2great/70050335483

Chip type           : ATmega128
Clock frequency     : 16.000000 MHz
Memory model        : Small

오실로 스코프로 찍어본 리모콘 파형 분석 코드 :

리모콘 코드 테이블
　 custom custom2 data data2
select1 C1 A2 30 CF
select2 C1 A2 B0 4F
select3 C1 A2 70 8F
select4 C1 A2 F0 0F
1 C1 A2 48 B7
2 C1 A2 C8 37
3 C1 A2 28 D7
4 C1 A2 A8 57
5 C1 A2 68 97
6 C1 A2 E8 17
7 C1 A2 18 E7
8 C1 A2 98 67
9 C1 A2 58 A7
0 C1 A2 38 C7
ok C1 A2 B8 47
save C1 A2 D8 27

********************************************************************************************/

#include <mega128.h>  
#include <stdio.h>
#include <delay.h>      

// define 

// 매크로
#define clear_bit(data, push)    ( (data) &= ~(0x1<<(push)) )             // 특정 비트만 '0'으로 클리어
#define set_bit(data, push)      ( (data) |= (0x1<<(push)) )              // 특정 비트만 '1'로 셋
#define check_bit(data, push)    ( (data) & (0x1<<(push)) )               // 특정 비트값을 읽어 온다.

// 함수 선언
void Signal(void);  
void Sig_cmp(void);
void Copy_func(unsigned char value);


// 전역변수 
unsigned ch = 0 ;       // Select FND   
unsigned store_= 0;
  
int sw = 2;
unsigned char Buffer[5] = {0xc0,0xc0,0xc0,0xc0,0xc0}; 
unsigned char fnd1_Buffer[5] = {0xc0,0xc0,0xc0,0xc0,0xc0};
unsigned char fnd2_Buffer[5] = {0xc0,0xc0,0xc0,0xc0,0xc0};
unsigned char fnd3_Buffer[5] = {0xc0,0xc0,0xc0,0xc0,0xc0};
unsigned char fnd4_Buffer[5] = {0xc0,0xc0,0xc0,0xc0,0xc0};

unsigned int time_count = 0;  
unsigned int custom_code = 0x0000;
unsigned int data_code = 0x0000;

unsigned char Lead_sig = 0;
unsigned char bit_data ;  
unsigned char custom_code_count=0;
unsigned char data_code_count=0;

 

// 7Segment 진리표
/***************************************************
       < 7Segment Data Table !!> ==커먼 캐써드= 타입=
      
           MSB  |   LSB     
          g f e | d c b a
----------------|--------------------------------                   
0  :      1 0 0 | 0 0 0 0       0xc0
----------------|--------------------------------
1  :      1 1 1 | 1 0 0 1       0xf9
----------------|--------------------------------
2  :      0 1 0 | 0 1 0 0       0xa4                       
----------------|--------------------------------
3  :      0 1 1 | 0 0 0 0       0xb0                       
----------------|--------------------------------
4  :      1 0 1 | 1 0 0 1       0x99                       
----------------|--------------------------------
5  :      0 0 1 | 0 0 1 0       0x92                       
----------------|--------------------------------
6  :      0 0 0 | 0 0 1 0       0x82                     
----------------|--------------------------------
7  :      0 1 1 | 1 0 0 0       0xf8                      
----------------|--------------------------------
8  :      0 0 0 | 0 0 0 0       0x80                       
----------------|--------------------------------
9  :      0 0 1 | 0 0 0 0       0x90                
----------------|--------------------------------
A  :      0 0 0 | 1 0 0 0       0x88               
----------------|--------------------------------
B  :      0 0 0 | 0 0 1 1       0x83                
----------------|--------------------------------
C  :      0 1 0 | 0 1 1 1       0xc6                
----------------|--------------------------------
D  :      0 1 0 | 0 0 0 1       0xa1                
----------------|--------------------------------
E  :      0 0 0 | 0 1 1 0       0x86                
----------------|--------------------------------
F  :      0 0 0 | 1 1 1 0       0x8e                
----------------|--------------------------------
****************************************************/ 

// FND에 표시할 숫자
enum {  // g f e  d c b a
    FND_0, // 0 1 1  1 1 1 1
 FND_1, // 0 0 0  0 1 1 0
 FND_2, // 1 0 1  1 0 1 1
 FND_3, // 0 0 1  1 1 1 1
 FND_4, // 0 1 0  0 1 1 1
 FND_5, // 1 1 0  1 1 0 1
 FND_6, // 1 1 1  1 1 0 1
 FND_7, // 1 0 0  0 1 1 1
 FND_8, // 1 1 1  1 1 1 1
 FND_9, // 1 1 0  1 1 1 1
 FND_A, // 1 1 1  0 1 1 1
 FND_B, // 1 1 1  1 1 0 0
 FND_C, // 1 0 1  1 0 0 0
 FND_D, // 1 0 1  1 1 1 0
 FND_E, // 1 1 1  1 0 0 1
 FND_F, // 1 1 1  0 0 0 1
 FND_VALUE
};
 
static unsigned char FND_font[] =
{
 0xc0, // 0
 0xf9, // 1
 0xa4, // 2
 0xB0, // 3
 0x99, // 4
 0x92, // 5
 0x82, // 6
 0xF8, // 7
 0x80, // 8
 0x90, // 9
 0x88, // A
 0x83, // B
 0xC6, // C
 0xA1, // D
 0x86, // E
 0x8E  // F
};  

void port_init(void)
{  
    DDRC = 0xFF;       // 포트 C 출력 설정 - FND 핀 연결  
 DDRB = 0xFF; 
 DDRA = 0xFF;
 DDRD = 0xFF;
 DDRF = 0xFF;
 
 DDRE = 0b00000010;  // PE4 - PE7 핀 입력 설정   - 외부 인터럽트
}
    
// Timer_Counter0 Initialize Function(타이머카운터0 초기화 함수)
void Timer_Counter0_init(void)
{
    // 타이머/카운터0 출력비교(TCNT0 = OCRO 일때) 인터럽트 서비스 루틴
 // 인터럽트 발생 주기 1/16us * 8분주 * 200 = 100us  = 0.1ms
 TIMSK = 0x02;         // OCIE0 = 1 출력 비교 인터럽트 인에이블
 TCCR0 = 0x0A;  // 프리스케일 = CK/8, CTC 모드
    OCR0 = 199;      // 출력 비교 레지스터값
 TCNT0 = 0x00;      // 타이머/카운터0 레지스터 초기값
 SREG = 0x80;         // 전역 인터럽트 인에이블 비트 I 셋.      
} 

// 외부인터럽트 초기화 함수
void External_Interrupt_init(void)
{
    // 인터럽트 초기화
 EICRB = 0x02;        // 외부 인터럽트 4 : 하강 에지
 EIMSK = 0x10;        // 외부 인터럽트 4 인에이블       
}

void main(void)
{
    int i;
    unsigned int twincle = 0;                 
   
  
 port_init();                   
 External_Interrupt_init(); 
 Timer_Counter0_init();  
                                                            
 while(1)  // 무한 루프 
 {                          
           
     switch(sw)
     {
    
         case 1 : 
         ///////////////////////////////////////////////////////////////////////////
             if(ch == 1)
           {                                                                       
             twincle++;
             if(twincle == 150)
             twincle = 0;
            
             if(twincle >= 80)
             {              
                
                 PORTA = 0x00;
                 PORTD = 0x00;
                 PORTB = 0x00;           
                 for(i=0; i<5; i++)
                    {                                         
                        PORTF = 0x01 << i;
                        PORTC = Buffer[i];
                        if(i==2)   
                        {
                            clear_bit(PORTC,7); // 점 찍기 (000.00),  "."
                            delay_us(50);
                        }
                        delay_us(500);
                    }                          
                 }

             PORTA = 0x00;
             PORTF = 0X00;
             PORTB = 0x00;
             for(i=0; i<5; i++)
                {
                    PORTD = 0x01 << i;
                    PORTC = fnd2_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTD = 0X00;
             PORTF = 0X00;
             PORTB = 0x00; 
             for(i=0; i<5; i++)
                {
                    PORTA = 0x01 << i;
                    PORTC = fnd3_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTA = 0x00;
             PORTD = 0X00;
             PORTF = 0X00;
             for(i=0; i<5; i++)
                {
                    PORTB = 0x01 << i;
                    PORTC = fnd4_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }    
         }
         ///////////////////////////////////////////////////////////////////////////////
          if(ch == 2)
         {
             twincle++;
             if(twincle == 150)
                 twincle = 0;
                
             PORTA = 0x00;
             PORTD = 0x00;
             PORTB = 0x00;            
             for(i=0; i<5; i++)
                {                                         
                    PORTF = 0x01 << i;
                    PORTC = fnd1_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7); // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }                           
               
                if(twincle >=80)
                {
                 PORTA = 0x00;
                 PORTF = 0X00;
                 PORTB = 0x00;
                 for(i=0; i<5; i++)
                    {
                        PORTD = 0x01 << i;
                        PORTC = Buffer[i];
                        if(i==2)   
                        {
                            clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                            delay_us(50);
                        }
                        delay_us(500);
                    }
                 }
 
                PORTD = 0X00;
             PORTF = 0X00;
             PORTB = 0x00; 
             for(i=0; i<5; i++)
                {
                    PORTA = 0x01 << i;
                    PORTC = fnd3_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTA = 0x00;
             PORTD = 0X00;
             PORTF = 0X00;
             for(i=0; i<5; i++)
                {
                    PORTB = 0x01 << i;
                    PORTC = fnd4_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                } 
         }
         ///////////////////////////////////////////////////////////////////////////////
             if(ch == 3)
            {  
                twincle++;
             if(twincle == 150)
                 twincle = 0;

                PORTA = 0x00;
             PORTD = 0x00;
             PORTB = 0x00;            
             for(i=0; i<5; i++)
                {                                         
                    PORTF = 0x01 << i;
                    PORTC = fnd1_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7); // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }                           

             PORTA = 0x00;
             PORTF = 0X00;
             PORTB = 0x00;
             for(i=0; i<5; i++)
                {
                    PORTD = 0x01 << i;
                    PORTC = fnd2_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
               
                if(twincle >=80)
                {
                    PORTD = 0X00;
                 PORTF = 0X00;
                 PORTB = 0x00; 
                 for(i=0; i<5; i++)
                    {
                        PORTA = 0x01 << i;
                        PORTC = Buffer[i];
                        if(i==2)   
                        {
                            clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                            delay_us(50);
                        }
                        delay_us(500);
                    }
                 }
 
                PORTA = 0x00;
             PORTD = 0X00;
             PORTF = 0X00;
             for(i=0; i<5; i++)
                {
                    PORTB = 0x01 << i;
                    PORTC = fnd4_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                } 
            }
            ///////////////////////////////////////////////////////////////////////////////
             if(ch == 4)
            {  
                twincle++;
             if(twincle == 150)
                 twincle = 0;
               
                PORTA = 0x00;
             PORTD = 0x00;
             PORTB = 0x00;            
             for(i=0; i<5; i++)
                {                                         
                    PORTF = 0x01 << i;
                    PORTC = fnd1_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7); // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }                           

             PORTA = 0x00;
             PORTF = 0X00;
             PORTB = 0x00;
             for(i=0; i<5; i++)
                {
                    PORTD = 0x01 << i;
                    PORTC = fnd2_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTD = 0X00;
             PORTF = 0X00;
             PORTB = 0x00; 
             for(i=0; i<5; i++)
                {
                    PORTA = 0x01 << i;
                    PORTC = fnd3_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
               
                if(twincle >=80)
                {
                    PORTA = 0x00;
                 PORTD = 0X00;
                 PORTF = 0X00;
                 for(i=0; i<5; i++)
                    {
                        PORTB = 0x01 << i;
                        PORTC = Buffer[i];
                        if(i==2)   
                        {
                            clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                            delay_us(50);
                        }
                        delay_us(500);
                    }
                 } 
             }
            
             break; 
             ///////////////////////////////////////////////////////////////////////////////
            
            
            
            
            
  
            
         case 2 :
 
             PORTA = 0x00;
             PORTD = 0x00;
             PORTB = 0x00;            
             for(i=0; i<5; i++)
                {                                         
                    PORTF = 0x01 << i;
                    PORTC = fnd1_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7); // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }                           

             PORTA = 0x00;
             PORTF = 0X00;
             PORTB = 0x00;
             for(i=0; i<5; i++)
                {
                    PORTD = 0x01 << i;
                    PORTC = fnd2_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTD = 0X00;
             PORTF = 0X00;
             PORTB = 0x00; 
             for(i=0; i<5; i++)
                {
                    PORTA = 0x01 << i;
                    PORTC = fnd3_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                }
 
                PORTA = 0x00;
             PORTD = 0X00;
             PORTF = 0X00;
             for(i=0; i<5; i++)
                {
                    PORTB = 0x01 << i;
                    PORTC = fnd4_Buffer[i];
                    if(i==2)   
                    {
                        clear_bit(PORTC,7) ; // 점 찍기 (000.00),  "."
                        delay_us(50);
                    }
                    delay_us(500);
                } 
            
                                      
       
                break;
            }
         }
 }
 

// 타이머/카운터0 출력비교(TCNT0 = OCRO 일때) 인터럽트 서비스 루틴
interrupt [TIM0_COMP] void timer_comp0(void)
{                   
 time_count++;
}     
 
// 외부 인터럽트 4 서비스 루틴 
interrupt[EXT_INT4] void external_int4(void)
{
    Signal(); 
    Sig_cmp();      
    time_count = 0 ;     
} 

void Signal(void)
{
       if( (time_count > 90) && (time_count < 145) )   // 입력 신호가 Lead 신호.
       {
              Lead_sig = 1; 
                           
              custom_code_count = 0;
              data_code_count =0; 
             
              custom_code = 0x0000;
              data_code = 0x0000;
       }
      
       else if ( (time_count > 5) && (time_count < 17) )   //입력 bit가 0일 경우
       {
              bit_data = 0x0000;
             
              if (custom_code_count < 16)               // custom_code_count 가 16보다 작을 경우
              {
                     custom_code_count++ ;              // custom_code_count 의 자리 수 증가
                     custom_code = (custom_code <<= 1) | (bit_data) ;        //비트를 1자리 이동후 최하위 비트에 0을 대입
              }
              else if (data_code_count < 16 )         // data_code_count가 16보다 작을 경우
              {
                     data_code_count++ ;         // data_code_count 의 자리 수 증가
                     data_code = (data_code <<= 1) | (bit_data) ;    //비트를 1자리 이동후 최하위 비트에 0을 대입
              }
 
       }
      
       else if ( (time_count > 17) && (time_count < 28) )     //입력 bit가 1일 경우
       {
              bit_data = 0x0001;
             
              if (custom_code_count < 16)               // custom_code_count 가 16보다 작을 경우
              {
                     custom_code_count++ ;              // custom_code_count 의 자리 수 증가
                     custom_code = (custom_code <<= 1) | (bit_data) ;        //비트를 1자리 이동후 최하위 비트에 0을 대입
              }
              else if (data_code_count < 16 )         // data_code_count가 16보다 작을 경우
              {
                     data_code_count++ ;         // data_code_count 의 자리 수 증가
                     data_code = (data_code <<= 1) | (bit_data) ;    //비트를 1자리 이동후 최하위 비트에 0을 대입
              }

       }
      
       else
       {
               Lead_sig = 0;
              
       } 
      
      
}

void Sig_cmp(void)
{
           int i;                                       
                            
        if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x30CF) ) // 메뉴 1번 키 
        {                                 
                ch = 1;
                sw = 1;   
       
                for(i=0; i<5; i++)
                {  
                    Buffer[i] = 0xc0;
                }
        }  
       
           else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xB04F) ) // 메뉴 2번 키 
        {
             ch = 2;
             sw = 1;                             
             for(i=0; i<5; i++)
                {  
                    Buffer[i] = 0xc0;
                }
        }
       
           else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x708F) ) // 메뉴 3번 키 
        {
             ch = 3; 
             sw = 1;                             
             for(i=0; i<5; i++)
                {  
                    Buffer[i] = 0xc0;
                }
        }
       
           else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xF00F) ) // 메뉴 4번 키 
        {
             ch = 4; 
             sw = 1;                             
             for(i=0; i<5; i++)
                {  
                    Buffer[i] = 0xc0;
                }
        }                                                                                                  
       
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x48b7) ) // 1 숫자
        {
             Copy_func(FND_font[FND_1]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xc837) ) // 2 숫자
        {
             Copy_func(FND_font[FND_2]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x28d7) ) // 3 숫자
        {
             Copy_func(FND_font[FND_3]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xa857) ) // 4 숫자
        {
             Copy_func(FND_font[FND_4]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x6897) ) // 5 숫자
        {
             Copy_func(FND_font[FND_5]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xe817) ) // 6 숫자
        {
             Copy_func(FND_font[FND_6]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x18e7) ) // 7 숫자
        {
             Copy_func(FND_font[FND_7]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x9867) ) // 8 숫자
        {
             Copy_func(FND_font[FND_8]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x58a7) ) // 9 숫자
        {
             Copy_func(FND_font[FND_9]);
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0x38c7) ) // 0 숫자
        {
             Copy_func(FND_font[FND_0]);
           
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xd827) ) // SAVE
        { 
             switch(ch)
            {
             case 1 : 
                 if( !((Buffer[0]== 0x86) && (Buffer[1]==0xc1) && (Buffer[2]==0x88) &&(0x7f)) )
                 {
                     for(i=0; i<5; i++)
                        {  
                            fnd1_Buffer[i] = Buffer[i];
                            store_ = 1;
                        }
                     }
                 break;
  
             case 2 :  
                 if( !((Buffer[0]== 0x86) && (Buffer[1]==0xc1) && (Buffer[2]==0x88) &&(0x7f)) )
                 {
                     for(i=0; i<5; i++)
                        {  
                            fnd2_Buffer[i] = Buffer[i];
                            store_ = 2;
                       
                        }
                     }
                 break;
  
             case 3 :                                                             
                 if( !((Buffer[0]== 0x86) && (Buffer[1]==0xc1) && (Buffer[2]==0x88) &&(0x7f)) )
                 {
                     for(i=0; i<5; i++)
                        {  
                            fnd3_Buffer[i] = Buffer[i]; 
                            store_ = 3;
                      
                        }
                     }
                 break;

             case 4 :                                                                         
                 if( !((Buffer[0]== 0x86) && (Buffer[1]==0xc1) && (Buffer[2]==0x88) &&(0x7f)) )
                 {
                     for(i=0; i<5; i++)
                        {  
                            fnd4_Buffer[i] = Buffer[i];
                            store_ = 4;
                       
                        }
                    }   
                 break;
                
             default :
                 break;
            }
            
            
            
                 Buffer[0] = 0x86;
                 Buffer[1] = 0xc1;
                 Buffer[2] = 0x88;
                 Buffer[3] = 0x92;
                 Buffer[4] = 0x7f;
          
        }
        else if ( (Lead_sig == 1) && (custom_code == 0xC1A2) && (data_code == 0xb847) ) // 출력
        {           
              sw = 2;
                 
        }
       
} 

// value값을 Buffer에 복사하는 함수
void Copy_func(unsigned char value)
{   
    Buffer[4] = Buffer[3];  
    Buffer[3] = Buffer[2];
    Buffer[2] = Buffer[1];
    Buffer[1] = Buffer[0];
    Buffer[0] = value;        
   
}                  

목록
신고

profile
좋지 2010.02.08 20:27
감사합니다....
profile
사운드웨어 2010.02.19 14:25
감솨합니다.
profile
루키키 2010.02.24 17:59
헉..언제 이렇게 해볼까염
profile
공신 2010.04.06 11:49
감사합니다.!! ^^
profile
blurlink 2010.04.28 17:42
감사합니다.
profile
불멸 2010.07.08 13:36

엄청나네요 감사합니다.

profile
개불먹자 2011.12.05 19:07

감사합니다

profile
컴쟁이 2012.08.12 00:09
좋은자료 감사합니다...
profile
시나브로69 2016.07.16 17:42

좋은 자료 감사합니다.

profile
병장나야 2016.12.12 16:58

감사합니다

profile
페스코 2023.01.12 17:28
감사합니다.
search
분류  >  마이크로프로세서
List of Articles
번호 분류 제목 평점 포인트 판매자 등록일 구매수 조회 수
공지 공공의 목적으로 공유하고자 하는 소프트웨어는 '소프트웨어 자료실'에 업로드를 요청드립니다.
공지 구매후 평점 댓글을 남겨주시면 구매포인트의 20%를 돌려드립니다.
379 마이크로프로세서 LCD용 Color Bit 변환툴 [6] 무료 병아리 2010-01-31 0 3878
378 마이크로프로세서 stm32_vector_motor_focfirmwarelibrariesv1[1].0 [4] 무료 whlove86 2010-01-27 0 5524
377 마이크로프로세서 PIC24-Eval-BoardC[1] [2] 무료 whlove86 2010-01-27 0 4756
376 마이크로프로세서 Graphics QA LVC75Z779 [2] 무료 whlove86 2010-01-27 0 3186
375 마이크로프로세서 SSD1928 OV9650 Demo [1] 무료 whlove86 2010-01-27 0 2699
» 마이크로프로세서 ATMEGA128 리모컨으로 FND 동작 [11] 무료 까까 2010-01-27 0 4430
373 마이크로프로세서 C8051F33x datasheet입니다. [2] 무료 동키 2010-01-26 0 4679
372 마이크로프로세서 C8051F930 datasheet [4] 무료 동키 2010-01-26 0 4655
371 마이크로프로세서 좋은임베디드 강좌 소개 - 친절한 임베디드 시스템 개발자 되기 강좌 무료 김별남 2010-01-24 0 6845
370 마이크로프로세서 8051이나 avr 하는데 필요한 다시 집고 가는기초C자료입니다^^ [14] 무료 까까 2010-01-20 0 3205
369 마이크로프로세서 PWM 듀티 송신&수신(프로테우스 시뮬포함) [9] 무료 바오밥 2010-01-17 0 7546
368 마이크로프로세서 보드 필요 없다!! Proteus VSM 이란 강력한 시뮬레이션 툴!! [56] 무료 까까 2010-01-14 0 14263
367 마이크로프로세서 [참고]IAR, AVR Studio Tool 사용 법입니다. [9] 무료 까까 2010-01-11 0 5644
366 마이크로프로세서 ATMEGA128 UART & EEPROM(I2C) [11] 무료 까까 2010-01-11 0 10027
365 마이크로프로세서 8051 무료 동영상 강좌 입니다 ^^ [68] 무료 까까 2010-01-08 0 9283
364 마이크로프로세서 단위계변환프로그램(dB관련) [7] 무료 sky2man 2010-01-07 0 3652
363 마이크로프로세서 ST STM32 Flash Loader Demonstrator V2.1.0 [3] 무료 아크마 2010-01-07 0 9380
362 마이크로프로세서 8051-실습-7Segment 동작원리와 구동 프로그램 [8] 무료 himm 2010-01-06 0 4966
361 마이크로프로세서 <ATmega8535> 7세그먼트 구동하기 CodeVisionAVR [24] 무료 himm 2010-01-06 0 5842
360 마이크로프로세서 8051 CAN 자료 입니다. [5] 무료 워터보이 2010-01-06 0 3005
목록
콘텐츠 등록
  • 최고에 도달하려면 최저에서 시작하라.
    - P.시루스
  • * 납포인트 정보 *
  • 글 작성 : 3
  • 댓글 작성 : 1
Link
Email
저작권법에 위배되는 콘텐츠는 등록 불가하며, 저작물에 대한 권리는 저작자에게 있습니다.
Copyright 2006-2021 © hardwareis.com, All rights reserved.