본문 바로가기
Embedded/Arduino

lilyPad_v220719

Aryazoa 2022. 7. 19. 10:50

13. 아기상어->학교종이 +LED

#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
 
#define PIEZO_PIN 2
 
int ledArr[] = {A4,A3,A2,11,10,9};
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);

void melody_1()
{
  //notes in the melody:
  int melody[] = {
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
  0,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
  0,
  NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,  
  };
  
  // note durations: 4 = quarter note, 8 = eighth note, etc
  int noteDurations[] = {
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2,
  2, 
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
  2, 
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
  };
  
  for (int thisNote = 0; thisNote < sizeof(melody) / sizeof(melody[0]); thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(PIEZO_PIN, melody[thisNote],noteDuration);
    ledON_shark(melody[thisNote]);
 
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    
    noTone(PIEZO_PIN); 
    ledOFF();
  }
}

void melody_2()
{
  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};
  for (int thisNote = 0; thisNote < 26; thisNote++) {
    int noteDuration = 250 * noteDurations[thisNote];
    tone(PIEZO_PIN, melody[thisNote],noteDuration);
    ledON_bell(melody[thisNote]);
      
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(PIEZO_PIN);
    ledOFF();
  }
}

void setup(){
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
  
  melody_1();
  delay(1000);
  melody_2();
}

int sys_cnt=0;
void loop(){}
  
void ledON_shark(int piezo_melody)
{ 
  if(piezo_melody == NOTE_C4) 
    digitalWrite(ledArr[0],HIGH);
  if((piezo_melody == NOTE_A4) || piezo_melody == NOTE_D4)
   digitalWrite(ledArr[1],HIGH);
  if(piezo_melody == NOTE_E4)
   digitalWrite(ledArr[4],HIGH);
  if(piezo_melody == NOTE_F4){
    if(sys_cnt%2==0)     
      digitalWrite(ledArr[2],HIGH);      
    else     
      digitalWrite(ledArr[3],HIGH);
  }      
  if(piezo_melody == NOTE_G4)
    digitalWrite(ledArr[5],HIGH);      
  sys_cnt++;
}

void ledON_bell(int piezo_melody)
{ 
  if(piezo_melody == NOTE_C4)
   digitalWrite(ledArr[0],HIGH);
  if(piezo_melody == NOTE_D4)
   digitalWrite(ledArr[5],HIGH);
  if(piezo_melody == NOTE_E4)
   digitalWrite(ledArr[1],HIGH);
  if(piezo_melody == NOTE_G4){
   digitalWrite(ledArr[2],HIGH);
   digitalWrite(ledArr[3],HIGH);
  }
  if(piezo_melody == NOTE_A4)
   digitalWrite(ledArr[4],HIGH);      
}
 
void ledOFF()
{
  for(int i=0; i<ledSize; i++){
    digitalWrite(ledArr[i], LOW);
  }
}

12. 포토센서값이 작아지면 노래 변경

#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
#define NOTE_C7  2093
#define NOTE_D7  2349
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_G7  3136
#define NOTE_A7  3520
#define NOTE_B7  3951
 
#define PIEZOPIN 2
 
int THR = 100;
 
int flag = 0;
int ledCount = 0;
int delayTime = 200;      // 깜빡임시간 지정(1초 =1000)
 
void setup()
{
  pinMode(PIEZOPIN, OUTPUT);
  pinMode(A5,INPUT);
  Serial.begin(9600);
}
 
