질문게시판 > 아두이노 소스코드 해석 질문

TODAY993 TOTAL273,940
사이트 이용안내
Login▼/회원가입
포럼 동영상강좌 회원가입


▼ BASIC4MCU 후원업체 최신 정보 ▼

▲ BASIC4MCU 후원업체 최신 정보 ▲

BASIC4MCU | 질문게시판 | 아두이노 소스코드 해석 질문

페이지 정보

작성자 master 작성일2018-09-14 08:45 조회1,397회 댓글0건

본문

	

이해가 너무 안가네요..... 해석좀 해주세요

 

#include <Servo.h>
#include <SPI.h>
#include <EEPROM.h>
#include <boards.h>
#include <RBL_nRF8001.h>
#include "Boards.h"

#define PROTOCOL_MAJOR_VERSION   0 //
#define PROTOCOL_MINOR_VERSION   0 //
#define PROTOCOL_BUGFIX_VERSION  2 // bugfix

#define PIN_CAPABILITY_NONE      0x00
#define PIN_CAPABILITY_DIGITAL   0x01
#define PIN_CAPABILITY_ANALOG    0x02
#define PIN_CAPABILITY_PWM       0x04
#define PIN_CAPABILITY_SERVO     0x08
#define PIN_CAPABILITY_I2C       0x10

// pin modes
//#define INPUT                 0x00 // defined in wiring.h
//#define OUTPUT                0x01 // defined in wiring.h
#define ANALOG                  0x02 // analog pin in analogInput mode
#define PWM                     0x03 // digital pin in PWM output mode
#define SERVO                   0x04 // digital pin in Servo output mode

byte pin_mode[TOTAL_PINS];
byte pin_state[TOTAL_PINS];
byte pin_pwm[TOTAL_PINS];
byte pin_servo[TOTAL_PINS];

Servo servos[MAX_SERVOS];

void setup()
{
  Serial.begin(57600);
  Serial.println("BLE Arduino Slave");
 
  /* Default all to digital input */
  for (int pin = 0; pin < TOTAL_PINS; pin++)
  {
    // Set pin to input with internal pull up
    pinMode(pin, INPUT);
    digitalWrite(pin, HIGH);

    // Save pin mode and state
    pin_mode[pin] = INPUT;
    pin_state[pin] = LOW;
  }

  // Default pins set to 9 and 8 for REQN and RDYN
  // Set your REQN and RDYN here before ble_begin() if you need
  //ble_set_pins(3, 2);
 
  // Set your BLE Shield name here, max. length 10
  //ble_set_name("My Name");
 
  // Init. and start BLE library.
  ble_begin();
}

static byte buf_len = 0;

void ble_write_string(byte *bytes, uint8_t len)
{
  if (buf_len + len > 20)
  {
    for (int j = 0; j < 15000; j++)
      ble_do_events();
   
    buf_len = 0;
  }
 
  for (int j = 0; j < len; j++)
  {
    ble_write(bytes[j]);
    buf_len++;
  }
   
  if (buf_len == 20)
  {
    for (int j = 0; j < 15000; j++)
      ble_do_events();
   
    buf_len = 0;
  } 
}

byte reportDigitalInput()
{
  if (!ble_connected())
    return 0;

  static byte pin = 0;
  byte report = 0;
 
  if (!IS_PIN_DIGITAL(pin))
  {
    pin++;
    if (pin >= TOTAL_PINS)
      pin = 0;
    return 0;
  }
 
  if (pin_mode[pin] == INPUT)
  {
      byte current_state = digitalRead(pin);
           
      if (pin_state[pin] != current_state)
      {
        pin_state[pin] = current_state;
        byte buf[] = {'G', pin, INPUT, current_state};
        ble_write_string(buf, 4);
       
        report = 1;
      }
  }
 
  pin++;
  if (pin >= TOTAL_PINS)
    pin = 0;
   
  return report;
}

void reportPinCapability(byte pin)
{
  byte buf[] = {'P', pin, 0x00};
  byte pin_cap = 0;
                   
  if (IS_PIN_DIGITAL(pin))
    pin_cap |= PIN_CAPABILITY_DIGITAL;
           
  if (IS_PIN_ANALOG(pin))
    pin_cap |= PIN_CAPABILITY_ANALOG;

  if (IS_PIN_PWM(pin))
    pin_cap |= PIN_CAPABILITY_PWM;

  if (IS_PIN_SERVO(pin))
    pin_cap |= PIN_CAPABILITY_SERVO;

  buf[2] = pin_cap;
  ble_write_string(buf, 3);
}

