부품:

세븐세그먼트 FND507, 1k저항 8개

부품설명:

다음은 FND507의 단자입니다. 

K는 공통단자입니다. FND507은 공통 양극입니다.

회로연결:

FND507이 아니더라도 다음과 같이 연결하면 됩니다.

K는 아두이노의 5V 공급전압에 연결합니다.

그다음, a, b, c, d, e, f, g, dp를 각각 1K저항과 연결하여 

아두이노의 디지털 핀 2,3,4,5,6,7,8,9와 연결합니다. 

코드1: 

Colored By Color Scripter™
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/* 7-segment*/
 
const int pins[]={2,3,4,5,6,7,8,9};
//set bits at each number
                                   //dp/gfedcba
const int numberCode[10]={B11000000, //0
                    B11111001, //1
                    B10100100, //2
                    B10110000, //3
                    B10011001, //4
                    B10010010, //5
                    B10000010, //6
                    B11011000, //7
                    B10000000, //8
                    B10010000}; //9
 
void setup()
{
  for(int i=0; i<7; i++)
  pinMode(pins[i], OUTPUT);
}
 
void loop()
{
for(int n=0; n<10; n++)
   {//show the number
     showNumber(n);
    //delay
     delay(200);
    }
delay(200);
}
 
void showNumber(int number)
{
  boolean value;
  
  for(int bitPosition=0; bitPosition<8; bitPosition++)
  {
    //if number isn't 0 to 9, all off.
    if(number<0 || number>9)
    value = 0;
    //if number is 0 to 9, 
    else
    //Read bit.
    value = bitRead(numberCode[number], bitPosition);
    
    //and Reading value 0, off. Reading value 1, on.
    digitalWrite(pins[bitPosition], value);
  }
 
  return ;
}

 
코드1설명:
loop()에는  
결과적으로 숫자를 보여주는 showNumber()함수와 
시간을 약간 지연시키는 delay가 있습니다.
showNumber()함수를 이해하기 위해서는 
프로그래밍 -> C언어 -> 비트를 읽거나 쓰기 1 - bitRead()를 읽어보세요~ 
그럼 위에 소개한 포스팅을 이해했다고 생각하고 showNumber()함수를 설명할께요. 
우선 맨 위쪽에 이진수들이 있습니다. 
여기서 각각의 이진수는 각 숫자를 세븐 세그먼트에서 나타내기위한 디지털값 입니다. 
비트위치0은 a를 
비트위치1은 b를 
비트위치2는 c를 
비트위치3은 d를 
비트위치4는 e를 
비트위치5는 f를 
비트위치6은 g를 
비트위치7은 dp를  나타내는 거죠. 
예를 들어, 1은 b와 c가 켜져야합니다.
그러니까 b와 c는 LOW를, 나머지 세그먼트에는 HIGH를 출력해야합니다. 
LOW는 0, HIGH는 1이니까 11111001이 되는거죠. 
다음으로 showNumber()함수내부의 if문 입니다. 
함수에 0~9가 아닌 값이 입력되면 0이 출력됩니다. 
0~9의 값이 입력되면, 
입력된 숫자와 대응되는 이진수의 각 비트를 읽습니다. 
그래서 0이면 LOW를 1이면 HIGH를 출력합니다. 
 
코드2:
Colored By Color Scripter™
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
32
33
34
35
36
37
38
39
40
41
42
/* 7-segment*/
 
const int pins[7]={2,3,4,5,6,7,8};
                              //abcdefg
const int numberCode[10][7]={{0,0,0,0,0,0,1}, //0
                             {1,0,0,1,1,1,1}, //1
                             {0,0,1,0,0,1,0}, //2
                             {0,0,0,0,1,1,0}, //3
                             {1,0,0,1,1,0,0}, //4
                             {0,1,0,0,1,0,0}, //5
                             {0,1,0,0,0,0,0}, //6
                             {0,0,0,1,1,0,1}, //7
                             {0,0,0,0,0,0,0}, //8
                             {0,0,0,0,1,0,0}}; //9
 
void setup()
{
  for(int i=0; i<7; i++)
  pinMode(pins[i], OUTPUT);
}
 
void loop()
{
for(int n=0; n<10; n++)
{showNumber(n);
delay(300);}
}
 