void melody_1()
{
  //음계 데이터 (24개)
  int melody[] = {NOTE_G7,NOTE_G7,NOTE_A7,NOTE_A7,NOTE_G7,
                  NOTE_G7,NOTE_E7,NOTE_G7,NOTE_G7,NOTE_E7,
                  NOTE_E7,NOTE_D7,NOTE_G7,NOTE_G7,NOTE_A7,
                  NOTE_A7,NOTE_G7,NOTE_G7,NOTE_E7,NOTE_G7,
                  NOTE_E7,NOTE_D7,NOTE_E7,NOTE_C7};
  //음의길이, 4:4분음표, 2:2분음표
  int noteDurations[] = {4,4,4,4,4,4,2,4,4,4,4,1,4,4,4,4,4,4,2,4,4,4,4,1};
 
 
  for (int thisNote = 0; thisNote < 24; thisNote++)
  {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(PIEZOPIN, melody[thisNote], noteDuration); //소리를 낸다.
    int pauseBetweenNotes = noteDuration * 1.30;      //delay 계산식
    delay(pauseBetweenNotes);                         //delay
    noTone(PIEZOPIN);                               //대상핀 출력 중단
  }
}
 
 
 
char notes[] = "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc "; 
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
int tempo = 300;
 
void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(PIEZOPIN, HIGH);
    delayMicroseconds(tone);
    digitalWrite(PIEZOPIN, LOW);
    delayMicroseconds(tone);
  }
}
 
void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
  
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}
 
void melody_2() {
  int length = 15;
  for (int i = 0; i < length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo);
    } else {
      playNote(notes[i], beats[i] * tempo);
    }
    delay(tempo / 2); 
  }
}
 
void melody_3(){
  //notes in the melody:
  int melody_3[] = {
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
    0,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
    0,
    NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,  
  };
 
  // note durations: 4 = quarter note, 8 = eighth note, etc
  int noteDurations_3[] = {
    2, 2, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2,
    2, 
    2, 2, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
    2, 
    2, 2, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4,
    4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
  };
  for (int thisNote = 0; thisNote < sizeof(melody_3) / sizeof(melody_3[0]); thisNote++) {
    int noteDuration = 1000/noteDurations_3[thisNote];
    tone(PIEZOPIN, melody_3[thisNote],noteDuration);
 
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    
    noTone(PIEZOPIN); 
  }
}
 
void loop()
{
  int inputValue = analogRead(A5);
  Serial.print("Sensor : ");
  Serial.print(inputValue);
  if(inputValue <= THR){
    melody_2();
  }
  else{
    noTone(PIEZOPIN);
    Serial.println("");
  }
  if (inputValue <= THR) {           
    if (flag == 0){                    
      flag = 1;
      ledCount = ledCount % 3;
      if(ledCount == 0){
        Serial.println(" => Melody #1");
        melody_1();
      }
      if(ledCount == 1){
        Serial.println(" => Melody #2");
        melody_2();
      }
      if(ledCount == 2){
        Serial.println(" => Melody #3");
        melody_3();
      }
      ledCount++;
    }
  }
  else {                            
    if (flag == 1) {
      flag = 0;           
    }
  }
  delay(100);                 
}

11. 포토센서값이 작아지면 LED 깜빡임 방법 변경

#define THR 150
#define PIEZOPIN 2
 
int ledArr[] = {A4,A3,A2,11,10,9}; // 사용하는 LED번호
int ledSize = sizeof(ledArr)/ sizeof(ledArr[0]);
int ledCount = 0;
int flag = 0;
 
 
int modeCount = 0;
int fadeCount = 0;
int fadeDirection = 1;
 
unsigned long fade_previousMillis = 0;
unsigned long previousMillis = 0;
 
const long fade_interval = 20;           
const long interval = 150;
 
 
 
void setup()
{
  for(int i=0; i<ledSize; i++)
  	pinMode(ledArr[i], OUTPUT);
  
  pinMode(A5,INPUT);
  Serial.begin(9600);
}
 
void led_off()
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

 
void led_blink(int count)
{
  if(count%2 == 0){ 
    for(int i=0; i<ledSize; i++){
      digitalWrite(ledArr[i], HIGH);
    }
  }
  else{
    for(int i=0; i<ledSize; i++){
      digitalWrite(ledArr[i], LOW);
    }
  }
}
 