void reportPinServoData(byte pin)
{
//  if (IS_PIN_SERVO(pin))
//    servos[PIN_TO_SERVO(pin)].write(value);
//  pin_servo[pin] = value;
 
  byte value = pin_servo[pin];
  byte mode = pin_mode[pin];
  byte buf[] = {'G', pin, mode, value};        
  ble_write_string(buf, 4);
}

byte reportPinAnalogData()
{
  if (!ble_connected())
    return 0;
   
  static byte pin = 0;
  byte report = 0;
 
  if (!IS_PIN_DIGITAL(pin))
  {
    pin++;
    if (pin >= TOTAL_PINS)
      pin = 0;
    return 0;
  }
 
  if (pin_mode[pin] == ANALOG)
  {
    uint16_t value = analogRead(pin);
    byte value_lo = value;
    byte value_hi = value>>8;
   
    byte mode = pin_mode[pin];
    mode = (value_hi << 4) | mode;
   
    byte buf[] = {'G', pin, mode, value_lo};        
    ble_write_string(buf, 4);
  }
 
  pin++;
  if (pin >= TOTAL_PINS)
    pin = 0;
   
  return report;
}

void reportPinDigitalData(byte pin)
{
  byte state = digitalRead(pin);
  byte mode = pin_mode[pin];
  byte buf[] = {'G', pin, mode, state};        
  ble_write_string(buf, 4);
}

void reportPinPWMData(byte pin)
{
  byte value = pin_pwm[pin];
  byte mode = pin_mode[pin];
  byte buf[] = {'G', pin, mode, value};        
  ble_write_string(buf, 4);
}

void sendCustomData(uint8_t *buf, uint8_t len)
{
  uint8_t data[20] = "Z";
  memcpy(&data[1], buf, len);
  ble_write_string(data, len+1);
}

byte queryDone = false;