void showNumber(int number)
{
  boolean value;
  
  for(int bitPosition=0; bitPosition<7; bitPosition++)
  {
    if(number<0 || number>9)
    value = 0;
    else
    {value = numberCode[number][bitPosition];
     digitalWrite(pins[bitPosition], value);}
  }
    return ;
}
 
코드2설명:
원리는 코드1과 같습니다. 
여기서는 이진수 대신에  
배열을 사용하여 LOW와 HIGH를 타나낸것 뿐 입니다. 
[출처] [세븐세그먼트] 1|작성자 DEW

부품:

8x8 도트 매트릭스, 220옴 저항 8개

회로연결:

​

+RED핀의 {13,14,15,16,17,18,19,20}의 순서대로 아두이노의 디지털 핀 {2,3,4,5,6,7,8,9}에 연결합니다.

공통음극의 {1,2,3,4,21,22,23,24}의 순서대로 아두이노의 디지털 핀 10,11,12,13,14,15,16,17에 연결합니다.

이때 저항을 공통음극과 아두이노 핀 사이에 하나씩 넣어주고요

도트 매트릭스 1 강의랑 연결이 반대로 되어 있는데, 이것은 코드때문에 이렇게 바뀐거구요. 

앞으로 쓰실 때는 이런식으로 하드웨어를 연결하는 것이 더 좋을 것입니다.​ 

코드:

Colored By Color Scripter™
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
const int xPin[] = {2,3,4,5,6,7,8,9};
const int yPin[] = {10,11,12,13,14,15,16,17};
byte bigHeart[] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00011000
};
byte smallHeart[] = {
  B00000000,
  B00000000,
  B00000000,
  B00010100,
  B00111110,
  B00111110,
  B00011100,
  B00001000
};
 
void setup()
{
  for(int i=0; i<8; i++)
  {
    pinMode(xPin[i], OUTPUT);
    digitalWrite(xPin[i], LOW);//off
    pinMode(yPin[i], OUTPUT);
    digitalWrite(yPin[i], HIGH);//off
  }
}
 
void loop()
{
  showAnimation(bigHeart, 580);
  showAnimation(smallHeart, 200);
}
 
void showAnimation(byte* image, int duration)
{
  unsigned long start = millis();
  while(start + duration > millis())
     multiplexing(image);
}
 
void multiplexing(byte* image)
{
  for(int i = 0; i<8; i++)
  {
    digitalWrite(yPin[i], LOW); //on
    for(int j=0; j<8; j++)
    {
      boolean pixel = bitRead(image[i], j);
      digitalWrite(xPin[j], pixel);
      
      delayMicroseconds(300);
      //delay(300);
      
      digitalWrite(xPin[j], LOW); //off
    }
    digitalWrite(yPin[i], HIGH); //Off
  }
}
 
 
코드설명:
앞서 한거랑 비슷 합니다. 다만 이미지가 두개라는 것 뿐이죠.
1. loop()함수
showMatrix(smallHeart, 580)은  
smallHeart이미지를 580밀리초 동안 띄운다는 것 입니다. 
이렇게 showMatrix(smallHeart, 580)과 showMatrix(bigHeart, 200)이  
계속 무한 반복되는 것입니다.
​ 
2. showMatrix()함수
먼저 입력된 duration 시간동안 이미지를 나타내기 위해서 while문을 쓰고 있는데요~
괄호안에 조건을 보면 start + duration > millis() 라고 되어 있습니다.
millis()함수는 프로그램을 시작한 이후 경과한 시간을 밀리초 단위로 반환합니다.
그래서 loop()함수에서 showMatrix()함수를 시작한지 duration동안의 시간이 지나면 while문의 조건이 거짓이 되어 
while문의 실행문장인 multiplexing()함수를 더 이상 반복하지 않고 마치는 것이죠.
따라서 showMatrix()함수는 입력된 시간동안에 입력된 이미지를 반복하는 함수입니다.
​
3. multiplexing()함수
multipexing()함수를 보면 두개의 for문이 있습니다.
for문의 조건들을 보면 0에서 8로 증가하면서 각각의 매트릭스 위치의 LED를 켜는데,
이 함수는 앞서 도트 매트릭스 1의 multiplexing()함수 같습니다.
함수내부에 있는 bitRead()함수는 8비트 변수에 접근해서 각 비트를 읽습니다. 
bigHeart배열과 smallHeart배열이 있는데, bigHeart[]에서 제일 처음의 원소는 8개 중에 맨위에있는 B00000000입니다.
그리고 1바이트(8비트) 값에서 제일 처음의 비트위치는 가장 오른쪽에 있는 값입니다.
이러한 비트값을 읽는 함수가 bitRead()입니다
[출처] [잔상 효과] - 도트 매트릭스 2|작성자 DEW