void led_up2dn(int count)
{
  int n = count % (ledSize+1);
  for(int i =0; i<ledSize; i++){
    if (i == n)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}
 
void led_dn2up(int count)
{
  int n = count % (ledSize+1);
  for(int i=ledSize-1; i>=0; i--){
    if (i == (ledSize-1-n))
      digitalWrite(ledArr[i], HIGH);  
    else
      digitalWrite(ledArr[i], LOW);  
  }
}
 
void led_weighted_up2dn(int count)
{
  int n = count % (ledSize+1);
  if (n == ledSize)
    led_off();
  else
  	digitalWrite(ledArr[n], HIGH);
}
 
void led_weighted_dn2up(int count)
{
  int n = count % (ledSize+1);
  if (n == ledSize)
    led_off();
  else
  	digitalWrite(ledArr[ledSize-1-n], HIGH); 
}
 
 
void mode_selection(int mode)
{
  switch(mode%6){
    case 0:
    	led_blink(ledCount);
    	ledCount++;
    	break;
    case 1:
    	led_up2dn(ledCount);
    	ledCount++;
    	break;
    case 2:
    	led_dn2up(ledCount);
    	ledCount++;
    	break;
    case 3:
    	led_weighted_up2dn(ledCount);
    	ledCount++;
    	break;
    case 4:
    	led_weighted_dn2up(ledCount);
    	ledCount++;
    	break;
    default:
    	led_off();
    	break;
  }
}
 
 
void loop() {
  int inputValue = analogRead(A5);
  Serial.print(inputValue);
  Serial.print(" ");
  Serial.println(modeCount);
  if (inputValue < THR){
    if(flag == 0){
      flag = 1;
      modeCount++;
      ledCount = 0;
      led_off();
      delay(150);
    }
  }
  else{
    if(flag == 1){
      flag = 0;
    }
  }
  
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    mode_selection(modeCount);
  }
  
}

 

10. 포토센서값이 작아지면 LED켜짐

#define SENSOR_THR 100
#define PHOTO_REG A5

const long interval = 200;         //깜빡임 시간지정
int ledArr[] = {A4,A3,A2,11,10,9}; //깜빡임 LED지정
 
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
unsigned long previousMillis = 0;
int sys_cnt = 0;
 
void setup()
{
  Serial.begin(9600);
  pinMode(PHOTO_REG, INPUT);
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
}
void loop()
{
  int photoValue = analogRead(PHOTO_REG);
  Serial.print("Sensor value : ");
  Serial.println(photoValue);
 
  if (photoValue <= SENSOR_THR) {
    led_on();
  }
  else{
    led_off();
  }
}
 
void blink()
{
  if(sys_cnt%2 == 0)
    led_on();  	
  else
    led_off();
  sys_cnt++;  
}
 
void led_on()
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}
 
void led_off()
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

 

9.  포토센서값 시리얼 모니터링

#define PHOTO_REG A5
void setup()
{
  pinMode(PHOTO_REG, INPUT);
  Serial.begin(9600);
}
void loop()
{
  int photoValue = analogRead(PHOTO_REG);
  Serial.print("Sensor value : ");
  Serial.println(photoValue);
  delay(50);
}

8. PIEZO(아기상어)+LED

#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
 
#define PIEZO_PIN 2
 
int ledArr[] = {A4,A3,A2,11,10,9};
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
 
//notes in the melody:
int melody[] = {
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
  0,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,
  0,
  NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
  NOTE_C4, NOTE_D4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_E4,  
};
 
// note durations: 4 = quarter note, 8 = eighth note, etc
int noteDurations[] = {
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2,
  2, 
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
  2, 
  2, 2, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4,
  4, 4, 4, 4, 4, 8, 4, 8, 4, 4, 4, 2, 
};
 
void setup(){
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
  
  for (int thisNote = 0; thisNote < sizeof(melody) / sizeof(melody[0]); thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(PIEZO_PIN, melody[thisNote],noteDuration);
    ledON(melody[thisNote]);
 
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    
    noTone(PIEZO_PIN); 
    ledOFF();
  }
}

int sys_cnt=0;
void loop(){}
  
