블로그 이미지
개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
솔웅

최근에 받은 트랙백

글 보관함

calendar

1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31        


MIT App Inventor



Today I've developed Mega Millions Jackpot number generator using MIT App Inventor.

MIT App Inventor is GUI Android Mobile App Development tool.



Wikipedia

App Inventor for Android

App Inventor for Android is an open-source web application originally provided by Google, and now maintained by the Massachusetts Institute of Technology (MIT).

It allows newcomers to computer programming to create software applications for the Android operating system (OS). It uses a graphical interface, very similar to Scratch and the StarLogo TNG user interface, which allows users to drag-and-drop visual objects to create an application that can run on Android devices. In creating App Inventor, Google drew upon significant prior research in educational computing, as well as work done within Google on online development environments.[1]



MIT App Inventor Website


What is MIT App Inventor?

MIT App Inventor is an innovative beginner's introduction to programming and app creation that transforms the complex language of text-based coding into visual, drag-and-drop building blocks. The simple graphical interface grants even an inexperienced novice the ability to create a basic, fully functional app within an hour or less.






This is the Mega Jackpot Number generator what I've developed today.





This is the apk file. so you can install in your android phone if you have.


LotteryNumber.apk





See the graphical design of the app here.




Here is core logic of the app.





The first 'for' statement is the one to get 5 quick pick numbers.

The second 'for' statement makes list who has numbers from 1~75.

3rd 'for' statement will remove 70 items from the list randomly.

so we will get 5 jackpot numbers for Mega Million.


The good point of this logic is simplification.


If you pickup random numbers from the 75 list then you need to use double 'for' statement to sort the numbers.

The logic is going to be much more complicated.


Above logic is much simpler because it is already sorted.




저작자 표시 비영리 동일 조건 변경 허락
신고


Grew up like this in 4 days. :)





In a meanwhile, I've updated the source code.


/*
* For Automated Mung Bean Sprouts growing machine
*
* Watering every 2 hours
* play music when watering
*
 * Relay pin 12
* speaker pin 8
*
 * created 22 Jan 2017
 *
 * updated 24 Jan 2017
 * -Added one more song (Butterfly)
 * -Randomly select a song (Schoolbell or Butterfly)
 * -watering every an hour from every 2 hours.
 * -increase watering time (Schoolbell - play 3 times, Butterfly - play 2 times)
*
 *by Douglas Changsoo Park
*
 */
 
#include <SimpleTimer.h>
#include "pitches.h"
 
int relay = 12;
int melodyPin = 8;
 
SimpleTimer timer;
 
int schoolbell_melody[] = {
  NOTE_G4,  NOTE_G4,  NOTE_A4,  NOTE_A4,  NOTE_G4,  NOTE_G4,  NOTE_E4,  NOTE_G4,  NOTE_G4,  NOTE_E4,  NOTE_E4,  NOTE_D4,  0,
  NOTE_G4,  NOTE_G4,  NOTE_A4,  NOTE_A4,  NOTE_G4,  NOTE_G4,  NOTE_E4,  NOTE_G4,  NOTE_E4,  NOTE_D4,  NOTE_E4,  NOTE_C4,  0 };
 
int schoolbell_noteDurations[] = {  1,1,1,1,  1,1,2,  1,1,1,1,  3,1,  1,1,1,1,  1,1,2,  1,1,1,1,  3,1  };

int butterfly_melody[] = {
  NOTE_G4,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_D4,NOTE_D4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_G4,NOTE_G4,
  NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_D4,NOTE_D4,NOTE_C4,NOTE_E4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,0,
  NOTE_D4,NOTE_D4,NOTE_D4,NOTE_D4,NOTE_D4,NOTE_E4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_E4,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_G4,
  NOTE_G4,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_D4,NOTE_D4,NOTE_C4,NOTE_E4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,0
};

int butterflyNoteDurations[] = {
  1,1,2,1,1,2, 1,1,1,1,1,1,2,  1,1,1,1,1,1,2, 1,1,1,1,1,1,3,1,
  1,1,1,1,1,1,2,1,1,1,1,1,1,2,  1,1,2,1,1,2,1,1,1,1,1,1,3,1
};

void setup() {
  // put your setup code here, to run once:
  pinMode(relay, OUTPUT);
 digitalWrite(relay, HIGH);
  //timer.setInterval(7200000, watering);
  timer.setInterval(3600000, watering);
  //timer.setInterval(25000, watering); // Test Mode
}
 
void loop() {
  // put your main code here, to run repeatedly:
  timer.run();
}
 
void watering() {
  digitalWrite(relay, LOW);
  int song = random(1,3);
  if(song == 1) {
    music_schoolBell();
    music_schoolBell();
    music_schoolBell();
  } else {
    music_butterfly();
    music_butterfly();
  }
  digitalWrite(relay, HIGH);
  noTone(8);
}
 
void music_schoolBell() {
    int size = sizeof(schoolbell_melody) / sizeof(int);
  for(int thisNote = 0; thisNote < size; thisNote++) {
      int noteDuration = 250 * schoolbell_noteDurations[thisNote];
      tone(melodyPin, schoolbell_melody[thisNote], noteDuration);
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      noTone(melodyPin);
  }
}

void music_butterfly(){
  int size = sizeof(butterfly_melody) / sizeof(int);
  for (int thisNote = 0; thisNote < size; thisNote++) {
      int noteDuration = 250 * butterflyNoteDurations[thisNote];
      tone(melodyPin, butterfly_melody[thisNote], noteDuration);
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      noTone(melodyPin);
  }
}


저작자 표시 비영리 동일 조건 변경 허락
신고


Automated Mung Bean Sprouts growing machine

(자동 콩나물 재배기)




※ How to grow mung bean sprouts


1. Rinse over beans and soak around for a day (24 hours)
2. Place net in pot and spread beans on the net and then cover the pot with something to make inside dark.
3. watering every 2 hours ==> Automate this step



※ Target : develop automated watering machine using Arduino



※  Components and Supplies



- Arduino Uno : $13.98



- 12V mini water pump  : $7.72



- 1 channel Relay : $3.37



- 12V Adapter + Barrel Jack : $5.3


- Small Breadboard and some jumper wires


- a piece of hose





※ Circuit




※ Source Code


/*
* For Automated Mung Bean Sprouts growing machine
*
* Watering every 2 hours
* play music when watering
*
 * Relay pin 12
* speaker pin 8
*
 * created 22 Jan 2017
*
 *by Douglas Changsoo Park
*
 */
 
#include <SimpleTimer.h>
#include "pitches.h"
 
int relay = 12;
 
SimpleTimer timer;
 
int melody[] = {
  NOTE_G4,
  NOTE_G4,
  NOTE_A4,
  NOTE_A4,
  NOTE_G4,
  NOTE_G4,
  NOTE_E4,
  NOTE_G4,
  NOTE_G4,
  NOTE_E4,
  NOTE_E4,
  NOTE_D4,
  0,
  NOTE_G4,
  NOTE_G4,
  NOTE_A4,
  NOTE_A4,
  NOTE_G4,
  NOTE_G4,
  NOTE_E4,
  NOTE_G4,
  NOTE_E4,
  NOTE_D4,
  NOTE_E4,
  NOTE_C4,
  0 };
 
  int noteDurations[] = {
  1,1,1,1,
  1,1,2,
  1,1,1,1,
  3,1,
  1,1,1,1,
  1,1,2,
  1,1,1,1,
  3,1
  };
 
void setup() {
  // put your setup code here, to run once:
  pinMode(relay, OUTPUT);
 digitalWrite(relay, HIGH);
  timer.setInterval(7200000, watering);

}
 
void loop() {
  // put your main code here, to run repeatedly:
  timer.run();
}
 
void watering() {
  digitalWrite(relay, LOW);
  music();

  music();

  digitalWrite(relay, HIGH);
  noTone(8);
}
 
void music() {
  for(int thisNote = 0; thisNote < 26; thisNote++) {
      int noteDuration = 250 * noteDurations[thisNote];
      tone(8, melody[thisNote], noteDuration);
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      noTone(8);
  }
}




※ Picture





※ Youtube



저작자 표시 비영리 동일 조건 변경 허락
신고


Configuring the onboard WiFi  (English)



Yún(雲)은 액세스 포인트 역할을하지만 기존 네트워크에도 연결할 수 있습니다. 이 지침은 Yún(雲)을 무선 네트워크에 연결하는 과정을 안내합니다. Yún(雲)은 WEP, WPA 및 WPA2 암호화를 지원하는 네트워크는 물론 암호화되지 않은 네트워크에도 연결할 수 있습니다.


처음 Yún(雲)의 전원을 켜면 Linino-XXXXXXXX라는 WiFi 네트워크가 생성됩니다. 컴퓨터를 이 네트워크에 연결하십시오.


IP 주소를 얻은 다음 웹 브라우저를 열고 주소 표시 줄에 http : //linino.local 또는 192.168.240.1을 입력하십시오. 잠시 후 암호를 묻는 웹 페이지가 나타납니다. "doghunter"를 입력하고 로그인 버튼을 클릭하십시오.






현재 네트워크 연결에 대한 진단 정보가있는 페이지를 찾을 수 있습니다. 첫 번째는 WiFi 인터페이스이고, 두 번째는 Ethernet 연결입니다. 진행하려면 Configuration 버튼을 누르십시오.