void loop()
{
  while(ble_available())
  {
    byte cmd;
    cmd = ble_read();
    Serial.write(cmd);
   
    // Parse data here
    switch (cmd)
    {
      case 'V': // query protocol version
        {
          byte buf[] = {'V', 0x00, 0x00, 0x01};
          ble_write_string(buf, 4);
        }
        break;
     
      case 'C': // query board total pin count
        {
          byte buf[2];
          buf[0] = 'C';
          buf[1] = TOTAL_PINS;
          ble_write_string(buf, 2);
        }       
        break;
     
      case 'M': // query pin mode
        { 
          byte pin = ble_read();
          byte buf[] = {'M', pin, pin_mode[pin]}; // report pin mode
          ble_write_string(buf, 3);
        } 
        break;
     
      case 'S': // set pin mode
        {
          byte pin = ble_read();
          byte mode = ble_read();
         
          if (IS_PIN_SERVO(pin) && mode != SERVO && servos[PIN_TO_SERVO(pin)].attached())
            servos[PIN_TO_SERVO(pin)].detach();
 
          /* ToDo: check the mode is in its capability or not */
          /* assume always ok */
          if (mode != pin_mode[pin])
          {             
            pinMode(pin, mode);
            pin_mode[pin] = mode;
         
            if (mode == OUTPUT)
            {
              digitalWrite(pin, LOW);
              pin_state[pin] = LOW;
            }
            else if (mode == INPUT)
            {
              digitalWrite(pin, HIGH);
              pin_state[pin] = HIGH;
            }
            else if (mode == ANALOG)
            {
              if (IS_PIN_ANALOG(pin)) {
                if (IS_PIN_DIGITAL(pin)) {
                  pinMode(PIN_TO_DIGITAL(pin), LOW);
                }
              }
            }
            else if (mode == PWM)
            {
              if (IS_PIN_PWM(pin))
              {
                pinMode(PIN_TO_PWM(pin), OUTPUT);
                analogWrite(PIN_TO_PWM(pin), 0);
                pin_pwm[pin] = 0;
                pin_mode[pin] = PWM;
              }
            }
            else if (mode == SERVO)
            {
              if (IS_PIN_SERVO(pin))
              {
                pin_servo[pin] = 0;
                pin_mode[pin] = SERVO;
                if (!servos[PIN_TO_SERVO(pin)].attached())
                  servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
              }
            }
          }
           
  //        if (mode == ANALOG)
  //          reportPinAnalogData(pin);
          if ( (mode == INPUT) || (mode == OUTPUT) )
            reportPinDigitalData(pin);
          else if (mode == PWM)
            reportPinPWMData(pin);
          else if (mode == SERVO)
            reportPinServoData(pin);
        }
        break;

      case 'G': // query pin data
        {
          byte pin = ble_read();
          reportPinDigitalData(pin);
        }
        break;
       
      case 'T': // set pin digital state
        {
          byte pin = ble_read();
          byte state = ble_read();
         
          digitalWrite(pin, state);
          reportPinDigitalData(pin);
        }
        break;
     
      case 'N': // set PWM
        {
          byte pin = ble_read();
          byte value = ble_read();
         
          analogWrite(PIN_TO_PWM(pin), value);
          pin_pwm[pin] = value;
          reportPinPWMData(pin);
        }
        break;
     
      case 'O': // set Servo
        {
          byte pin = ble_read();
          byte value = ble_read();

          if (IS_PIN_SERVO(pin))
            servos[PIN_TO_SERVO(pin)].write(value);
          pin_servo[pin] = value;
          reportPinServoData(pin);
        }
        break;
     
      case 'A': // query all pin status
        for (int pin = 0; pin < TOTAL_PINS; pin++)
        {
          reportPinCapability(pin);
          if ( (pin_mode[pin] == INPUT) || (pin_mode[pin] == OUTPUT) )
            reportPinDigitalData(pin);
          else if (pin_mode[pin] == PWM)
            reportPinPWMData(pin);
          else if (pin_mode[pin] == SERVO)
            reportPinServoData(pin); 
        }
       
        queryDone = true;
        {
          uint8_t str[] = "ABC";
          sendCustomData(str, 3);
        }
      
        break;
         
      case 'P': // query pin capability
        {
          byte pin = ble_read();
          reportPinCapability(pin);
        }
        break;
       
      case 'Z':
        {
          byte len = ble_read();
          byte buf[len];
          for (int i=0;i<len;i++)
            buf[i] = ble_read();
          Serial.println("->");
          Serial.print("Received: ");
          Serial.print(len);
          Serial.println(" byte(s)");
          Serial.print(" Hex: ");
          for (int i=0;i<len;i++)
            Serial.print(buf[i], HEX);
          Serial.println();
        }
    }

    // send out any outstanding data
    ble_do_events();
    buf_len = 0;
   
    return; // only do this task in this loop
  }

  // process text data
  if (Serial.available())
  {
    byte d = 'Z';
    ble_write(d);

    delay(5);
    while(Serial.available())
    {
      d = Serial.read();
      ble_write(d);
    }
   
    ble_do_events();
    buf_len = 0;
   
    return;   
  }

  // No input data, no commands, process analog data
  if (!ble_connected())
    queryDone = false; // reset query state
   
  if (queryDone) // only report data after the query state
  {
    byte input_data_pending = reportDigitalInput(); 
    if (input_data_pending)
    {
      ble_do_events();
      buf_len = 0;
     
      return; // only do this task in this loop
    }
 
    reportPinAnalogData();
   
    ble_do_events();
    buf_len = 0;
   
    return; 
  }
   
  ble_do_events();
  buf_len = 0;
}

 

//

 

 