void ledON(int piezo_melody)
{ 
  if(piezo_melody == NOTE_C4) 
    digitalWrite(ledArr[0],HIGH);
  if((piezo_melody == NOTE_A4) || piezo_melody == NOTE_D4)
   digitalWrite(ledArr[1],HIGH);
  if(piezo_melody == NOTE_E4)
   digitalWrite(ledArr[4],HIGH);
  if(piezo_melody == NOTE_F4){
    if(sys_cnt%2==0)     
      digitalWrite(ledArr[2],HIGH);      
    else     
      digitalWrite(ledArr[3],HIGH);
  }      
  if(piezo_melody == NOTE_G4)
    digitalWrite(ledArr[5],HIGH);      
  sys_cnt++;
}
 
void ledOFF()
{
  for(int i=0; i<ledSize; i++){
    digitalWrite(ledArr[i], LOW);
  }
}

7. PIEZO(학교종이)+LED

#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_G4  392
#define NOTE_A4  440
 
#define PIEZO_PIN 2
int ledArr[] = {A4,A3,A2,11,10,9};
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
  
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() {
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
  
  for (int thisNote = 0; thisNote < 26; thisNote++) {
    int noteDuration = 250 * noteDurations[thisNote];
    tone(PIEZO_PIN, melody[thisNote],noteDuration);
    ledON(melody[thisNote]);
      
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(PIEZO_PIN);
    ledOFF();
  }
}
void loop() {}
  
void ledON(int piezo_melody)
{ 
  if(piezo_melody == NOTE_C4)
   digitalWrite(ledArr[0],HIGH);
  if(piezo_melody == NOTE_D4)
   digitalWrite(ledArr[5],HIGH);
  if(piezo_melody == NOTE_E4)
   digitalWrite(ledArr[1],HIGH);
  if(piezo_melody == NOTE_G4){
   digitalWrite(ledArr[2],HIGH);
   digitalWrite(ledArr[3],HIGH);
  }
  if(piezo_melody == NOTE_A4)
   digitalWrite(ledArr[4],HIGH);      
}
 
void ledOFF()
{
  for(int i=0; i<ledSize; i++){
    digitalWrite(ledArr[i], LOW);
  }
}

6-2. 2묶음 LED가 개별동작

const long interval1 = 200;  // 깜빡임 시간
int ledArr1[] = {A4,A3,A2}; // 첫번째 LED묶음
const long interval2 = 200;  // 깜빡임 시간
int ledArr2[] = {9,10,11};  // 두번재 LED묶음

int ledSize1 = sizeof(ledArr1)/sizeof(ledArr1[0]);
int ledSize2 = sizeof(ledArr2)/sizeof(ledArr2[0]);
unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
int sys_cnt1 = 0,sys_cnt2 = 0;
int sys_cnt =0;