새 페이지에서 Yún(雲)을 구성하고 고유 한 이름을 지정하고 연결할 네트워크를 식별합니다.


board 이름 입력란에 Arduino의 고유 이름을 입력하십시오. 이것을 나중에 참조 할 때 사용할 것입니다.


Arduino에 8 자 이상의 암호를 선택하십시오. 이 필드를 공백으로두면 기본 암호 인 doghunter가 유지됩니다


원하는 경우 시간대와 국가를 설정할 수 있습니다. 이러한 옵션은 로컬 WiFi 네트워크 연결에 도움이되므로 설정하는 것이 좋습니다. 현지 시간대를 설정하면 해당 국가의 규제 도메인도 선택됩니다.


연결하려는 WiFi 네트워크의 이름을 입력하십시오.


보안 유형을 선택하고 암호를 입력하십시오.





Configure & Restart (구성 및 재시작) 버튼을 누르면 Arduino가 재설정되고 지정된 네트워크에 연결됩니다. Arduino 네트워크는 잠시 후 종료됩니다.





이제 Yún(雲)에게 지정한 네트워크에 가입 할 수 있습니다.





Programming the 32U4 over WiFi


Yún(雲)이 컴퓨터와 동일한 네트워크에 있으면 무선으로 연결하여 프로그래밍 할 수 있습니다.

Yún(雲)을 구성한 후 구성 설정에서 지정한 네트워크에 연결하십시오. Arduino IDE를 엽니 다.

Tools> Port 메뉴에서 Yún(雲)의 이름과 IP 주소를 나열하는 항목이 보여야 합니다. board 메뉴에서 Arduino Yún(雲)을 선택하십시오.

Blink example (File > Examples > 01Basics > Blink)을 열고 board에 스케치를 업로드하십시오. 관리자 암호를 묻는 메시지가 나타납니다. 구성 화면에서 입력 한 것을 사용하십시오.

프로그램이 업로드되면 32U4 프로세서가 다시 시작됩니다. 13 번 핀에 연결된 LED가 깜박 거려야합니다.


Using the onboard Ethernet


Yun을 Ethernet 케이블로 유선 네트워크에 연결하면 DHCP를 통해 자동으로 연결을 시도합니다. board는 Wi-Fi와 마찬가지로 포트 메뉴에 표시됩니다.

Yun을 컴퓨터에 직접 연결하려면 컴퓨터의 인터페이스가 고정 IP 주소를 갖도록 구성하거나 DHCP 서버의 역할을 수행하십시오.

NB : Ethernet 인터페이스는 eth1이 아니라 eth0입니다.


Tutorial (English)





Tutorial (Korean)






Communicating with LininoOS via Bridge


Bridge 라이브러리는 Arduino와 LininoOS 간의 통신을 가능하게합니다. 아래에 표현된 대로 둘 사이에서 서로 다른 종류의 커뮤니케이션을 용이하게 해 주는 여러개의 utility class들이 있습니다. 좀 더 자세한 내용은 Bridge library reference 페이지를 참조하세요.





WiFi 및 Ethernet 인터페이스, USB 호스트 및 SD 카드는 모두 AR9331에 연결됩니다. Bridge 라이브러리를 사용하면 이러한 장치로 작업하고 스크립트를 실행하고 웹 서비스와 통신 할 수 있습니다.


The Console

Bridge를 기반으로 한 콘솔을 사용하면 직렬 모니터에서와 같이 무선으로 정보를 Yún(雲)에서 컴퓨터로 보낼 수 있습니다. 그것은 SSH를 통해 Yún(雲)과 컴퓨터 사이의 보안 연결을 만듭니다.

다음을 Yún(雲)에 Load 하세요.

#include <Console.h>

const int ledPin = 13; // the pin that the LED is attached to
int incomingByte;      // a variable to read incoming serial data into

void setup() {
  // initialize serial communication:
  Bridge.begin();
  Console.begin();

  while (!Console){
    ; // wait for Console port to connect.
  }
  Console.println("You're connected to the Console!!!!");
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // see if there's incoming serial data:
  if (Console.available() > 0) {
    // read the oldest byte in the serial buffer:
    incomingByte = Console.read();
    // if it's a capital H (ASCII 72), turn on the LED:
    if (incomingByte == 'H') {
      digitalWrite(ledPin, HIGH);
    }
    // if it's an L (ASCII 76) turn off the LED:
    if (incomingByte == 'L') {
      digitalWrite(ledPin, LOW);
    }
  }
  delay(100);
}




콘솔을 보려면 포트 메뉴에서 Yún(雲)의 이름과 IP 주소를 선택하십시오. Yún(雲)은 컴퓨터가 Yún(雲)과 동일한 LAN에있는 경우에만 포트 메뉴에 나타납니다. board가 다른 네트워크에 있으면 Ports (포트) 메뉴에 표시되지 않습니다. 포트 모니터를 엽니 다. Yún(雲)의 암호를 묻는 메시지가 나타납니다.


터미널 창을 열고 ssh root@yourYunsName.local 'telnet localhost 6571'을 입력 한 다음 enter를 눌러 콘솔을 볼 수도 있습니다.


주의 : Windows를 사용하는 경우 터미널 에뮬레이터를 설치해야합니다. PuTTY는 좋은 프로그램입니다. PuTTY에서는 위의 두 명령을 별도로 입력해야합니다.


'H'를 입력하면 핀 13의 LED가 켜지고 'L'을 입력하면 LED가 꺼집니다.


Process


프로세스 명령을 사용하면 Arduino를 통해 LininoOS에서 Linux 프로세스를 실행할 수 있습니다.

다음 예에서 LininoOS는 curl을 사용하여 서버에 연결하고 ASCII 텍스트를 다운로드합니다. 텍스트를 직렬 연결로 인쇄합니다.

#include <Process.h>

void setup() {
  // Initialize Bridge
  Bridge.begin();

  // Initialize Serial
  Serial.begin(9600);

  // Wait until a Serial Monitor is connected.
  while (!Serial);

  // run various example processes
  runCurl();
}

void loop() {
  // Do nothing here.
}

void runCurl() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  Process p;        // Create a process and call it "p"
  p.begin("curl");  // Process that launch the "curl" command
  p.addParameter("http://arduino.cc/asciilogo.txt"); // Add the URL parameter to "curl"
  p.run();      // Run the process and wait for its termination

  // Print arduino logo over the Serial
  // A process output can be read with the stream methods
  while (p.available()>0) {
    char c = p.read();
    Serial.print(c);
  }
  // Ensure the last bit of data is sent.
  Serial.flush();
}




Using Bridge to pass information between processors

Bridge를 사용하면 키 / 값 쌍을 사용하여 두 프로세서간에 정보를 전달할 수 있습니다.

이 예제는 Bridge 라이브러리를 사용하여 REST 호출을 통해 board의 디지털 및 아날로그 핀에 액세스하는 방법을 보여줍니다. 브라우저를 통해 REST 스타일 호출을 사용할 때 자신의 API를 만드는 방법을 보여줍니다.

이 예제를 실행할 때 컴퓨터가 Yun과 동일한 네트워크에 있는지 확인하십시오.

board를 프로그래밍했으면 핀에 값을 요청하고 핀에 값을 쓰고 핀을 입력 또는 출력으로 구성 할 수 있습니다.

REST 암호가 해제되어 있으면 다음과 같은 URL 구조의 브라우저를 사용할 수 있습니다.



원하는 경우 브라우저 대신 명령 행에서 curl 명령을 사용할 수 있습니다.

Bridge, YunServer 및 YunClient 라이브러리를 포함해야합니다.


#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h>



Yun이 연결된 클라이언트를 청취 할 수 있도록 서버를 인스턴스화하십시오.

YunServer server;

setup ()에서 디버깅을 위해 직렬 통신을 시작하고 Bridge가 시작되는 동안 핀 13의 내장 LED를 HIGH로 설정하십시오. Bridge.begin ()이 (가) 차단 중이며 완료하는 데 약 2 초가 걸립니다. 브리지가 시동되면 LED를 끄십시오.

void setup() {
  Serial.begin(9600);
  pinMode(13,OUTPUT);
  digitalWrite(13, LOW);
  Bridge.begin();
  digitalWrite(13, HIGH);



setup ()의 두 번째 부분에서는 YunServer의 인스턴스에 localhost에서만 들어오는 연결을 수신 대기하도록 지시합니다. LininoOS와의 연결은 핀 분석 및 제어를 위해 32U4 프로세서로 전달됩니다. 이것은 포트 5555에서 발생합니다. server.begin ()을 사용하여 서버를 시작합니다.



server.listenOnLocalhost();
  server.begin();
}


loop ()에서 YunClient의 인스턴스를 만들어 연결을 관리합니다. 클라이언트가 연결되면 사용자 정의 기능 (아래 설명 참조)에서 요청을 처리하고 완료되면 연결을 닫습니다.

루프 ()의 끝 부분에 지연을 두는 것은 프로세서가 너무 많은 일을하지 않도록하는 데 도움이됩니다.


void loop() {
  YunClient client = server.accept();

  if (client) {
    process(client);
    client.stop();
  }

  delay(50);
}



YunClient를 인수로 사용하는 process라는 함수를 만듭니다. 들어오는 정보를 보관할 문자열을 작성하여 명령을 읽으십시오. REST 명령을 기능 (디지털, 아날로그 및 모드)별로 구문 분석하고 해당 이름이 지정된 함수에 정보를 전달하십시오.