8*8도트 매트릭스를 사용하자ㅏㅏㅏ. 매트릭스LED 44개 켜기!!

부품:

8x8 도트 매트릭스, 220옴 저항 8개

부품설명:

이건 우선 제가가지고 있는 매트릭스의 핀 배치입니다. 

공통 음극에, +GREEEN에 전원을 입력하면 초록색불이, +RED에 전원을 연결하면 빨간색 불이 켜집니다.

그림에 나타난대로 공통음극의 1,2,3,4,21,22,23,24에 각 각 -를 연결하면, y축의 LED가 순서대로 켜지구요.

+GREEN이나 +RED에 각 각 +를 연결하면, x축의 LED가 순서대로 켜집니다.

도트 매트릭스의 원리는 똑같습니다. 다만 핀배치의 위치만 다를 뿐이죠.

그러니까 각자의 도트 매트릭스에 맞춰서 하면됩니다~

회로연결:

도트매트릭스의 +RED인 {20,19,18,17,16,15,14,13}을 아두이노의 {2,3,4,5,6,7,8,9}에 연결하구요~

도트매트릭스의 ​공통음극인 {24,23,22,21,4,3,2,1}을 각각 아두이노에 순서에 맞도록{10,11,12,13,14,15,16,17}에 연결하는데요, 이때 주의할 점이 저항을 연결해야 합니다! 즉, 도트매트릭스 공통음극과 아두이노 핀사이에 저항 낮은거 한 개씩 넣어줘야 됩니다~ 

코드:

Colored By Color Scripter™
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
const int xPin[8] = {2,3,4,5,6,7,8,9};
const int yPin[9] = {10,11,12,13,14,15,16,17};
 
void setup()
{
  for(int i=0; i<8; i++)
  {
    pinMode(xPin[i], OUTPUT);
    digitalWrite(xPin[i], LOW); //off
    pinMode(yPin[i], OUTPUT);
    digitalWrite(yPin[i], HIGH); //off
  }
}
 
void loop()
{
  showLED(44);
}
 
void showLED(int num)
{
  int portion = num/8;
  int remainder = num % 8;
  multipexing(portion, remainder);
}
 
void multipexing(int portion, int remainder)
{
  for(int i=0; i<8; i++)
  {
    digitalWrite(xPin[i], HIGH);//on
    for(int j=0; j<8; j++)
    {
      if(i<portion)
        digitalWrite(yPin[j], LOW); //on
      else if(i==portion && j<remainder)
        digitalWrite(yPin[j], LOW); //on
      else
        digitalWrite(yPin[j], HIGH); //off
        
      delay(300);  
      //delayMicroseconds(300);
      
      digitalWrite(yPin[j], HIGH); //off
    }
    digitalWrite(xPin[i], LOW);//off
  }
}

코드설명:

1. loop()함수 

showLED()에 우리가 켜고싶은 LED의 갯수인 44가 입력되었습니다.

​

2. showLED()함수

​shoWLED()에 숫자가 입력되면 

이 숫자를 8로 나눈 몫이 portion에 저장되고, 

이 숫자를 8로 나눴을 때의 나머지는 remainder에 저장됩니다.

그리고 portion과 remainder은 multiplexing()함수에 입력됩니다.

이때 portion이 의미하는 것이 5줄이고,

remainder이 의미하는 것이 4개의 LED인거죠.

그래서 실질적으로 LED가 켜지게 되는 것은 multiplexing()함수에서 입니다.

​

3. multiplexing()함수

이 함수를 이해할려면 백문이 불허일견!

코드의 44줄에 있는 delayMicroseconds(300); -> delay(30); 으로 바꾸어서 아두이노에 업로드 합니다. 

44개의 LED가 하나하나씩 순서대로 켜집니다.

이것이 바로 16개의 핀으로 64개의 LED를 제어하는 방법입니다.

이것을 아주아주 짧은 시간에 반복하면 