// DateTime : 2018-08-30 오전 6:40:07
// by Ok-Hyun Park
//
#include <Servo.h>
#include <SPI.h>
#include <EEPROM.h>
#include <boards.h>
#include <RBL_nRF8001.h>
#include "Boards.h"
#define PROTOCOL_MAJOR_VERSION   0 //
#define PROTOCOL_MINOR_VERSION   0 //
#define PROTOCOL_BUGFIX_VERSION  2 // bugfix
#define PIN_CAPABILITY_NONE      0x00
#define PIN_CAPABILITY_DIGITAL   0x01
#define PIN_CAPABILITY_ANALOG    0x02
#define PIN_CAPABILITY_PWM       0x04
#define PIN_CAPABILITY_SERVO     0x08
#define PIN_CAPABILITY_I2C       0x10
// pin modes
//#define INPUT                  0x00 // defined in wiring.h
//#define OUTPUT                 0x01 // defined in wiring.h
#define ANALOG                   0x02 // analog pin in analogInput mode
#define PWM                      0x03 // digital pin in PWM output mode
#define SERVO                    0x04 // digital pin in Servo output mode
byte pin_mode[TOTAL_PINS];
byte pin_state[TOTAL_PINS];
byte pin_pwm[TOTAL_PINS];
byte pin_servo[TOTAL_PINS];
Servo servos[MAX_SERVOS];
//
void setup(){
  Serial.begin(57600);
  Serial.println("BLE Arduino Slave");
  /*Default all to digital input*/
  for(int pin=0;pin<TOTAL_PINS;pin++){
    pinMode(pin,INPUT); digitalWrite(pin,HIGH); // Set pin to input with internal pull up
    pin_mode[pin]=INPUTpin_state[pin]=LOW// Save pin mode and state
  }
  // Default pins set to 9 and 8 for REQN and RDYN
  // Set your REQN and RDYN here before ble_begin()if you need
  //ble_set_pins(3,2);
  // Set your BLE Shield name here,max.length 10
  //ble_set_name("My Name");
  // Init.and start BLE library.
  ble_begin();
}
//
static byte buf_len=0;
//
void ble_write_string(byte *bytes,uint8_t len){
  if(buf_len+len>20){ for(int j=0;j<15000;j++)ble_do_events(); buf_len=0; }
  for(int j=0;j<len;j++){ ble_write(bytes[j]); buf_len++; }
  if(buf_len==20){ for(int j=0;j<15000;j++)ble_do_events(); buf_len=0; }
}
//
byte reportDigitalInput(){
  if(!ble_connected())return 0;
  static byte pin=0byte report=0;
  if(!IS_PIN_DIGITAL(pin)){ if(++pin>=TOTAL_PINS)pin=0return 0; }
  if(pin_mode[pin]==INPUT){
    byte current_state=digitalRead(pin);
    if(pin_state[pin]!=current_state){
      pin_state[pin]=current_statebyte buf[]={'G',pin,INPUT,current_state}; ble_write_string(buf,4); report=1;
    }
  }
  if(++pin>=TOTAL_PINS)pin=0;
  return report;
}
//
void reportPinCapability(byte pin){
  byte buf[]={'P',pin,0x00}; byte pin_cap=0;
  if(IS_PIN_DIGITAL(pin))pin_cap|=PIN_CAPABILITY_DIGITAL;
  if(IS_PIN_ANALOG(pin) )pin_cap|=PIN_CAPABILITY_ANALOG;
  if(IS_PIN_PWM(pin)    )pin_cap|=PIN_CAPABILITY_PWM;
  if(IS_PIN_SERVO(pin)  )pin_cap|=PIN_CAPABILITY_SERVO;
  buf[2]=pin_cap;
  ble_write_string(buf,3);
}
//
void reportPinServoData(byte pin){
  // if(IS_PIN_SERVO(pin))servos[PIN_TO_SERVO(pin)].write(value);
  // pin_servo[pin]=value;
  byte value=pin_servo[pin]; byte mode=pin_mode[pin]; byte buf[]={'G',pin,mode,value}; ble_write_string(buf,4);
}
//
byte reportPinAnalogData(){
  if(!ble_connected())return 0;
  static byte pin=0byte report=0;
  if(!IS_PIN_DIGITAL(pin)){ if(++pin>=TOTAL_PINS)pin=0return 0; }
  if(pin_mode[pin]==ANALOG){
    uint16_t value=analogRead(pin);
    byte value_lo=valuebyte value_hi=value>>8byte mode=pin_mode[pin];
    mode=(value_hi<<4)|mode;
    byte buf[]={'G',pin,mode,value_lo};
    ble_write_string(buf,4);
  }
  if(++pin>=TOTAL_PINS)pin=0;
  return report;
}
//
void reportPinDigitalData(byte pin){
  byte state=digitalRead(pin); byte mode=pin_mode[pin]; byte buf[]={'G',pin,mode,state}; ble_write_string(buf,4);
}
//
void reportPinPWMData(byte pin){
  byte value=pin_pwm[pin]; byte mode=pin_mode[pin]; byte buf[]={'G',pin,mode,value}; ble_write_string(buf,4);
}
//
void sendCustomData(uint8_t *buf,uint8_t len){
  uint8_t data[20]="Z"memcpy(&data[1],buf,len); ble_write_string(data,len+1);
}
//
byte queryDone=false;
//
void loop(){
  while(ble_available()){
    byte cmd;
    cmd=ble_read();
    Serial.write(cmd);
    // Parse data here
    switch(cmd){
      case 'V'byte buf[]={'V',0x00,0x00,0x01};ble_write_string(buf,4); break// query protocol version
      case 'C'byte buf[2]; buf[0]='C';  buf[1]=TOTAL_PINS;             ble_write_string(buf,2); break// query board total pin count
      case 'M'byte pin=ble_read(); byte buf[]={'M',pin,pin_mode[pin]}; ble_write_string(buf,3); break// query pin mode
      case 'S':{ // set pin mode
        byte pin=ble_read(); byte mode=ble_read();
        if(IS_PIN_SERVO(pin)&&mode!=SERVO&&servos[PIN_TO_SERVO(pin)].attached())servos[PIN_TO_SERVO(pin)].detach();
        /*ToDo: check the mode is in its capability or not*/
        /*assume always ok*/
        if(mode!=pin_mode[pin]){
          pinMode(pin,mode); pin_mode[pin]=mode;
          if     (mode==OUTPUT){ digitalWrite(pin,LOW ); pin_state[pin]=LOW;  }
          else if(mode==INPUT ){ digitalWrite(pin,HIGH); pin_state[pin]=HIGH; }
          else if(mode==ANALOG){
            if(IS_PIN_ANALOG(pin)){
              if(IS_PIN_DIGITAL(pin))pinMode(PIN_TO_DIGITAL(pin),LOW);
            }
          }
          else if(mode==PWM){
            if(IS_PIN_PWM(pin)){
              pinMode(PIN_TO_PWM(pin),OUTPUT); analogWrite(PIN_TO_PWM(pin),0); pin_pwm[pin]=0pin_mode[pin]=PWM;
            }
          }
          else if(mode==SERVO){
            if(IS_PIN_SERVO(pin)){
              pin_servo[pin]=0pin_mode[pin]=SERVO;
              if(!servos[PIN_TO_SERVO(pin)].attached())servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
            }
          }
        }
        //if(mode==ANALOG)reportPinAnalogData(pin);
        if    ((mode==INPUT)||(mode==OUTPUT))reportPinDigitalData(pin);
        else if(mode==PWM)reportPinPWMData(pin);
        else if(mode==SERVO)reportPinServoData(pin);
        break;
      }
      case 'G'byte pin=ble_read(); reportPinDigitalData(pin); break// query pin data
      case 'T'byte pin=ble_read(); byte state=ble_read(); digitalWrite(pin,state); reportPinDigitalData(pin); break// set pin digital state
      case 'N':{ // set PWM
        byte pin=ble_read(); byte value=ble_read();
        analogWrite(PIN_TO_PWM(pin),value);
        pin_pwm[pin]=valuereportPinPWMData(pin); break;
      }
      case 'O':{ // set Servo
        byte pin=ble_read(); byte value=ble_read();
        if(IS_PIN_SERVO(pin))servos[PIN_TO_SERVO(pin)].write(value);
        pin_servo[pin]=valuereportPinServoData(pin); break;
      }
      case 'A':{ // query all pin status
        for(int pin=0;pin<TOTAL_PINS;pin++){
          reportPinCapability(pin);
          if    ((pin_mode[pin]==INPUT)||(pin_mode[pin]==OUTPUT))reportPinDigitalData(pin);
          else if(pin_mode[pin]==PWM)reportPinPWMData(pin);
          else if(pin_mode[pin]==SERVO)reportPinServoData(pin);
        }
        queryDone=trueuint8_t str[]="ABC"sendCustomData(str,3);
        break;
      }
      case 'P':{ byte pin=ble_read(); reportPinCapability(pin); break; } // query pin capability
      case 'Z':{
        byte len=ble_read(); byte buf[len];
        for(int i=0;i<len;i++)buf[i]=ble_read();
        Serial.println("->");
        Serial.print("Received: "); Serial.print(len);    Serial.println(" byte(s)");
        Serial.print(" Hex: ");     for(int i=0;i<len;i++)Serial.println(buf[i],HEX);
      }
    }
    // send out any outstanding data
    ble_do_events(); buf_len=0return// only do this task in this loop
  }
  // process text data
  if(Serial.available()){
    byte d='Z'ble_write(d); delay(5);
    while(Serial.available()){ d=Serial.read(); ble_write(d); }
    ble_do_events(); buf_len=0return;
  }
  // No input data,no commands,process analog data
  if(!ble_connected())queryDone=false// reset query state
  if(queryDone){
    byte input_data_pending=reportDigitalInput();
    if(input_data_pending){ ble_do_events(); buf_len=0return; }
    reportPinAnalogData();
    ble_do_events(); buf_len=0return;
  }
  ble_do_events();
  buf_len=0;
}

 