void process(YunClient client) {
  String command = client.readStringUntil('/');

  if (command == "digital") {
    digitalCommand(client);
  }
  if (command == "analog") {
    analogCommand(client);
  }
  if (command == "mode") {
    modeCommand(client);
  }
}




디지털 명령을 처리하는 함수를 만듭니다. 클라이언트를 인수로 승인하십시오. 명령의 핀과 값을 보유 할 로컬 변수를 작성하십시오.

void digitalCommand(YunClient client) {
  int pin, value;


 
client.parseInt ()를 사용하여 핀에 대한 클라이언트의 요청을 구문 분석하십시오.

핀의 뒤의 문자가 「/」의 경우는, URL가 1 또는 0의 값을 가지는 것을 의미합니다. 이 값은 핀에 값을 할당하여 HIGH 또는 LOW로 만듭니다. 말미의 「/」가없는 경우, 지정된 핀으로부터 값을 읽어들입니다.

pin = client.parseInt();

  if (client.read() == '/') {
    value = client.parseInt();
    digitalWrite(pin, value);
  }
  else {
    value = digitalRead(pin);
  }


값을 클라이언트에 인쇄하고 데이터 저장소 키를 현재 핀 값으로 업데이트하십시오.

F ()에서 클라이언트에 값을 래핑하면 플래시 메모리 형태로 인쇄됩니다. 이렇게하면 URL과 같은 긴 문자열을 처리 할 때 유용한 SRAM의 공간을 절약 할 수 있습니다.

키는 핀이 될 것이고, 타입이 될 것이다. 예를 들어 디지털 핀 2에 대해 D2가 저장됩니다.이 값은 핀이 현재 설정되어 있거나 핀에서 읽은 값이됩니다.

client.print(F("Pin D"));
  client.print(pin);
  client.print(F(" set to "));
  client.println(value);

  String key = "D";
  key += pin;
  Bridge.put(key, String(value));
}


아날로그 입력 핀으로 작업 할 때 D 대신 A로 키를 설정하는 것을 제외하면 동일한 방식으로 아날로그 통화를 처리하는 기능을 설정하십시오.


void analogCommand(YunClient client) {
  int pin, value;

  pin = client.parseInt();

  if (client.read() == '/') {
    value = client.parseInt();
    analogWrite(pin, value);

    // Send feedback to client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" set to analog "));
    client.println(value);

    String key = "D";
    key += pin;
    Bridge.put(key, String(value));
  }
  else {
    value = analogRead(pin);

    client.print(F("Pin A"));
    client.print(pin);
    client.print(F(" reads analog "));
    client.println(value);

    String key = "A";
    key += pin;
    Bridge.put(key, String(value));
  }
}




핀 모드 변경을 처리하는 하나 이상의 함수를 만듭니다. YunClient를 인수로 받아들이고 핀 번호를 저장할 로컬 변수를 만듭니다. 디지털 및 아날로그 기능에서와 마찬가지로 핀 값을 읽습니다.

void modeCommand(YunClient client) {
  int pin;
  pin = client.parseInt();



URL이 올바른지 확인하십시오.


if (client.read() != '/') {
    client.println(F("error"));
    return;
  }



유효한 URL 인 경우 URL을 문자열로 저장하십시오. 모드가 입출력이면, 핀을 구성하여 클라이언트에보고하십시오. 문자열이이 값과 일치하지 않으면 오류를 반환합니다.

String mode = client.readStringUntil('\r');

  if (mode == "input") {
    pinMode(pin, INPUT);
    // Send feedback to client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" configured as INPUT!"));
    return;
  }

  if (mode == "output") {
    pinMode(pin, OUTPUT);
    // Send feedback to client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" configured as OUTPUT!"));
    return;
  }

  client.print(F("error: invalid mode "));
  client.print(mode);
}


이 예제에 대한 자세한 내용은 Bridge Example 페이지에서 확인할 수 있습니다.




최종 수정 2011 년 11 월 4 일 SM

Arduino 시작 안내서의 텍스트는 Creative Commons Attribution-ShareAlike 3.0 License에 따라 사용이 허가되었습니다. 가이드의 코드 샘플은 공개 도메인으로 배포됩니다.

저작자 표시 비영리 동일 조건 변경 허락
신고


Getting Started with the Arduino Yún LininoOS



Arduino Yún(雲)은 다른 Arduino board와는 많이 다릅니다. 프로그래밍 중에는 Arduino Leonardo와 매우 유사하며 동일한 프로세서 인 Atmel ATmega32U4를 사용합니다. 그리고 LininoOS 및 OpenWrt 무선 스택을 실행하는 Atheros AR9331이라는 추가 프로세서가 있습니다. USB를 통해 32U4를 프로그래밍하는 것은 Arduino Leonardo와 동일합니다. Wi-Fi 네트워크에 연결하도록 Yún(雲)을 구성하면 Wi-Fi를 통해 32U4를 프로그래밍 할 수 있습니다.


Quick Start

Arduino Yún(雲)은 모든 board에 공통적 인 통합 개발 환경 인 Arduino Software (IDE)를 사용하여 프로그래밍됩니다. Getting Started에서 설명 된대로 PC에 이 IDE가 설치되어 있어야합니다.



Installing Drivers for the Yún(雲)

OSX


첫 번째로 Yún(雲)을 Mac에 연결하면 "Keyboard Setup Assistant"가 시작됩니다. Yún(雲)을 위해 따로 구성 할 것은 없습니다. 창 왼쪽 상단의 빨간색 버튼을 클릭하여이 대화 상자를 닫을 수 있습니다.




Windows


Arduino Software (IDE)의 Windows 버전에는 이미 적절한 드라이버가 들어 있습니다. 설치하면 운영 체제에서 설치하게됩니다. Yún(雲)을 연결하면 드라이버가 자동으로 설치됩니다.



Linux
Ubuntu 10.0.4 이상용 드라이버를 설치할 필요는 없지만 포트 5353이 방화벽에 의해 차단되지 않도록하십시오.


Open your first sketch

LED blink 예제 스케치를 엽니 다 : File > Examples >01.Basics > Blink.





Select your board type and port


Arduino 또는 Genuino board에 해당하는 Tools> Board 메뉴에서 항목을 선택해야합니다.





Tools | Serial Port menu에서 board의 serial device를 선택하십시오. COM3 나 그 이상이 될 것입니다. (COM1 및 COM2는 일반적으로 하드웨어 직렬 포트 용으로 예약 됨). 이것을 알려면 board를 disconnect 한 후 메뉴를 다시 여세요. 사라지는 항목이 Arduino 또는 Genuino board 입니다. board를 다시 연결하고 해당 직렬 포트를 선택하십시오. board가 WiFi에서 제대로 구성되면 스크린 샷과 같이 포트 목록에서 board를 찾을 수 있습니다.





Upload the program

이제 environment에서 'Upload'버튼을 클릭하기 만하면됩니다. 잠시 기다린 후 - board의 RX 및 TX LED가 깜박이는 것이 보여야 합니다. 업로드가 완료되면 'Done uploading'라는 메시지가 상태 표시 줄에 나타납니다.





업로드가 완료되고 몇 초 후에 on-board LED가 깜박일 것입니다. If it does, congratulations! Arduino Yún(雲)을 잘 사용하고 있는 겁니다. 문제가있는 경우 troubleshooting suggestions을 참조하십시오.




Get inspired

이제 Yún(雲) board를 설정하고 프로그래밍 했으므로  Project Hub 튜토리얼 플랫폼에서 영감을 얻거나 Bridge library and examples를 더 깊이 파고들 수 있습니다. Yún(雲)  hardware page에서 추가 기술 정보를 확인할 수도 있습니다.






Please Read...



Arduino Leonardo와의 차이점





YUn은 32U4 칩 외에도 OpenWrt를 기반으로 한 LininoOS라는 임베디드 시스템 용 Linux 배포판을 실행하는 Atheros AR9331이라는 추가 프로세서를 보유하고 있습니다. Python 2.7의 full install도 포함되어 있습니다.

Yún(雲)은 Leonardo보다 다양한 물리적 특성과 connectors 를 가지고 있습니다. on-board SD 슬롯, Ethernet jack 및 USB-A Host connector가 있습니다. Yún(雲)에는 ower barrel connector가 없습니다. 마이크로 USB 커넥터에서 전원을 공급받을 수 있습니다.

5V 레귤레이터가 내장되어 있지 않습니다. 5V 이상으로 Yún(雲)에 전원을 공급하면 손상 될 수 있습니다. 마이크로 USB 연결에서 Yún(雲)에 전원을 공급하지 않으면 board의 VIN 및 5V 핀에 전원을 공급할 수 있습니다. VIN 핀을 사용하는 경우 5V 이상을 공급할 수 없으므로 board가 손상 될 수 있습니다. 되도록 USB 연결로 Yún(雲)에 전원을 공급하는 것이 권장됩니다.

SD, Ethernet 및 USB-A 커넥터는 물리적으로 32U4 프로세서에 연결되지 않으며 AR9331에 연결됩니다.

Yún(雲)의 32U4는 Serial1을 사용할 수 없다는 점을 제외하면 Leonardo와 같은 방식으로 작동합니다. AR9331 프로세서와 통신하기 위해 예약되어 있습니다.