우리눈에는 그냥 44개의 LED가 동시에 켜져있는 것으로 보입니다.

​
[출처] [잔상 효과] - 도트 매트릭스 1|작성자 DEW

부품:

LED11개, 330옴 저항 11개

회로:

아두이노 디지털 핀 2~12에 각 각 저항과 함께 LED를 연결합니다.

코드:

Colored By Color Scripter™
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
const int ledpins[]={2,3,4,5,6,7,8,9,10,11,12};
int wait = 50;
 
void setup()
{
  for(int i=0; i<11; i++)
    pinMode(ledpins[i], OUTPUT);
}
 
void loop()
{
  digitalWrite(ledpins[5],HIGH);
  delay(wait*10);
 //separate light
  for(int n=6, m=4; m>=0 ; n++, m--)
   {digitalWrite(ledpins[n],HIGH);
    digitalWrite(ledpins[m],HIGH);
    digitalWrite(ledpins[n-1],LOW);
    digitalWrite(ledpins[m+1],LOW);
    delay(wait);}
 //combine light
  for(int n=9, m=1; m<=5 ;n--,m++)
   {digitalWrite(ledpins[n],HIGH);
    digitalWrite(ledpins[m],HIGH);
    digitalWrite(ledpins[n+1],LOW);
    digitalWrite(ledpins[m-1],LOW);
    delay(wait);} 
 
   digitalWrite(ledpins[5],LOW);
   delay(wait*10);
}
 
 
코드 설명:
loop()함수 내부에서,
우선, 중간에 있는 ledpins[5]하나가 켜집니다.
그 다음,  첫번째 for문에서 변수 n과 m에 의해서 
n은 10<-5가 되고, m은 5->0가 되기 때문에 빛이 양 끝으로 갈라지게 됩니다.
그 다음, 두번째 for문에서 n과 m의 초기값은 각 각 9와 1이고
n은 9->5가 되고, m은 5<-1이 되기 때문에 빛이 중앙으로 모이게 됩니다.
중앙으로 모인 후에는, 5번 핀이 꺼집니다. 
[출처] [디지털출력] 3|작성자 DEW

회로:

코드1:

Colored By Color Scripter™
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
const int ledpins[] = {2, 3, 4, 5, 6, 7};
int wait = 100;
 
void setup()
{
for(int i=0; i<6; i++)
   pinMode(ledpins[i], OUTPUT);
 
//first of all, make ledpins[0] HIGH
digitalWrite(ledpins[0], HIGH);
delay(wait);
}
 
 void loop()
{
  //moving left
  for(int i =1; i<=5; i++)
  {
    digitalWrite(ledpins[i], HIGH);
    digitalWrite(ledpins[i-1], LOW);
    delay(wait);
   }
  //moving right
  for(int i =4; i>=0 ; i--)
   {
    digitalWrite(ledpins[i], HIGH);
    digitalWrite(ledpins[i+1], LOW);
    delay(wait);
   }
}
 
코드1 설명:
우선, setup()부분에서 ledpins[0]가 켜집니다.
그 다음, loop()부분에서 
첫번째 for문에 의해서 ledpins[1]~ledpins[5]까지 순서대로 왼쪽으로 켜지고,
두번째 for문에 의해서 ledpins[4]~ledpins[0]까지 순서대로 오른쪽으로 켜집니다.  
아래의 두 코드도 코드1과 원리는 같습니다~ 
 
기타코드:
Colored By Color Scripter™
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
32
const int ledpins[] = {2, 3, 4, 5, 6, 7};
const int wait = 20;
 
void setup()
{
  for(int led = 0; led <N; led++)
    pinMode(ledpins[led], OUTPUT);
}
 
void loop()
{
  //moving left
  for(int led = 0; led <=4 ; led++)
     {
      digitalWrite(ledpins[led], HIGH);
      delay(wait);
      digitalWrite(ledpins[led+1], HIGH);
      delay(wait);
      digitalWrite(ledpins[led], LOW);
      delay(wait*2);
      }
  //moving right 
   for(int led = 5; led >=1; led--)
      {  
      digitalWrite(ledpins[led], HIGH);
      delay(wait);
      digitalWrite(ledpins[led-1], HIGH);
      delay(wait);
      digitalWrite(ledpins[led], LOW);
      delay(wait*2);
      }
}
 