프로토콜을 먼저 구하고

무슨 기능을 사용하고 있는지 리스트를 만들고

보드 스펙을 놓고서 

소스코드를 분석하셔야합니다.

 

자료가 부족해서 분석이 어려우므로 타인에게 설명을 해달라는 것은 불가능에 가깝습니다.

 

하나만 분석해드리죠

  // process text data
  if(Serial.available()){                                       // 시리얼 데이터가 있으면
    byte d='Z'ble_write(d); delay(5);                         // 'Z' 컴맨드를 ble로 전송한 후
    while(Serial.available()){ d=Serial.read(); ble_write(d); } // 시리얼 수신데이터를 ble로 전송
    ble_do_events(); buf_len=0return;
  }
//
      case 'A':{ // query all pin status
        for(int pin=0;pin<TOTAL_PINS;pin++){
          reportPinCapability(pin);
          if((pin_mode[pin]==INPUT)||(pin_mode[pin]==OUTPUT))reportPinDigitalData(pin);
          else if(pin_mode[pin]==PWM)reportPinPWMData(pin);
          else if(pin_mode[pin]==SERVO)reportPinServoData(pin);
        }
        queryDone=trueuint8_t str[]="ABC"sendCustomData(str,3);
        break;
      }
queryDone은 'A' 컴맨드에서 true로 설정됩니다.
아래 if()문은 'A' 컴맨드에 대한 응답으로 보시면 됩니다.

  if(queryDone){                                  // queryDone가 True면
    byte input_data_pending=reportDigitalInput(); // 디지털핀 mode 상태를 보고하고
    if(input_data_pending){ ble_do_events(); buf_len=0return; }
    reportPinAnalogData();                        // 아나로그 mode 상태도 보고함
    ble_do_events(); buf_len=0return;
  }