또한 Yún(雲)에는 WiFi 모듈이 내장되어있어 무선 라우터에 연결하거나 액세스 포인트 역할을 할 수 있습니다.

32u4, WiFi 및 AR9331 프로세서에는 모두 자체 재설정 단추가 있습니다.






Yún(雲)에는 전원, WLAN 연결, WAN 연결 및 USB를 나타내는 몇 가지 상태 LED가 있습니다. 또한 핀 13은 상태 표시등 중 하나에 연결됩니다.





OpenWrt LininoOS


LininoOS는 약 3000 개의 패키지가 내장되어 있으며 OpenWRT 배포를 기반으로합니다. LininoOS는 GPG 서명이있는 패키지 관리 기능을 갖춘 완벽하게 쓰기 가능한 파일 시스템을 제공합니다. LininoIO와 통합되어 IoT 공간을위한 완벽한 리눅스 시스템입니다. LininoOS는 Arduino Yun을 위해 많은 혁신적인 기능들을 제공합니다.


    LininoIO는 마이크로 프로세서 환경에 마이크로 컨트롤러 기능을 통합 할 수있는 소프트웨어 프레임 워크입니다. LininoOS를 사용하여 Linux 측에서 Node.js, Python, Bash 등을 사용하여 응용 프로그램을 간단하게 작성하여 board와 모든 장치를 완벽하게 제어 할 수 있습니다.


    Ideino Node.js가 포함 된 Node.js는 빠르고 확장 가능한 네트워크 애플리케이션을 손쉽게 구축 할 수 있도록 Chrome의 JavaScript 런타임에 구축 된 플랫폼입니다. Node.js는 가볍고 효율적이며 분산 장치에서 실행되는 데이터 집약적 인 실시간 애플리케이션에 완벽한 이벤트 구동 비 차단 I / O 모델을 사용합니다. Ideino는 node.js 응용 프로그램을 작성하고 디버깅 할 수있는 임베디드 편집기입니다.


    AllJoyn은 범용 소프트웨어 프레임 워크와 연결된 제품 및 소프트웨어 응용 프로그램 간의 상호 운용성을 지원하여 동적 인 근거리 네트워크를 만들 수있는 핵심 시스템 세트를 제공하는 오픈 소스 프로젝트입니다.


지속적인 개선과 OpenWrt 커뮤니티와 Arduino 커뮤니티의 제안으로 인해 LininoOS는 계속 개선 되고 있습니다. Yún(雲)에 설치된 LininoOS 를 설치한 지 오래 된 경우 upgrade tutorial 을 확인하고 사용 가능한 최신 버전을 실행하고 있는지 확인하십시오.


웹 인터페이스에 액세스하는 방법은 아래에 설명되어 있습니다.



Install additional software on Linux


Yún(雲)은 "curl"과 "python"을 포함하여 LininoOS에 사전 설치된 여러 소프트웨어를 제공합니다. Yún(雲)에 다른 소프트웨어를 설치 할 수 있습니다. Linux 시스템에서는 "opkg"도구를 사용하여 추가 소프트웨어를 설치할 수 있습니다. LininoOS에 대한 사전 컴파일 된 패키지는 최신 버전에서 찾을 수 있습니다.
LininoOS 시스템과 인터페이스 할 때 Arduino 's Bridge 라이브러리를 통해 액세스하거나 SSH를 통해 명령 행을 사용해야합니다. command line에 익숙하지 않다면 자주 사용되는 프로그램과 몇 가지 기본 사항에 대해 읽어보십시오.


Python



LininoOS에는 Python 2.7 설치가 포함되어 있으며, 여기에 응용 프로그램이나 스크립트를 작성할 수 있습니다. Python에 대한 자세한 내용은 Python 2.7 documentation pages를 참조하십시오.


처음으로 Python을 시작한다면 많은 훌륭한 자료가 온라인에 있습니다. "Learn Python the Hard Way" 는 자신 만의 스크립트로 시작하고 실행하기 위해 알아야 할 모든 것을 다루고 있습니다.



External storage on the Yún


Yún(雲)에 내장 된 비 휘발성 메모리는 쓰기가 제한되어 있으므로 사용하지 않는 것이 좋습니다.


데이터 저장을 위해 microSD 카드 나 thumb drive와 같은 외부 메모리를 사용하거나 스크립트, 웹 페이지 등을 사용할 수 있습니다. Yún(雲)이 32U4를 통해 이러한 드라이브에 대한 정보에 액세스하여 저장하려면 volume의 root에 arduino라는 디렉토리가 있어야합니다.


Web services


LininoOS는 클라이언트와 서버에 REST를 사용합니다. REST는 "Representational State Transfer"의 머리 글자입니다. Arduino 하드웨어의 여러 부분을 URL을 통해 노출하는 소프트웨어 아키텍처입니다.


기본적으로 REST API 액세스는 비밀번호로 보호됩니다. 암호를 변경하지 않고 서비스에 액세스하려면이 설정을 변경할 수 있습니다. 이 설정을 변경하려면 Yún(雲) 구성 패널을 입력하십시오. 페이지 하단에 액세스 변경을위한 토글이 표시됩니다.



REST의 개념에 대한 훌륭한 소개는 여기에서 찾을 수 있습니다.


Yún(雲)이 인식하는 세 가지 REST 엔드 포인트는 다음과 같습니다.


    / arduino
    /데이터
    /mailbox



"/ arduino"디렉토리에는 사전 구성된 것이 없습니다. end point 다음에 URL에 추가 된 것은 웹 서버에서 32U4의 스케치로 전달됩니다. 스케치 내부에서 API를 정의 할 수 있습니다. board의 핀에 액세스하는 방법을 보려면 Bridge 예제를 참조하십시오.


"/ data"는 내부 키 / 값 저장에 액세스하는 데 사용됩니다. 사용할 수있는 통화는 다음과 같습니다.


    / put / KEY / VALUE : 저장소에 값을 저장합니다.
    / get / KEY : JSON에서 요청한 키의 값을 얻습니다.
    / get : JSON에서 전체 저장 목록을 가져옵니다.
    / delete : 내부 저장소를 삭제합니다.



"mailbox"은 Mailbox라는 대기열에 메시지를 추가하는 데 사용됩니다. 메시지 대기열은 Linux 시스템에 저장되며 Arduino 마이크로 컨트롤러에서 읽을 수 있습니다. 사용 가능한 REST 호출은 다음과 같습니다.


    "/ mailbox / message"
   



Resetting the processors (AR9331, WiFi, and 32U4)


LininoOS를 재부팅하는 AR9331을 다시 시작하려면 아날로그 입력 핀과 board의 LED에 가까운 "Yún(雲) RST"재설정 버튼을 누릅니다.


32U4를 다시 시작하고 현재 설치된 Arduino 스케치를 다시 시작하려면 Ethernet 포트 옆에있는 버튼을 두 번 누릅니다.


WiFi 용 재설정 버튼은 USB-A 커넥터 옆에 있습니다. "WLAN RST"라고 표시되어 있습니다. 버튼을 누르면 WLAN LED가 깜박입니다.


다른 네트워크로 이동하여 더 이상 웹 인터페이스를 통해 Yún(雲)에 무선으로 액세스 할 수없는 경우 Wi-Fi 재설정 버튼 (WLAN RST)을 5 초 이상 30 초 미만으로 길게 눌러 Yún(雲)의 네트워크 구성을 재설정 할 수 있습니다. AR9331 프로세서가 재부팅됩니다. WiFi 구성이 재설정되고 Yún(雲)이 자체 Wi-Fi 네트워크 Arduino Yún(雲)-XXXXXXXXXXXXX를 시작합니다. 다른 모든 수정 / 구성은 유지됩니다.


LininoOS 배포를 기본 상태로 재설정하려면 WiFi 재설정 버튼 (WLAN RST)을 30 초 이상 누릅니다. board는 원래 설정으로 되돌아갑니다. 상자에서 꺼내거나 이전에 다시 플래시 한 LininoOS 이미지의 최신 업데이트로 가져 왔습니다. 무엇보다도 이것은 설치된 모든 파일과 네트워크 설정을 제거합니다.



Resetting the password


웹 패널 암호를 재설정하고 변경할 수 있습니다. USB 케이블로 Arduino Yún(雲)을 컴퓨터에 연결하고 YunSerialTerminal 스케치를 업로드하십시오. Arduino IDE의 Bridge 예제에서 찾을 수 있습니다. Yún(雲) 부팅이 완료되면 직렬 모니터를 열고 드롭 다운 메뉴에서 New Line 문자를 선택한 다음 Enter 키를 누릅니다. 아래와 같은 것이 직렬 모니터에 나타나야합니다.






이제 암호를 변경하려면 passwd 명령을 실행해야합니다. passwd를 직렬 모니터 입력에 입력하고 Enter 키를 누릅니다. 새 암호를 입력하라는 메시지가 나타나면 암호를 다시 입력하여 확인하십시오. 원하는 경우 약한 암호 오류를 무시할 수 있습니다. 입력 한 두 암호가 일치하면 시스템 암호가 변경되고 새 암호로 웹 패널에 액세스 할 수 있습니다.



Serial re-enumeration on reset.