Colored By Color Scripter™
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
32
33
34
35
const int ledpins[] = {2, 3, 4, 5, 6, 7};
int wait = 50;
 
 
void setup()
{
  for(int led = 0; led < SIZE; led++)
  {
    pinMode(ledpins[led], OUTPUT);
  }
  
 digitalWrite(ledpins[0], HIGH);
 delay(wait);  
}
 
 
void loop()
{
  //moving left  
  for(int led = 0; led <=4 ; led++)
     {
     digitalWrite(ledpins[led+1], HIGH);
     delay(wait);
     digitalWrite(ledpins[led], LOW);
     delay(wait*3);
     }
   //moving right
   for(int led = 5; led >= 1; led--)
     {
     digitalWrite(ledpins[led-1], HIGH);
     delay(wait);
     digitalWrite(ledpins[led], LOW);
     delay(wait*3);
     }
} 
[출처] [디지털출력] 2|작성자 DEW

문제:

LED 6개를 이용해서, 빛이 지나가면서 뒤에 꼬리가 생기게 하고 싶어요.

회로:

아두이노에서 PWM을 지원하는 3,5,6,9,10,11번 핀에 각각 LED를 연결합니다.

코드1:
Colored By Color Scripter™
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
32
33
34
35
36
37
38
39
40
const int ledpins[] = {3,5,6,9,10,11};
const int SIZE = sizeof(ledpins) / sizeof(ledpins[0]);
int wait = 500;
 
void setup()
{
}
 
void loop()
{
   //first case
  for(int i=0; i<4; i++)
     {
      for(int n=i, m=0; n>=0; n--, m++)
          analogWrite(ledpins[n], 255/pow(3,m));
       
      delay(wait);
      }
      
   //second case   
   for(int n=4, m=0; n>=0; n--, m++)
          {if(n>0)
           analogWrite(ledpins[n], 255/pow(3, m));
           else
           analogWrite(ledpins[n], 0);}
           
   delay(wait);
      
  //third case    
  for(int i=0; i<5; i++)
      {
        for(int limit=i+1, led=5, dark=i; n>=0; led--, dark++)
          {if(led>limit)
           analogWrite(ledpins[led], 255/pow(3, dark));
           else
           analogWrite(ledpins[led], 0);}
           
        delay(wait);
      }
}

코드1 설명:

loop()함수를보면 first case와 second case, third case로 나누어져 있습니다.

first case는 빛의 머리부분이 0~4까지 오는 부분으로 

빛의 개수가 1개에서 4개로 증가하는 부분입니다.

second case는 빛의 머리부분이 5에 오는 부분입니다.

third case는 빛의 꼬리부분이 2~5를 지나 없으질 때까지의 부분으로

빛의 개수가 4개에서 0개로 줄어드는 부분입니다.

first case에서는 

i=0일 때, for문의 초기화 부분에서 n=0이니까 ledpins[0]이 머리가 됩니다.

그리고 조건 i>=0 때문에 for문이 종료됩니다.

i=1일 때, for문의 초기화 부분에서 n=1이니까 ledpins[1]이 머리가 되고,

증감연산에 의해 n=0이 되어 ledpins[0]은 밝기가 255/3으로 줄어듭니다.

그리고 조건 i>=0 때문에 for문이 종료됩니다.

i=2일 때, for문의 초기화 부분에서 n=2이니까 ledpins[2]가 머리가 되고,

증감연산에 의해 n=1이 되어 ledpins[1]의 밝기가 255/3으로 줄어들고,

다시 증감연산에 의해 n=0이 되어 ledpins[0]의 밝기가 255/9로 줄어듭니다.

그리고 조건 i>=0 때문에 for문이 종료됩니다.

i=3일 때, for문의 초기화 부분에서 n=3이니까 ledpins[3]이 머리가 되고,

증감연산에 의해 n=2가 되어 ledpins[0]의 밝기가 255/3으로 줄어들고,

다시 증감연산에 의해 n=1이 되어 ledpins[1]의 밝기가 255/9로 줄어들고,

다시 증감연산에 의해 n=0이 되어 ledpins[0]의 밝기가 255/27로 줄어듭니다.

그리고 조건 i>=0 때문에 for문이 종료됩니다. 

second case에서는

4~1의 led까지 점점 어두워 지다가 ledpins[0]에서 꺼집니다.