void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize1; i++)
    pinMode(ledArr1[i], OUTPUT);
  for(int i=0; i<ledSize2; i++)
    pinMode(ledArr2[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis1 = millis();
  unsigned long currentMillis2 = millis();
 
  if (currentMillis1 - previousMillis1 >= interval1) {
    previousMillis1 = currentMillis1;
    blink_add(ledArr1,ledSize1, sys_cnt1);
    sys_cnt1++;
  }
  if (currentMillis2 - previousMillis2 >= interval2) {
    previousMillis2 = currentMillis2;
    blink_add(ledArr2,ledSize2, sys_cnt2);
    sys_cnt2++;
  }
}

void blink()
{
  if(sys_cnt%2 == 0){
	led_all_on(ledArr1, ledSize1);
    led_all_off(ledArr2,ledSize2);
  }
  else{
    led_all_off(ledArr1, ledSize1);
    led_all_on(ledArr2,ledSize2);
  }
  sys_cnt++;  
}

void blink_add(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_add_on(ledArr, ledSize, count);
}

void blink_turn(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%ledSize;
  led_each_on(ledArr, ledSize, count);
}

void blink_turn_off(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_each_on(ledArr, ledSize, count);

  sys_cnt++;
}


void led_each_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i==onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_add_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i<=onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_all_on(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}

void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

6. 2묶음의 LED가 개별 동작

const long interval1 = 200;  // 깜빡임 시간
int ledArr1[] = {A4,A3,A2}; // 첫번째 LED묶음
const long interval2 = 500;  // 깜빡임 시간
int ledArr2[] = {11,10,9};  // 두번재 LED묶음

int ledSize1 = sizeof(ledArr1)/sizeof(ledArr1[0]);
int ledSize2 = sizeof(ledArr2)/sizeof(ledArr2[0]);
unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
int sys_cnt1 = 0,sys_cnt2 = 0;
int sys_cnt =0;

void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize1; i++)
    pinMode(ledArr1[i], OUTPUT);
  for(int i=0; i<ledSize2; i++)
    pinMode(ledArr2[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis1 = millis();
  unsigned long currentMillis2 = millis();
 
  if (currentMillis1 - previousMillis1 >= interval1) {
    previousMillis1 = currentMillis1;
    blink_add(ledArr1,ledSize1, sys_cnt1);
    sys_cnt1++;
  }
  if (currentMillis2 - previousMillis2 >= interval2) {
    previousMillis2 = currentMillis2;
    blink_turn_off(ledArr2,ledSize2, sys_cnt2);
    sys_cnt2++;
  }
}

void blink()
{
  if(sys_cnt%2 == 0){
	led_all_on(ledArr1, ledSize1);
    led_all_off(ledArr2,ledSize2);
  }
  else{
    led_all_off(ledArr1, ledSize1);
    led_all_on(ledArr2,ledSize2);
  }
  sys_cnt++;  
}

void blink_add(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_add_on(ledArr, ledSize, count);
}

void blink_turn(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%ledSize;
  led_each_on(ledArr, ledSize, count);
}

void blink_turn_off(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_each_on(ledArr, ledSize, count);

  sys_cnt++;
}


void led_each_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i==onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_add_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i<=onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_all_on(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}

void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

5. BLINK

const long interval = 200;  // 깜빡임 시간
int ledArr1[] = {A4,A3,A2}; // 첫번째 LED묶음
int ledArr2[] = {11,10,9};  // 두번재 LED묶음
 
int ledSize1 = sizeof(ledArr1)/sizeof(ledArr1[0]);
int ledSize2 = sizeof(ledArr2)/sizeof(ledArr2[0]);
unsigned long previousMillis = 0;
int sys_cnt = 0;
 
void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize1; i++)
    pinMode(ledArr1[i], OUTPUT);
  for(int i=0; i<ledSize2; i++)
    pinMode(ledArr2[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    blink();
  }
}
 
void blink()
{
  if(sys_cnt%2 == 0){
    led_all_on(ledArr1, ledSize1);
    led_all_off(ledArr2,ledSize2);
  }
  else{
    led_all_off(ledArr1, ledSize1);
    led_all_on(ledArr2,ledSize2);
  }
  sys_cnt++;  
}
void led_all_on(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}

void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

4. BLINK(A4,A3,A2) + FADE(11,10,9)

#define UP 0
#define DOWN 1
 
int pwmArr[] = {11,10,9};
int blinkArr[]={A4,A3,A2};
int blinkInterval = 200;
int fadeInterval = 30;
 
int pwmSize = sizeof(pwmArr) / sizeof(pwmArr[0]);
int blinkSize = sizeof(blinkArr) / sizeof(blinkArr[0]);
const int minPWM = 0;
const int maxPWM = 255;
 
byte fadeDirection = UP;
int fadeValue = 0;
byte fadeIncrement = 5;
unsigned long previousFadeMillis;
unsigned long previousMillis;

int ledState = LOW;

void setup()
{
  for(int i=0; i<pwmSize; i++)
    pinMode(pwmArr[i], OUTPUT);
 
  for(int j=0; j<blinkSize; j++)
    pinMode(blinkArr[j], OUTPUT);
}
 