Yún(雲)에는 직렬 통신을 처리하는 전용 칩이 없기 때문에 직렬 포트가 가상이라는 것을 의미합니다. 이는 운영 체제와 board 자체의 소프트웨어 루틴입니다. Arduino를 연결할 때 컴퓨터가 직렬 포트 드라이버 인스턴스를 생성하는 것처럼 32u4는 부트 로더를 실행할 때마다 직렬 인스턴스를 생성합니다. 이 board는 USB의 CDC (Connected Device Class) 드라이버의 인스턴스입니다.


즉, 32U4 프로세서를 리셋 할 때마다 USB 직렬 연결이 끊어지고 다시 설정됩니다. board가 직렬 포트 목록에서 사라지고 목록이 다시 열거됩니다. Yún(雲)에 대한 직렬 연결이 열려있는 프로그램은 연결을 끊습니다. 이것은 USB 연결 (보조 ATmega8U2 또는 ATmega16U2 프로세서에서 유지 관리)을 닫지 않고 주 프로세서 (ATmega328P)를 재설정 할 수있는 Arduino Uno와는 대조적입니다. 이 차이점은 드라이버 설치, 업로드 및 통신에 영향을 미칩니다.
직렬 포트를 열면 재설정되지 않습니다.


Yún(雲)은 컴퓨터에서 직렬 포트를 열 때 스케치를 다시 시작하지 않습니다. 즉, board에서 컴퓨터로 이미 전송 된 직렬 데이터 (예 : setup ()에서 전송 된 대부분의 데이터 포함)가 표시되지 않습니다.


이는 아래에 설명 된 콘솔에도 적용됩니다.



즉, 직렬 또는 콘솔 print (), println () 또는 write () 문을 setup ()에 사용하면 직렬 모니터 또는 콘솔 연결을 열 때 해당 문구가 표시되지 않습니다. 이 문제를 해결하려면 포트가 다음과 같이 열려 있는지 여부를 확인할 수 있습니다.

// Serial Monitor가 열릴 때까지 프로그램을 멈춘다.
   while (! Serial);


또는
// Console이 열릴 때까지 프로그램을 중지합니다.
   while (! Console);

저작자 표시 비영리 동일 조건 변경 허락
신고


Arduino Yun





Overview (English)



Arduino Yún(雲)은 ATmega32u4와 Atheros AR9331을 기반으로 한 마이크로 컨트롤러 보드입니다. Atheros 프로세서는 Linino OS 라는 이름의 OpenWrt 기반의 Linux distribution을 지원합니다. 보드에는 내장 Ethernet 및 WiFi 지원, USB-A 포트, 마이크로 SD 카드 슬롯, 20 개의 디지털 입 / 출력 핀 (7 개는 PWM 출력으로, 12 개는 아날로그 입력으로 사용 가능), 16 MHz crystal oscillator, 마이크로 USB connection, ICSP 헤더 및 3 개의 리셋 버튼이 있습니다.



NB : 일부 국가에서는 정부 승인없이 WiFi 지원 장치를 판매 할 수 없습니다. 적절한 인증을 기다리는 동안 일부 지역 배급 업체는 WiFi 기능을 비활성화합니다. 그런 나라에 사신다면 Yún(雲)을 구입하기 전에 대리점에 문의하십시오. WiFi를 사용하지 않으려면 이 스케치를 실행하십시오.



Yún(雲)은 보드에 내장 된 Linux distribution onboard 그리고  강력한 네트워크 된 컴퓨터와 communicate 할 수 있는 면에서 다른 Arduino 보드와 차별화됩니다. 거기에다가 cURL과 같은 Linux 명령를 사용해 사용자의 shell이나 python 스크립트를 만들어 이러한 상호작용을 견고하게 할 수 있습니다. Yún(雲)은 ATmega32u4를 사용하는 Leonardo와 유사하지만, Linux에 탑재되어 있는 면이 다릅니다. (USB 통신 기능이 내장되어있어 보조 프로세서가 필요 없음).


NB : Yun Release 5 새로운 Arduino Yun R5는 이러한 기능들이 이전 릴리스와 다릅니다.

    - 전원 공급 시스템은 AREF에 5V를 제공합니다.
    - 레이아웃이 수정되어 USB 신호용 구멍 2 개와 GP6 및 GPIO13 (LED2) 용 구멍 2 개가 추가되었습니다.

여기서 board  warranty  정보를 찾을 수 있습니다.



Getting Started




이 섹션에서 보드 구성에 필요한 모든 정보를 찾을 수 있습니다. 시작할 준비가 되셨습니까? 2014 년 10 월 이전에 Arduino Yún(雲)을 구입 한 경우에는 Yún(雲) Open WRT OS Getting Started Page를 참조하시고 2015 년 이 후에 구입했으면  Arduino Yún(雲)  Linino OS Getting Started page 페이지를 확인하십시오.


Need Help?



   
Technical specs

Yún(雲)에는 두 개의 프로세서가 있기 때문에 이 섹션에서는 두 테이블 각각의 특성을 보여줍니다.


AVR Arduino microcontroller


Microcontroller


ATmega32U4
Operating Voltage 5V
Input Voltage 5 V
Digital I/O Pins 20
PWM Output 7
Analog I/O Pins 12
DC Current per I/O Pin 40 mA on I/O Pins; 50 mA on 3,3 Pin
Flash Memory 32 KB (of which 4 KB used by bootloader)
SRAM 2.5 KB
EEPROM 1 KB
Clock Speed 16 MHz



Arduino Microprocessor


Processor


Atheros AR9331
Architecture MIPS
Operating Voltage 3.3V
Ethernet 802.3 10/100Mbit/s
WiFi 802.11b/g/n 2.4 GHz
USB Type 2.0 Host
Card Reader Micro-SD
RAM 64 MB DDR2
Flash Memory 16 MB
SRAM 2.5 KB
EEPROM 1 KB
Clock Speed 400 MHz




Documentation
 


OSH: Schematics



Arduino Yún(雲)은 오픈 소스 하드웨어입니다! 다음 파일을 사용하여 자신의 보드를 만들 수 있습니다.






Power


5V DC로 micro-USB 연결을 통해 보드에 전원을 공급하는 것을 권장합니다. Vin 핀을 통해 보드에 전원을 공급하는 경우, 규정 된 5VDC를 공급해야합니다. 높은 전압에 대비한 on-board voltage regulator가 없으므로 보드가 손상 될 수 있습니다.


Yún(雲)도 PoE 전원 공급 장치와 호환되지만 이 기능을 사용하려면 보드에 PoE 모듈을 장착하거나 사전 조립 된 보드를 구입해야합니다.


참고 : PoE 어댑터가있는 Yún(雲)의 초기 모델은 보드에 12V를 잘못 제공했습니다. 곧 업데이트 된 버전에서는 5V를 전달하는 distributors가 제공 될 것입니다. 보드에 잘못된 PoE 어댑터가 있다고 생각 되시면 support@arduino.org로 문의하십시오.
   

전원 핀은 다음과 같습니다.

    VIN. Arduino 보드의 입력 전압. 다른 Arduino 보드와 달리,이 핀을 통해 보드에 전원을 공급하려는 경우 규정 된 5V를 제공해야합니다.
    5V. 전원 공급 장치는 보드의 마이크로 컨트롤러 및 기타 구성 요소에 전원을 공급하는 데 사용됩니다. 이것은 VIN 또는 USB에 의해 제공 될 수 있습니다.
    3V3. on-board regulator에서 생성되는 3.3V 전원. 최대 전류 소모는 50mA입니다.
    GND. Ground pins.
    IOREF. 보드의 I / O 핀이 작동하는 전압 (예, 보드의 VCC). 이것은 Yún(雲)에서 5V입니다.



Memory


ATmega32u4는 32KB (부트 로더 용으로 4KB 사용)입니다. 또한 2.5KB의 SRAM과 1KB의 EEPROM (EEPROM 라이브러리로 읽고 쓸 수 있음)이 있습니다.


AR9331의 메모리는 프로세서 내부에 내장되어 있지 않습니다. RAM과 저장 메모리는 외부에서 연결됩니다. Yún(雲)에는 64 MB의 DDR2 RAM과 16 MB의 플래시 메모리가 있습니다. 플래시 메모리는 공장에서 Linino OS라는 OpenWrt 기반의 Linux 배포판으로 미리 로드됩니다. 프로그램을 설치할 때나 구성 파일을 변경할 때와 같이 공장 출하시 이미지의 내용을 변경할 수 있습니다. "WLAN RST" 버튼을 30 초 동안 눌러 공장 출하 상태로 되돌릴 수 있습니다.


Linino OS 설치는 사용 가능한 16MB의 내장 플래시 메모리 중 약 9MB를 차지합니다. 응용 프로그램 설치를 위한 디스크 공간이 더 필요하면 마이크로 SD 카드를 사용할 수 있습니다.


Input and Output


Atheros AR9331의 I / O 핀에 액세스 할 수 없습니다. 모든 I / O 라인은 32U4에 연결됩니다.


Yún(雲)에있는 20 개의 디지털 I / O 핀 각각은 pinMode (), digitalWrite () 및 digitalRead () 함수를 사용하여 입력 또는 출력으로 사용할 수 있습니다. 그것들은 5 볼트에서 작동합니다. 각 핀은 최대 40 mA를 제공하거나 수신 할 수 있으며 20-50 kOhms의 내부 풀업 저항 (기본적으로 연결이 끊어짐)이 있습니다. 또한 일부 핀에는 특수 기능이 있습니다 : 직렬 : 0 (RX) 및 1 (TX). ATmega32U4 하드웨어 직렬 기능을 사용하여 TTL 직렬 데이터를 수신 (RX) 및 전송 (TX)하는 데 사용됩니다. Yún(雲)에서 Serial 클래스는 USB (CDC) 통신을 의미합니다. 0 번과 1 번 핀의 TTL 직렬을 위해서는 Serial1 클래스를 사용하십시오.