third case에서는 

i=0일 때, limit값이 1입니다. 

limit이하의 led는 꺼집니다.

for문의 초기화 부분에서 led=5이고 dark=0이기 때문에 

5번핀이 가장 밝고 다음 led로 갈수록 어두워 집니다.

그러다가 led가 1이되면 led는 꺼집니다.

i=1일 때, limit값은 2입니다.

for문의 초기화 부분에서 led=5이고 dark=1이기 때문에

5번 핀이 조금 어둡고 다음 led로 갈수록 더 어두워 집니다.

그러다가 led가 1이 되면 led는 limit값 이하이기때문에 꺼집니다.

이렇게 되다가 i=4일 때, limit값은 5가 됩니다.

for문의 초기화 부분에서 led=5이고 dark=4이지만 

모든 led가 limit값 이하이기 때문에 꺼집니다.

코드2:

Colored By Color Scripter™
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const int ledpins[10] = {3,5,6,9,10,11};
const int SIZE = sizeof(ledpins) / sizeof(ledpins[0]);
int wait = 500;
 
void setup()
{
}
 
void loop()
{
  for(int i=0; i<10; i++)
     {
      if(0<=i<=5)
         analogWrite(ledpins[i],255/ pow(3,0));
      if(1<=i<=6)
         analogWrite(ledpins[i-1], 255/pow(3,1));
      if(2<=i<=7)
         analogWrite(ledpins[i-2], 255/pow(3,2));
      if(3<=i<=8)
         analogWrite(ledpins[i-3], 255/pow(3,3));
      if(4<=i<=9)
         analogWrite(ledpins[i-4],0);
      
      delay(wait);
     }
}
 
 
코드2 설명:
우선 9~6까지의 가상의 LED를 생각해서 총 LED가 10개 있다고 생각합니다.
그리고 for문의 i는 가장 밝은 머리부분의 LED를 나타냅니다.
for문의 증감연산에 의해서 led의 머리부분이 0~9까지 이동하게 됩니다.
이때 각각의 led는 if문에 의하여 선택적으로 켜지게 됩니다. 
선택적으로 켜지는 것은 각자가 생각해 봅시다~ 
[출처] [아날로그 출력]  - 이동|작성자 DEW

문제:

LED를 점점 밝아졌다가 어두워졌다 하도록 만들고 싶어요.

회로:

코드1: 
Colored By Color Scripter™
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const int led = 3;
int brightness = 0 , i;
 
void setup()
{
}
 
void loop()
{
 if(brightness  < 1)
 i = 1;
 else if(brightness > 254)
 i = -1;
 //light LED as brightness
 analogWrite(led, brightness);
 delay(10);
 
 brightness = brightness + i;
}
 
코드 설명:
loop()함수에서 맨 처음 brightness값은 0이지요?
그래서 if문에 의해서 i=0이 됩니다.
brightness = brightness + i에 의해서 brightness값이 점점 증가하다가,
brightness값이 255가 되면 i=-1이 되어,
brightness값이 점점 감소하게 됨니다.
그리고 다시 brightness값이 0이되면 i=1이되어,
brightness값이 점점 증가하게 됩니다.
 
코드2: 
Colored By Color Scripter™
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const int led = 3 ;
 
void setup()
{  
}
 
void loop()
{
 for(int i=0; i<255; i++)
  {analogWrite( led, i);
   delay(10);}
 
 for(int i= 255; i>0; i--)
  {analogWrite( led, i);
   delay(10);}
} 
 
코드2 설명:
첫번째 for문에서 i값이 점점 증가합니다.
i가 255가 되면 첫번째 for문은 끝나고 
두번째 for문이 시작됩니다.
두번째 for문에서 i값이 점점 감소합니다.
i가 0이 되면 두번째 for문은 끝나고
첫번째 for문이 시작됩니다. 
[출처] [아날로그 출력] - 기본|작성자 DEW

문제:

LED3개를 순서대로 깜박이게 하고 싶어요.

부품:

LED3개, 330옴 저항 3개

회로:

코드: 

코드설명:

loop()함수 내부를 보면,

first, second, third 순으로 LED를 깜박인다는 것을 알 수 있습니다.

blink함수를 자세하게 보자면,

핀과 시간이 입력되면 해당핀에 입력된 시간만큼의 펄스를 주게되는 것입니다.