//
시리얼 모니터 입력내용을 'Z' 컴맨드로 ble로 출력했으니
ble의 'Z'컴맨드도 시리얼모니터로 출력하겠죠?

      case 'Z':{                                 // ble 'Z'컴맨드 수신
        byte len=ble_read(); byte buf[len];      // len(길이) 수신
        for(int i=0;i<len;i++)buf[i]=ble_read(); // len 갯수만큼 읽어서 버퍼에 저장
        Serial.println("->");
        Serial.print("Received: "); Serial.print(len);    Serial.println(" byte(s)"); // len 출력
        Serial.print(" Hex: ");     for(int i=0;i<len;i++)Serial.println(buf[i],HEX); // 16진ASC로 출력
      }

ble에서 오는 데이터는 컴맨드 다음에 len가 붙는 점이 다릅니다.
시리얼모니터의 데이터는 몇바이트를 입력하는지 알 수가 없으므로 len를 붙이고 있지 않습니다.

 

  • BASIC4MCU 작성글 SNS에 공유하기
  • 페이스북으로 보내기
  • 트위터로 보내기
  • 구글플러스로 보내기

댓글 0

조회수 1,397

등록된 댓글이 없습니다.

질문게시판HOME > 질문게시판 목록

MCU, AVR, 아두이노 등 전자공학에 관련된 질문을 무료회원가입 후 작성해주시면 전문가가 답변해드립니다.

ATMEGA128PWMLED초음파
아두이노AVR블루투스LCD
UART모터적외선ATMEGA
전체 스위치 센서
게시물 검색

Privacy Policy
MCU BASIC ⓒ 2017