ATmega32U4의 하드웨어 시리얼과 Yún(雲)의 AR9331은 함께 연결되어 두 프로세서 간의 통신에 사용됩니다. Linux 시스템에서 일반적인 것처럼 AR9331의 직렬 포트는 시스템에 액세스하기위한 콘솔에 노출되어 있습니다. 즉, 스케치에서 Linux가 제공하는 프로그램과 도구에 액세스 할 수 있습니다.


    TWI : 2 (SDA) 및 3 (SCL). 와이어 라이브러리를 사용하여 TWI 통신을 지원.
    외부 인터럽트 : 3 (인터럽트 0), 2 (인터럽트 1), 0 (인터럽트 2), 1 (인터럽트 3) 및 7 (인터럽트 4). 이 핀들은 낮은 값, 상승 또는 하강 edge 또는 값 변경시 인터럽트를 트리거하도록 구성 할 수 있습니다. 자세한 내용은 attachInterrupt () 함수를 참조하십시오. 핀 0과 1은 Linux 프로세서와 통신하는 데 사용되는 하드웨어 직렬 포트이기 때문에 인터럽트로 사용하지 않는 것이 좋습니다. 핀 7은 AR9331 프로세서에 연결되며 장래에 핸드 쉐이크 신호로 사용될 수 있습니다. 인터럽트로 사용하려는 경우 충돌(conflict) 할 가능성이 있으니 주의하세요.
    PWM : 3, 5, 6, 9, 10, 11 및 13. analogWrite () 기능으로 8 비트 PWM 출력을 제공합니다.
    SPI : ICSP 헤더에 있습니다. 이 핀은 SPI 라이브러리를 사용하여 SPI 통신을 지원합니다. SPI 핀은 우노 (Uno)에있는 디지털 I / O 핀에 연결되어 있지 않으므로 ICSP 커넥터에서만 사용할 수 있습니다. 즉, SPI를 사용하지만 Yún(雲)의 6 핀 ICSP 헤더에 연결된 6 핀 ICSP 커넥터가없는 Shild가있는 경우 Shild가 작동하지 않습니다. SPI 핀은 소프트웨어에서 SPI 인터페이스로 구현 된 AR9331 gpio 핀에도 연결됩니다. 이것은 ATMega32u4와 AR9331이 SPI 프로토콜을 사용하여 통신 할 수 있음을 의미합니다.
    LED : 13. 디지털 핀 13에 연결된 내장 LED가 있습니다. 핀이 HIGH 값일 때 LED가 켜지고 핀이 LOW이면 꺼집니다. Yún(雲)에는 전원, WLAN 연결, WAN 연결 및 USB를 나타내는 몇 가지 다른 상태 LED가 있습니다.


    아날로그 입력 : A0 - A5, A6 - A11 (디지털 핀 4, 6, 8, 9, 10 및 12). Yún(雲)에는 A0 ~ A11로 표시된 12 개의 아날로그 입력이 있으며이 모두는 디지털 I / O로도 사용할 수 있습니다. 핀 A0-A5는 Uno와 같은 위치에 나타납니다. 입력 A6-A11은 각각 디지털 I / O 핀 4, 6, 8, 9, 10 및 12에 있습니다. 각각의 아날로그 입력은 10 비트의 분해능 (즉, 1024 개의 상이한 값)을 제공한다. 기본적으로 아날로그 입력은 접지에서 5V까지 측정되지만, AREF 핀과 analogReference () 기능을 사용하여 범위의 상단을 변경할 수 있습니다.
     AREF. 아날로그 입력을위한 기준 전압. analogReference ()와 함께 사용됩니다.
     




보드에는 기능이 다른 3 개의 리셋 버튼이 있습니다.



    Yún(雲) RST. AR9331 마이크로 프로세서를 재설정하려면이 wire를 LOW로하십시오. AR9331을 재설정하면 Linux 시스템이 재부팅됩니다. RAM에 저장된 모든 데이터가 손실되고 실행중인 모든 프로그램이 종료됩니다.
    32U4 RST. 이 라인을 LOW로 설정하면 ATmega32U4 마이크로 컨트롤러를 재설정 할 수 있습니다. 일반적으로 리셋 버튼을 실드에 추가하여 보드의 블록을 막습니다.
    WLAN RST. 이 버튼에는 두 가지 기능이 있습니다. Primarly는 WiFi를 공장 구성으로 복원합니다. 출고시 구성은 Yún(雲)의 WiFi를 액세스 포인트 모드 (AP)에두고 기본 IP 주소 192.168.240.1을 할당하는 것으로 구성됩니다.이 경우 컴퓨터와 함께 Wi-Fi 네트워크에 표시되는 WiFi 네트워크에 연결할 수 있습니다 SSID 이름 "Arduino Yun-XXXXXXXXXXXX", 여기서 12 개의 'X'는 Yún(雲)의 MAC 주소입니다. 연결되면 브라우저의 192.168.240.1 또는 "http : //arduino.local"주소로 Yún(雲)의 웹 패널에 접속할 수 있습니다. WiFi 구성을 복원하면 Linux 환경이 재부팅됩니다. WiFi 구성을 복원하려면 WLAN RST 버튼을 5 초 동안 누르고 있어야합니다. 버튼을 누르면 WLAN 파란색 LED가 깜박이기 시작하고 5 초 후에 버튼을 놓으면 WiFi가 복원 절차가 기록되었음을 나타내는 깜박임을 계속합니다. WLAN RST 버튼의 두 번째 기능은 Linux 이미지를 기본 팩토리 이미지로 복원하는 것입니다. Linux 환경을 복원하려면 버튼을 30 초 동안 눌러야합니다. 공장 이미지를 복원하면 AR9331에 연결된 온보드 플래시 메모리에 저장된 모든 파일과 소프트웨어가 손실됩니다.

   
   
Communication    



Yún(雲)은 컴퓨터와 다른 Arduino 또는 기타 마이크로 컨트롤러와 통신하기위한 여러 가지 기능을 제공합니다. ATmega32U4는 전용 UART TTL (5V) 직렬 통신을 제공합니다. 또한 32U4는 USB를 통한 직렬 (CDC) 통신을 허용하며 컴퓨터의 소프트웨어에 대한 가상 COM 포트로 나타납니다. 또한 이 칩은 표준 USB COM 드라이버를 사용하여 최대 속도 USB 2.0 장치로 작동합니다. Arduino 소프트웨어에는 Arduino 보드와 간단한 텍스트 데이터를주고받을 수있는 직렬 모니터가 포함되어 있습니다. 데이터가 USB 연결을 통해 컴퓨터로 전송되면 보드의 RX 및 TX LED가 깜박입니다.
디지털 핀 0과 1은 32U4와 AR9331 간의 직렬 통신에 사용됩니다.
Ciao 라이브러리를 사용하여 프로세서 간의 통신을 할 수 있습니다.


SoftwareSerial 라이브러리를 사용하면 Yún(雲)의 디지털 핀 중 하나에서 직렬 통신이 가능합니다. 핀 0과 1은 Bridge 라이브러리에서 사용되므로 피해야합니다. 또한 ATmega32U4는 I2C (TWI) 및 SPI 통신을 지원합니다. Arduino 소프트웨어에는 I2C 버스의 사용을 단순화하는 Wire 라이브러리가 포함되어 있습니다. SPI 통신의 경우 SPI 라이브러리를 사용하십시오.


Yún(雲)은 일반 키보드 및 마우스로 표시되며 키보드 및 마우스 클래스를 사용하여 이러한 입력 장치를 제어하도록 프로그래밍 할 수 있습니다.



onboard Ethernet 및 WiFi 인터페이스는 AR9331 프로세서에 직접 노출됩니다. 데이터를 보내고 받으려면 Bridge 라이브러리를 사용하십시오.


Yún(雲)은 또한 Linino OS를 통해 USB 호스트 기능을 제공합니다. USB 플래시 장치와 같은 주변 장치를 추가 저장 장치, 키보드 또는 웹캠에 연결할 수 있습니다. 이러한 장치가 작동하려면 추가 소프트웨어를 다운로드하여 설치해야 할 수 있습니다.




Programming


Yún(雲)은 Arduino 소프트웨어로 프로그래밍 할 수 있습니다 (다운로드). 도구> 보드 메뉴에서 "Arduino Yún(雲)"을 선택하십시오 (여러분 board의 마이크로 컨트롤러에 맞게).


Arduino Yún(雲)의 ATmega32U4에는 external hardware programmer 없이 새로운 코드를 업로드 할 수있는 부트 로더가 미리 설치되어 있습니다. AVR109 프로토콜을 사용하여 통신합니다.


Arduino ISP 또는 이와 유사한 것을 사용하여 ICSP (In-Circuit Serial Programming) 헤더를 통해 부트 로더를 우회하여 마이크로 컨트롤러를 프로그래밍 할 수도 있습니다.



Automatic (Software) Reset