void doTheFade(int *pwmPin, unsigned long thisMillis) {
   if (thisMillis - previousFadeMillis >= fadeInterval) {
      if (fadeDirection == UP) {
         fadeValue = fadeValue + fadeIncrement;
         if (fadeValue >= maxPWM) {
            fadeValue = maxPWM;
            fadeDirection = DOWN;
         }
      } else {
         fadeValue = fadeValue - fadeIncrement;
         if (fadeValue <= minPWM) {
            fadeValue = minPWM;
            fadeDirection = UP;
         }
      }
      for(int i=0; i<pwmSize; i++)
        analogWrite(pwmArr[i], fadeValue);
      previousFadeMillis = thisMillis;
   }
}
 
void doTheBlink(int *blinkPin, unsigned long thisMillis)
{
  if (thisMillis - previousMillis >= blinkInterval) {
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }
    for(int i=0; i<blinkSize; i++)
      digitalWrite(blinkPin[i], ledState);
    previousMillis = thisMillis;
  }
}
 
void loop() {
  unsigned long currentMillis = millis();
  doTheFade(pwmArr, currentMillis);
  doTheBlink(blinkArr, currentMillis);
}

3-2. LED가 여러가지 방법으로 깜빡이기

const long interval = 200;  // 깜빡임 시간
int ledArr[] = {A4,A3,A2,11,10,9};  // LED
 
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
unsigned long previousMillis = 0;


 
void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
}

void loop()
{
  unsigned long currentMillis = millis();
  mode_select(ledArr, ledSize, currentMillis);
  
}

void mode_select(int* ledArr, int ledSize, unsigned long millis)
{
  static int mode =0;
  switch(mode){
    case 0:
      mode = blink_all(ledArr, ledSize, mode, millis);
      break;
    case 1:
      mode = blink_turn(ledArr, ledSize, mode, millis);
      break;
    case 2:
      mode = blink_turn_rev(ledArr, ledSize, mode, millis);
      break;
    case 3:
      mode = blink_add(ledArr, ledSize, mode, millis);
      break;
    case 4:
      mode = blink_sub(ledArr, ledSize, mode, millis);
      break;
    case 5:
      mode = blink_add_rev(ledArr, ledSize, mode, millis);
      break;
    case 6:
      mode = blink_sub_rev(ledArr, ledSize, mode, millis);
      break;
  }
}

void print_values(int mode, int value)
{
  Serial.print(mode);
  Serial.print(" : ");
  Serial.println(value);
}

void count_value(int *mode, int *blink, bool count_case)
{
  // count_case : 1(positive count)
  // count_case : 0(negative count)
  
}



int blink_all(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    led_blink(ledArr, ledSize, blink_cnt%2);
    
    if(blink_cnt == (ledSize*2-1)){
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      blink_cnt++;
    }
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}

int blink_turn(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = blink_cnt%(ledSize+1);
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    led_each_on(ledArr, ledSize, count);
    if(count == ledSize){
      led_all_off(ledArr, ledSize);
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      blink_cnt++;
    }
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}

int blink_turn_rev(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = (ledSize-1)-(blink_cnt%(ledSize+1));
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    led_each_on(ledArr, ledSize, count);
    if(count == -1){
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      blink_cnt++;
    }
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}


//누적해서 다켜지고 나면 끄기 없음
int blink_add(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = blink_cnt%ledSize;
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    digitalWrite(ledArr[count],HIGH);
    if(count == ledSize-1){
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      blink_cnt++;
    }
    
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}

//누적해서 다켜지고 나면 끄기 없음
int blink_add_rev(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = (ledSize-1)-(blink_cnt%ledSize);
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    digitalWrite(ledArr[count],HIGH);
    if(count == 0){
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      blink_cnt++;
    }
    
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}


//누적해서 다켜지고 나면 끄기 포함
int blink_add_off(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = blink_cnt%(ledSize+1);
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    if(count == ledSize){
      led_all_off(ledArr, ledSize);
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      led_addOn(ledArr, ledSize, count);
      blink_cnt++;
    }
    
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}