Yún(雲)은 업로드하기 전에 리셋 버튼을 물리적으로 누르지 않고 연결된 컴퓨터에서 실행되는 소프트웨어로 재설정 할 수 있도록 설계되었습니다. 리셋은 Yún(雲)의 가상 (CDC) 직렬 / COM 포트가 1200 보오 (baud)에서 열리고 나서 닫힐 때 트리거됩니다. 이 경우 프로세서가 재설정되어 USB 연결이 끊어집니다 (즉, 가상 직렬 / COM 포트가 사라짐). 프로세서가 재설정되면 부트 로더가 시작되고 약 8 초 동안 활성 상태를 유지합니다.


부트 로더는 Yún(雲)의 재설정 버튼을 눌러 시작할 수도 있습니다. 보드가 처음 전원을 켤 때 부트 로더를 시작하는 대신 사용자 스케치 (있는 경우)로 곧장 점프합니다. Yún(雲)이 리셋을 처리하는 방식 때문에 Arduino 소프트웨어가 업로드 전에 재설정을 시작하게하는 것이 가장 좋습니다. 특히 다른 보드에 업로드하기 전에 재설정 버튼을 누르는 습관이있는 경우에 특히 유용합니다. 소프트웨어가 보드를 재설정 할 수 없으면 보드의 재설정 버튼을 눌러 부트 로더를 시작할 수 있습니다.



USB Overcurrent Protection


Yún(雲)에는 컴퓨터의 USB 포트를 단락 및 과전류로부터 보호하는 재설정 가능한 폴리 퓨즈가 있습니다. 대부분의 컴퓨터가 자체적 인 내부 보호 기능을 제공하지만 퓨즈는 추가 보호 기능을 제공합니다. USB 포트에 500 mA 이상이 인가되면 단락 또는 과부화가 제거 될 때까지 퓨즈가 자동으로 연결을 끊습니다.



Physical Characteristics


Yún(雲) PCB의 최대 길이와 너비는 각각 2.7과 2.1 인치이며 USB 커넥터는 이전 치수를 초과하여 확장됩니다. 4 개의 나사 구멍으로 보드를 표면이나 케이스에 부착 할 수 있습니다. 디지털 핀 7과 8 사이의 거리는 160mil (0.16 ")이며 다른 핀의 100mil 간격의 배수가 아닙니다. 보드의 무게는 32g입니다.


Pin Out




Previous Versions

이 제품의 이전 버전을 소유하고 있습니까? 2014 년 10 월 이전에 Arduino Yún(雲)을 구입 한 경우 Yún(雲) Open WRT OS Getting Started Page를 확인하십시오. 2015 년에 구입 한 경우 Arduino Yún(雲) Linino OS Getting Started page를 확인하십시오.

저작자 표시 비영리 동일 조건 변경 허락
신고

[Arduino] Motion Sensor and Water Level Sensor

2017.01.17 07:56 | Posted by 솔웅


더 재밌게 놀기 연구소



※ Motion Seosor (HC-SR501)



Data sheet :

HC-SR501_Datasheet.pdf



Motion sensor will work without Arduino

When the sensor detects motion, the output pin will go "high"


* Using Arduino


Circuit



Source Code


//www.elegoo.com
//2016.06.13

/*
 * PIR sensor tester
 */
 
int ledPin = 13;                // choose the pin for the LED
int inputPin = 7;               // choose the input pin (for PIR sensor)
int pirState = LOW;             // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
 
void setup() {
  pinMode(ledPin, OUTPUT);      // declare LED as output
  pinMode(inputPin, INPUT);     // declare sensor as input
 
  Serial.begin(9600);
}
 
void loop(){
  val = digitalRead(inputPin);  // read input value
  if (val == HIGH) {            // check if the input is HIGH
    digitalWrite(ledPin, HIGH);  // turn LED ON
    if (pirState == LOW) {
      // we have just turned on
      Serial.println("Motion detected!");
      // We only want to print on the output change, not state
      pirState = HIGH;
    }
  } else {
    digitalWrite(ledPin, LOW); // turn LED OFF
    if (pirState == HIGH){
      // we have just turned of
      Serial.println("Motion ended!");
      // We only want to print on the output change, not state
      pirState = LOW;
    }
  }
}


Result





※ Water Level Sensor


Circuit



Source Code


//www.elegoo.com
//2016.06.13

int adc_id = 0;
int HistoryValue = 0;
char printBuffer[128];

void setup()
{
  Serial.begin(9600);
}

void loop()
{
    int value = analogRead(adc_id); // get adc value

    if(((HistoryValue>=value) && ((HistoryValue - value) > 10)) || ((HistoryValue<value) && ((value - HistoryValue) > 10)))
    {
      sprintf(printBuffer,"ADC%d level is %d\n",adc_id, value);
      Serial.print(printBuffer);
      HistoryValue = value;
    }
}


Result













저작자 표시 비영리 동일 조건 변경 허락
신고


더 재밌게 놀기 연구소


※ Joystick


Circuit



Source Code


//www.elegoo.com
//2016.06.13

// Arduino pin numbers
const int SW_pin = 2; // digital pin connected to switch output
const int X_pin = 0; // analog pin connected to X output
const int Y_pin = 1; // analog pin connected to Y output

void setup() {
  pinMode(SW_pin, INPUT);
  digitalWrite(SW_pin, HIGH);
  Serial.begin(9600);
}

void loop() {
  Serial.print("Switch:  ");
  Serial.print(digitalRead(SW_pin));
  Serial.print("\n");
  Serial.print("X-axis: ");
  Serial.print(analogRead(X_pin));
  Serial.print("\n");
  Serial.print("Y-axis: ");
  Serial.println(analogRead(Y_pin));
  Serial.print("\n\n");
  delay(500);
}


Result






※ MAX7219 LED Dot Matrix Module


Circuit



Add this Library

LedControl.zip



Source Code


//www.elegoo.com
//2016.11.5

//We always have to include the library
#include "LedControl.h"

/*
 Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
 pin 12 is connected to the DataIn
 pin 11 is connected to the CLK
 pin 10 is connected to LOAD
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(12,11,10,1);

/* we always wait a bit between updates of the display */
unsigned long delaytime1=500;
unsigned long delaytime2=50;
void setup() {
  /*
   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
   */
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,8);
  /* and clear the display */
  lc.clearDisplay(0);
}

/*
 This method will display the characters for the
 word "Arduino" one after the other on the matrix.
 (you need at least 5x7 leds to see the whole chars)
 */
void writeArduinoOnMatrix() {
  /* here is the data for the characters */
  byte a[5]={B01111110,B10001000,B10001000,B10001000,B01111110};
  byte r[5]={B00010000,B00100000,B00100000,B00010000,B00111110};
  byte d[5]={B11111110,B00010010,B00100010,B00100010,B00011100};
  byte u[5]={B00111110,B00000100,B00000010,B00000010,B00111100};
  byte i[5]={B00000000,B00000010,B10111110,B00100010,B00000000};
  byte n[5]={B00011110,B00100000,B00100000,B00010000,B00111110};
  byte o[5]={B00011100,B00100010,B00100010,B00100010,B00011100};

  /* now display them one by one with a small delay */
  lc.setRow(0,0,a[0]);
  lc.setRow(0,1,a[1]);
  lc.setRow(0,2,a[2]);
  lc.setRow(0,3,a[3]);
  lc.setRow(0,4,a[4]);
  delay(delaytime1);
  lc.setRow(0,0,r[0]);
  lc.setRow(0,1,r[1]);
  lc.setRow(0,2,r[2]);
  lc.setRow(0,3,r[3]);
  lc.setRow(0,4,r[4]);
  delay(delaytime1);
  lc.setRow(0,0,d[0]);
  lc.setRow(0,1,d[1]);
  lc.setRow(0,2,d[2]);
  lc.setRow(0,3,d[3]);
  lc.setRow(0,4,d[4]);
  delay(delaytime1);
  lc.setRow(0,0,u[0]);
  lc.setRow(0,1,u[1]);
  lc.setRow(0,2,u[2]);
  lc.setRow(0,3,u[3]);
  lc.setRow(0,4,u[4]);
  delay(delaytime1);
  lc.setRow(0,0,i[0]);
  lc.setRow(0,1,i[1]);
  lc.setRow(0,2,i[2]);
  lc.setRow(0,3,i[3]);
  lc.setRow(0,4,i[4]);
  delay(delaytime1);
  lc.setRow(0,0,n[0]);
  lc.setRow(0,1,n[1]);
  lc.setRow(0,2,n[2]);
  lc.setRow(0,3,n[3]);
  lc.setRow(0,4,n[4]);
  delay(delaytime1);
  lc.setRow(0,0,o[0]);
  lc.setRow(0,1,o[1]);
  lc.setRow(0,2,o[2]);
  lc.setRow(0,3,o[3]);
  lc.setRow(0,4,o[4]);
  delay(delaytime1);
  lc.setRow(0,0,0);
  lc.setRow(0,1,0);
  lc.setRow(0,2,0);
  lc.setRow(0,3,0);
  lc.setRow(0,4,0);
  delay(delaytime1);
}

/*
  This function lights up a some Leds in a row.
 The pattern will be repeated on every row.
 The pattern will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void rows() {
  for(int row=0;row<8;row++) {
    delay(delaytime2);
    lc.setRow(0,row,B10100000);
    delay(delaytime2);
    lc.setRow(0,row,(byte)0);
    for(int i=0;i<row;i++) {
      delay(delaytime2);
      lc.setRow(0,row,B10100000);
      delay(delaytime2);
      lc.setRow(0,row,(byte)0);
    }
  }
}

/*
  This function lights up a some Leds in a column.
 The pattern will be repeated on every column.
 The pattern will blink along with the column-number.
 column number 4 (index==3) will blink 4 times etc.
 */
void columns() {
  for(int col=0;col<8;col++) {
    delay(delaytime2);
    lc.setColumn(0,col,B10100000);
    delay(delaytime2);
    lc.setColumn(0,col,(byte)0);
    for(int i=0;i<col;i++) {
      delay(delaytime2);
      lc.setColumn(0,col,B10100000);
      delay(delaytime2);
      lc.setColumn(0,col,(byte)0);
    }
  }
}

/*
 This function will light up every Led on the matrix.
 The led will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void single() {
  for(int row=0;row<8;row++) {
    for(int col=0;col<8;col++) {
      delay(delaytime2);
      lc.setLed(0,row,col,true);
      delay(delaytime2);
      for(int i=0;i<col;i++) {
        lc.setLed(0,row,col,false);
        delay(delaytime2);
        lc.setLed(0,row,col,true);
        delay(delaytime2);
      }
    }
  }
}

void loop() {
  writeArduinoOnMatrix();
  rows();
  columns();
  single();
}



※ ADXL335 Module


Circuit




Source Code


//www.elegoo.com
//2016.06.13

int x, y, z;
int a1 = A0;
int a2 = A1;
int a3 = A2;
void setup()
{
  pinMode(a1,INPUT);
  pinMode(a2,INPUT);
  pinMode(a3,INPUT);
  Serial.begin(9600);  
}
void loop()
{
  x = analogRead(a1);    
  y = analogRead(a2);    
  z = analogRead(a3);    
  Serial.print("x:  ");
  Serial.print(x, DEC); 
  Serial.print(" ");
 Serial.print("y:  ");
  Serial.print(y, DEC);  
  Serial.print(" ");
 Serial.print("z:  ");
  Serial.println(z, DEC);
  delay(100);           
}


Result




저작자 표시 비영리 동일 조건 변경 허락
신고


더 재밌게 놀기 연구소


※ Ultrasonic Sensor (external library)


Circuit



Add zip library to include it in the source code.

HC-SR04_Library.zip


=> This NewPing library converts ping time to distance and print result.



Source Code


//www.elegoo.com
//2016.06.13

#include <NewPing.h>

#define TRIGGER_PIN  12  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN     11  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

void setup() {
  Serial.begin(9600); // Open serial monitor at 115200 baud to see ping results.
}

void loop() {
  delay(500);  // Wait 500ms between pings (about 2 pings/sec). 29ms should be the shortest delay between pings.
  unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
  Serial.print("Ping: ");
  Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance and print result (0 = outside set distance range, no ping echo)
  Serial.println("cm");
}


==> Result






※ Membrane switch (Keypad)


Circuit




Download and add KeyPad Library


http://playground.arduino.cc/Code/Keypad



Source Code


//www.elegoo.com
//2016.06.13

/* @file CustomKeypad.pde
|| @version 1.0
|| @author Alexander Brevig
|| @contact alexanderbrevig@gmail.com
||
|| @description
|| | Demonstrates changing the keypad size and key values.
|| #
*/
#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

void setup(){
  Serial.begin(9600);
}
 
void loop(){
  char customKey = customKeypad.getKey();
 
  if (customKey){
    Serial.println(customKey);
  }
}


==> Result : If you press any button then the value of the button will be display








※ Temperature and Humidity Sensor


Circuit


add SimpleDHT library


SimpleDHT.zip



Source Code


//www.elegoo.com
//2016.06.13

#include <SimpleDHT.h>

// for DHT11,
//      VCC: 5V or 3V
//      GND: GND
//      DATA: 2
int pinDHT11 = 2;
SimpleDHT11 dht11;

void setup() {
  Serial.begin(9600);
}

void loop() {
  // start working...
  Serial.println("=================================");
  Serial.println("Sample DHT11...");
 
  // read with raw sample data.
  byte temperature = 0;
  byte humidity = 0;
  byte data[40] = {0};
  if (dht11.read(pinDHT11, &temperature, &humidity, data)) {
    Serial.print("Read DHT11 failed");
    return;
  }
 
  Serial.print("Sample RAW Bits: ");
  for (int i = 0; i < 40; i++) {
    Serial.print((int)data[i]);
    if (i > 0 && ((i + 1) % 4) == 0) {
      Serial.print(' ');
    }
  }
  Serial.println("");
 
  Serial.print("Sample OK: ");
  Serial.print((int)temperature); Serial.print(" *C, ");
  Serial.print((int)humidity); Serial.println(" %");
 
  // DHT11 sampling rate is 1HZ.
  delay(1000);
}


==> Result



저작자 표시 비영리 동일 조건 변경 허락
신고

[Arduino] 7 Segment, Servo, LCD and Thermometer

2017.01.14 21:38 | Posted by 솔웅


더 재밌게 놀기 연구소



※ Four 7 digital segment with 74 HC595


Circuit

Source Code


int latch=9;  //74HC595  pin 12 STCP
int clock=10; //74HC595  pin 11 SHCP
int data=8;   //74HC595  pin 14 DS

unsigned char table[]=
{0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c
,0x39,0x5e,0x79,0x71,0x00};

void setup() {
  pinMode(latch,OUTPUT);
  pinMode(clock,OUTPUT);
  pinMode(data,OUTPUT);
}
void Display(unsigned char num)
{

  digitalWrite(latch,LOW);
  shiftOut(data,clock,MSBFIRST,table[num]);
  digitalWrite(latch,HIGH);
 
}
void loop() {
  Display(1);
  delay(500);
  Display(2);
  delay(500);
  Display(3);
  delay(500);
  Display(4);
  delay(500);
  Display(5);
  delay(500);
  Display(6);
  delay(500);
  Display(7);
  delay(500);
  Display(8);
  delay(500);
  Display(9);
  delay(500);
  Display(10);
  delay(500);
  Display(11);
  delay(500);
  Display(12);
  delay(500);
  Display(13);
  delay(500);
  Display(14);
  delay(500);
  Display(15);
  delay(500);
}



※ Servo Motor


Circuit




Source Code


//www.elegoo.com
//2016.06.13
/************************************************/
#include <Servo.h>
/************************************************/
Servo myservo;//create servo object to control a servo
/************************************************/
void setup()
{
  myservo.attach(9);//attachs the servo on pin 9 to servo object
  myservo.write(0);//back to 0 degrees
  delay(1000);//wait for a second
}
/*************************************************/
void loop()

  myservo.write(15);//goes to 15 degrees
  delay(1000);//wait for a second
  myservo.write(30);//goes to 30 degrees
  delay(1000);//wait for a second.33
  myservo.write(45);//goes to 45 degrees
  delay(1000);//wait for a second.33
  myservo.write(60);//goes to 60 degrees
  delay(1000);//wait for a second.33
  myservo.write(75);//goes to 75 degrees
  delay(1000);//wait for a second.33
  myservo.write(90);//goes to 90 degrees
  delay(1000);//wait for a second
  myservo.write(75);//back to 75 degrees
  delay(1000);//wait for a second.33
  myservo.write(60);//back to 60 degrees
  delay(1000);//wait for a second.33
  myservo.write(45);//back to 45 degrees
  delay(1000);//wait for a second.33
  myservo.write(30);//back to 30 degrees
  delay(1000);//wait for a second.33
  myservo.write(15);//back to 15 degrees
  delay(1000);//wait for a second
  myservo.write(0);//back to 0 degrees
  delay(1000);//wait for a second
}
/**************************************************/





※ LCD


Circuit




Source Code


//www.elegoo.com
//2016.06.13

/*
  LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD
 and shows the time.

  The circuit:
 * LCD RS pin to digital pin 7
 * LCD Enable pin to digital pin 8
 * LCD D4 pin to digital pin 9
 * LCD D5 pin to digital pin 10
 * LCD D6 pin to digital pin 11
 * LCD D7 pin to digital pin 12
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis() / 1000);
}





※ LCD with Thermometer


Circuit



Source Code


//www.elegoo.com
//2016.06.13

/*
Adafruit Arduino - Lesson 12. Light and Temperature
*/

#include <LiquidCrystal.h>

int tempPin = 0;
int lightPin = 1;

//                BS  E  D4 D5  D6 D7
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup()
{
  lcd.begin(16, 2);
}

void loop()
{
  // Display Temperature in C
  int tempReading = analogRead(tempPin);
  float tempVolts = tempReading * 5.0 / 1024.0;
  float tempC = (tempVolts - 0.5) * 100.0;
  float tempF = tempC * 9.0 / 5.0 + 32.0;
  //         ----------------
  lcd.print("Temp         F  ");
  lcd.setCursor(6, 0);
  lcd.print(tempF);
 
  // Display Light on second row
  int lightReading = analogRead(lightPin);
  lcd.setCursor(0, 1);
  //         ----------------
  lcd.print("Light           "); 
  lcd.setCursor(6, 1);
  lcd.print(lightReading);
  delay(500);
}


저작자 표시 비영리 동일 조건 변경 허락
신고
이전 1 2 다음

티스토리 툴바