int blink_sub(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int rev_count = (ledSize-1)-(blink_cnt%(ledSize+1));
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    if(rev_count == -1){
      led_all_off(ledArr, ledSize);
      blink_cnt = 0;
      mode_cnt += 1;
    }
    else{
      led_addOn(ledArr, ledSize, rev_count);
      blink_cnt++;
    }
    
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}
int blink_sub_rev(int* ledArr, int ledSize, int mode_cnt, unsigned long currentMillis)
{
  static int blink_cnt = 0;
  int count = blink_cnt%(ledSize+1);
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    if(count == ledSize){
      led_all_off(ledArr, ledSize);
      blink_cnt = 0;
      mode_cnt = 0;
      //mode_cnt += 1;
    }
    else if(count >= 1){
      digitalWrite(ledArr[count-1],LOW);
    }
    blink_cnt++;
    print_values(mode_cnt, blink_cnt);
  }
  return mode_cnt;
}

 
void led_addOn(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i<=onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_addOn_neg(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i<=onLed)
      digitalWrite(ledArr[i], LOW);
    else
      digitalWrite(ledArr[i], HIGH);
  }
}

void led_each_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
  
  if(onLed != ledSize)
    digitalWrite(ledArr[onLed], HIGH);
}

void led_blink(int* ledArr, int ledSize, bool mode)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], mode);
}


void led_all_on(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}

void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

 

3. LED 누적해서 깜빡이기

const long interval = 200;  // 깜빡임 시간
int ledArr[] = {A4,A3,A2,11,10,9};  // LED
 
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
unsigned long previousMillis = 0;
int sys_cnt = 0;
 
void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    blink_add(ledArr,ledSize, sys_cnt);
    sys_cnt++;
  }
}

void blink_add(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_add_on(ledArr, ledSize, count);
}
 
void led_add_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i<=onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}

void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

2.  LED 각각 깜빡이기

const long interval = 200;  // 깜빡임 시간
int ledArr[] = {A4,A3,A2,11,10,9};  // LED
 
int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
unsigned long previousMillis = 0;
int sys_cnt = 0;
 
void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    blink_turn(ledArr,ledSize, sys_cnt);
    sys_cnt++;
  }
}
 
void blink_turn(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%ledSize;
  led_each_on(ledArr, ledSize, count);
}
 
void blink_turn_off(int* ledArr, int ledSize, int sys_cnt)
{
  int count = sys_cnt%(ledSize+1);
  
  if(count == ledSize)
    led_all_off(ledArr, ledSize);
  else
  	led_each_on(ledArr, ledSize, count);
}
 
void led_each_on(int* ledArr, int ledSize, int onLed)
{
  for(int i=0; i<ledSize; i++){
    if(i==onLed)
      digitalWrite(ledArr[i], HIGH);
    else
      digitalWrite(ledArr[i], LOW);
  }
}
 
void led_all_off(int* ledArr, int ledSize)
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

 

1. 전체 LED 깜빡이기

const long interval = 200;         //깜빡임 시간지정
int ledArr[] = {A4,A3,A2,11,10,9}; //깜빡임 LED지정

int ledSize = sizeof(ledArr)/sizeof(ledArr[0]);
unsigned long previousMillis = 0;
int sys_cnt = 0;

void setup()
{
  Serial.begin(9600);
  for(int i=0; i<ledSize; i++)
    pinMode(ledArr[i], OUTPUT);
}
void loop()
{
  unsigned long currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    blink();
  }
}

void blink()
{
  if(sys_cnt%2 == 0)
	led_on();  	
  else
    led_off();
  sys_cnt++;  
}

void led_on()
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], HIGH);
}

void led_off()
{
  for(int i=0; i<ledSize; i++)
    digitalWrite(ledArr[i], LOW);
}

'Embedded > Arduino' 카테고리의 다른 글

미세먼지 센서  (0) 2022.10.24
lilyPad_v220721  (0) 2022.07.21
Arduino v220718  (0) 2022.07.18
arduino v220714  (0) 2022.07.14
lilypad_v220713  (0) 2022.07.13

'Embedded/Arduino' Related Articles

티스토리툴바