Reo’s Archive
Reo’s Archive/
🏫
[2024-1] IoT 기술과 프로그래밍
카테고리
[2024-1] IoT 기술과 프로그래밍
🏫

[2024-1] IoT 기술과 프로그래밍

카테고리
🎓 Univ Lecture
작성자
박용성박용성
작성일
2024년 06월 03일
태그
C
Arduino
Slug
univ-iot
중간고사 이전9주차틀린 코드11주차과제교수님 풀이12주차과제13주차14주차

중간고사 이전

#define VARI A0
#define LED 8
int data; // 수신 문자를 저장하는 문바열 변수 data 선언

#define RED 11
#define GREEN 10
#define BLUE 9

int rval = 0;
int gval = 0;
int bval = 0;

String str;

void setup() {
  Serial.begin(9600);
  // pinMode(LED, OUTPUT);

  // pinMode(RED, OUTPUT);
  // pinMode(GREEN, OUTPUT);
  // pinMode(BLUE, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop() {
  // Serial.print("hello");
  // Serial.println("world!!");
  // Serial.print("\n");

  // Serial.println("hello world!");
  // delay(500);

  // ----

  // Serial.print("available : ");
  // Serial.println(Serial.available());
  // //Serial.println(Serial.read()); // a = 65, 7비트가 필요하지 않나? 왜 available이 1씩 늘어나지?
  // delay(1000);

  // ----

  // if (Serial.available() > 0) {
  //   data = Serial.read(); // 수신 문자 저장
  //   Serial.print(data); // 수신 문자 시리얼 출력
  // }

  // ----

  // if (Serial.available()) {
  //   char a;
  //   a = Serial.read();
  //   Serial.print("read : ");
  //   Serial.println(a);
  // }

  // ----

  // if (Serial.available()) {
  //   float a;
  //   a = Serial.parseFloat();
  //   Serial.print("read : ");
  //   Serial.println(a);
  // }

  // ----

  // if (Serial.available() > 0) {
  //   data = Serial.read();
  //   // 1을 수신하면 LED 켜기
  //   if (data == '1') {
  //     digitalWrite(LED, HIGH);
  //     Serial.println("LED ON");
  //   }
  //   else if (data == '0') {
  //     digitalWrite(LED, LOW);
  //     Serial.println("LED OFF");
  //   }
  // }

  // ----

  //   if (Serial.available() > 0) {
  //   data = Serial.parseInt();
  //   // 100보다 크면 LED 켜기
  //   if (data > 100) {
  //     digitalWrite(LED, HIGH);
  //     Serial.println("LED ON");
  //   }
  //   else if (data <= 100) {
  //     digitalWrite(LED, LOW);
  //     Serial.println("LED OFF");
  //   }
  // }

  // ----

  // if (Serial.available() > 0) {
  //   rval = Serial.parseInt();
  //   gval = Serial.parseInt();
  //   bval = Serial.parseInt();

  //   if (Serial.read() == '\n') {
  //     Serial.println(rval);
  //     Serial.println(gval);
  //     Serial.println(bval);
  //     analogWrite(RED, 255-rval);
  //     analogWrite(GREEN, 255-rval);
  //     analogWrite(BLUE, 255-rval);
  //   }
  // }

  // ---- 

  if (Serial.available() > 0) {
    char ch = Serial.read();

    if (ch == '\n') {
      if (str == "on") {
        digitalWrite(13, HIGH);
        str = "";
      }
      else if (str == "off") {
        digitalWrite(13, LOW);
        str = "";
      }
    }
    else {
        str += ch;
    }
  }

}
 
 

7주차

const int MOTOR = 9;

void setup() {
  pinMode(MOTOR, OUTPUT);
}

void loop() {
  for (int i = 0; i <= 255; i++) {
    analogWrite(MOTOR, i);
    delay(10);
  }

  delay(2000);

  for (int i = 255; i >= 0; i--) {
    analogWrite(MOTOR, i);
    delay(10);
  }
  delay(2000);
}
// 가변저항으로 모터 속도 조절하기
const int MOTOR = 9; // 9번 핀을 사용하는 MOTOR 상수 정의
const int POT = 0;   // 아날로그 입력 0번 핀을 사용하는 가변저항 POT 상수 정 의
int val = 0;

void setup() {
    pinMode(MOTOR, OUTPUT);
}

void loop() {
    val = analogRead(POT);
    val = map(val, 0, 1023, 0, 255);
    analogWrite(MOTOR, val);
}
/* L9110S 모듈 제어 해보기 (방향제어 : 코딩1)*/ 
int motorA1 = 8;
int motorA2 = 9;

void setup() {
    pinMode(motorA1, OUTPUT);
    pinMode(motorA2, OUTPUT);
}

void loop() {
    digitalWrite(motorA1, HIGH);
    digitalWrite(motorA2, LOW);
}
/* L9110S 모듈 제어 해보기 (방향제어 : 코딩1)*/
int motorA1 = 8;
int motorA2 = 9;
int speed = 255;

void setup() {
	pinMode(motorA1, OUTPUT);
	pinMode(motorA2, OUTPUT);
}

void loop() {
	analogWrite(motorA1, speed);
	analogWrite(motorA2, 0);
	delay(2000);
	
	analogWrite(motorA1, 0);
	analogWrite(motorA2, speed);
	delay(2000);
	
	analogWrite(motorA1, speed);
	analogWrite(motorA2, 0);
	delay(2000);
}
/* L9110S 모듈 제어 해보기 (방향제어 : 코딩1)*/
int motorA1 = 9;
int motorA2 = 10;
int speed = 255;

void setup() {
	pinMode(motorA1, OUTPUT);
	pinMode(motorA2, OUTPUT);
}

void loop() {
	for (speed = 0; speed <= 256; speed += 10) {
    analogWrite(motorA1, speed);
    analogWrite(motorA2, 0);
    delay(200);
  }
}
// 모터 속도 가변
int motorA1 = 9;
int motorA2 = 10;

void setup() {
	pinMode(motorA1, OUTPUT);
	pinMode(motorA2, OUTPUT);
  pinMode(A0, INPUT);

  // 디버깅 위해 설정
  Serial.begin(9600);
}

void loop() {
  int var = analogRead(var);
  var = map(var, 0, 741, 0, 255); // 전압 떨어져서 741 최댓값
  analogWrite(motorA1, var);
  analogWrite(motorA2, 0);

  Serial.println(var);
  delay(200);
}
 
 
기말 정리

9주차

틀린 코드

#include <Wire.h>
#include <string.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
String str;

void setup() {
    Wire.begin(4); // I2C 버스 주소 #4로 시작
    Wire.onReceive(receiveEvent); // 이벤트 등록
    Serial.begin(9600);

    lcd.init();
    lcd.backlight();
    lcd.clear();
}

void loop() {
  if (str.length() > 0) {
    lcd.setCursor(0, 1);
    lcd.print(str); // LCD에 문자열 출력
    str = ""; // 문자열 초기화
  }
  delay(100);
}


void receiveEvent(int howMany) {
    while(1 < Wire.available()) {// loop through all but the last {
        char c = Wire.read(); // receive byte as a character
        Serial.print(c);
        str += c;
    }
    
    int x = Wire.read();
    str += " ";
    str += x;
    Serial.println(x);
}
 
#include <Wire.h>
#include <string.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
String str;

void setup() {
    Wire.begin(4); // I2C 버스 주소 #4로 시작
    Wire.onReceive(receiveEvent); // 이벤트 등록
    Serial.begin(9600);

    lcd.init();
    lcd.clear();
    lcd.backlight();
    lcd.setCursor(0, 0);
    lcd.print("Hello, World!");
}

void loop() {
  lcd.setCursor(0, 1);
  lcd.print(str);
  str = "";
  delay(100);
}


void receiveEvent(int howMany) {
    while(1 < Wire.available()) {// loop through all but the last {
        char c = Wire.read(); // receive byte as a character
        Serial.print(c);
        str += c;
    }
    
    int x = Wire.read();
    str += " ";
    str += x;
    Serial.println(x);
}

#include <Wire.h>
#include <string.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
String str;

void setup() {
    Wire.begin(4); // I2C 버스 주소 #4로 시작
    Wire.onReceive(receiveEvent); // 이벤트 등록
    Serial.begin(9600);

    lcd.init();
    lcd.backlight();
}

void loop() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Hello, World!");
  lcd.setCursor(0, 1);
  lcd.print(str);
  str = "";
  delay(100);
}

void receiveEvent(int howMany) {
    while(1 < Wire.available()) {// loop through all but the last {
        char c = Wire.read(); // receive byte as a character
        Serial.print(c);
        str += c;
    }
    
    int x = Wire.read();
    str += x;
    Serial.println(x);
}
 

11주차

#include <SPI.h>

byte queue[100];
byte head, tail;
byte rxdata;
byte rxcount = 0;

char buf[80];

void setup() {
    pinMode(SCK, INPUT); // set SPI slave manually
    pinMode(MOSI, INPUT);
    pinMode(MISO, OUTPUT);
    pinMode(SS, INPUT);
    SPI.setClockDivider(SPI_CLOCK_DIV16);
    SPCR &= ~(1 << MSTR); // Slave
    SPCR |= (1 << SPIE);
    SPCR |= (1 << SPE);
    Serial.begin(9600);
    head = 0;
    tail = 0;
}

ISR(SPI_STC_vect) { // SPI Interrupt
    rxdata = SPDR;  // rx data
    SPDR = rxdata;  // echo back
    queue[head] = rxdata;
    head = (head + 1) % 100;
    rxcount += 1;
}
void loop() {
    int rxdata;
    if (head != tail) {
        rxdata = queue[tail];
        tail = (tail + 1) % 100;
        sprintf(buf, "SPI RX count = %d, data = %d", rxcount, rxdata);
        Serial.println(buf);
    }
}
#include <SPI.h>

void setup() {
    SPI.begin(); // SCK, MOSI, SS into output mode
    SPI.setClockDivider(SPI_CLOCK_DIV16);
    Serial.begin(9600);
}

bytex = 0;
byte rx1, rx2;
char buf[80];

void loop() {
    digitalWrite(SS, LOW);
    rx1 = SPI.transfer(x);
    x++;
    rx2 = SPI.transfer(x);
    x++;
    digitalWrite(SS, HIGH); // select
    sprintf(buf, "Master x=%d, rx1=%d, rx2=%d", x, rx1, rx2);
    Serial.println(buf);
    delay(1000);
}
 

과제

#include <SPI.h>

const int SWITCH = 2;
const int LED = 7;

void setup() {
    pinMode(LED, OUTPUT);
    pinMode(SWITCH, INPUT);
    SPI.begin();                          // SPI 통신 시작
    SPI.setClockDivider(SPI_CLOCK_DIV16); // 클록 분배 설정
    Serial.begin(9600);
}

void loop() {

    byte localSwitchState = digitalRead(SWITCH) == LOW;     // 스위치 읽기, 눌리지 않았을 때 꺼지도록
    digitalWrite(SS, LOW);                                  // 슬레이브 선택
    byte slaveSwitchState = SPI.transfer(localSwitchState); // 스위치 상태 전송 및 slave 상태 수신
    digitalWrite(SS, HIGH);                                 // 슬레이브 해제
    digitalWrite(LED, slaveSwitchState);                    // 수신된 슬레이브 스위치 상태에 따라 LED 제어
    delay(100);                                             // 딜레이
}

#include <SPI.h>

const int SWITCH = 2;
const int LED = 7;
volatile byte receivedData = 0; // 마스터로부터 받은 데이터

void setup() {
    pinMode(LED, OUTPUT); // LED 출력 모드 설정
    pinMode(SWITCH, INPUT);
    pinMode(SCK, INPUT); // set SPI slave manually
    pinMode(MOSI, INPUT);
    pinMode(MISO, OUTPUT);
    pinMode(SS, INPUT);

    SPI.setClockDivider(SPI_CLOCK_DIV16);
    SPCR &= ~(1 << MSTR); // Slave
    SPCR |= (1 << SPIE);
    SPCR |= (1 << SPE);

    Serial.begin(9600);
}

ISR(SPI_STC_vect) { // SPI 인터럽트 서비스 루틴
    receivedData = SPDR;
    SPDR = digitalRead(SWITCH) == LOW; // 슬레이브 스위치 상태를 다시 마스터에게 보냄
}

void loop() {
    digitalWrite(LED, receivedData); // 마스터로부터 받은 데이터에 따라 LED 제어
}
 

교수님 풀이

#include <SPI.h>
#define LED 7
#define ipbutton 2

int buttonvalue;
int x;

void setup(void) {
	Serial.begin(115200);
	pinMode(ipbutton, INPUT);
	pinMode(LED, OUTPUT);
	
	SPI.begin();
	SPI.setClockDivider(SPI_CLOCK_DIV8);
	digitalWrite(SS, HIGH);
}

void loop(void) {
	byte Mastersend, Masterreceive;
	buttonvalue = digitalRead(ipbutton);
	
	if (buttonvalue == HIGH) {
		x = 1;
	} else {
		x = 0;
	}
	
	digitalWrite(SS, LOW);
	Mastersend = x;
	Masterreceive = SPI.transfer(Mastersend);
	
	if (Masterreceive == 1) {
		digitalWrite(LED, HIGH);
		Serial.println("Master LED ON");
	} else {
		digitalWrite(LED, LOW);
		Serial.println("Master LED OFF");
	}
	
	delay(1000);
}

#include <SPI.h>

#define LEDpin 7
#define buttonpin 2
volatile boolean received;
volatile byte Slavereceived, Slavesend;

int buttonvalue;
int x;

void setup() {
    Serial.begin(115200);
    pinMode(buttonpin, INPUT);
    pinMode(LEDpin, OUTPUT);
    pinMode(MISO, OUTPUT);
    SPCR |= _BV(SPE); // TURN on SPI in Slave Mode
    received = false;
    SPI.attachInterrupt(); // Interrupt ON is set for SPI
}

ISR(SPI_STC_vect) {       // Interrupt routine function
    Slavereceived = SPDR; // Value received from master if store in variable slaverecevied
    received = true;
}

void loop() {
    if (received) {
        if (Slavereceived == 1) {
            digitalWrite(LEDpin, HIGH); // Sets pin 7 as HIGH LED ON
            Serial.println("Slave LED ON");
        } else {
            digitalWrite(LEDpin, LOW);
            Serial.println("Slave LED OFF");
        }

        buttonvalue = digitalRead(buttonpin);

        if (buttonvalue == HIGH) {
            x = 1;
        } else {
            x = 0;
        }

        Slavesend = x;
        SPDR = Slavesend; // Sends the x value to master via SPDR

        delay(1000);
    }
}
 

12주차

#define F_CPU 16000000UL
#define _BV(bit) (1 << (bit))

#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>

void UART_0_init(void);
void UART1_transmit(char data);
unsigned char UART1_receive(void);
void UART1_send_String(char *data);

void UART_0_init(void) {
    UBRR0H = 0x00; // 9,600 보율로 설정
    UBRR0L = 207;
    UCSR0A |= (1 << U2X0); // 2배속 모드
    UCSR0C |= 0x06;        // 8N1 설정
    UCSR0B |= _BV(RXEN0);  // 수신 가능
    UCSR0B |= _BV(TXEN0);  // 송신 가능
}

void UART1_transmit(char data) {
    // 송신 가능 대기
    while (!(UCSR0A & (1 << UDRE0)))
        ;
    UDR0 = data; // 데이터 전송
}

unsigned char UART1_receive(void) {
    // 수신 가능 대기
    while (!(UCSR0A & (1 << RXC0)))
        ;
    return UDR0;
}

void UART1_send_String(char *data) {
    int i = 0;
    do {
        UART1_transmit(data[i]);
        i++;
    } while (data[i] != 0);
    UART1_transmit(data[i]);
}

int main(void) {
    UART_0_init();

    while (1) {
        UART1_send_String("HelloWorld\n");
        _delay_ms(1000);
    }

    return 0;
}

#define F_CPU 16000000UL
#define _BV(bit) (1 << (bit))

#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>

void UART_0_init(void);
void UART1_transmit(char data);
unsigned char UART1_receive(void);

void UART_0_init(void) {
    UBRR0H = 0x00; // 9,600 보율로 설정
    UBRR0L = 207;
    UCSR0A |= (1 << U2X0); // 2배속 모드
    UCSR0C |= 0x06;        // 8N1 설정
    UCSR0B |= _BV(RXEN0);  // 수신 가능
    UCSR0B |= _BV(TXEN0);  // 송신 가능
}

void UART1_transmit(char data) {
    while (!(UCSR0A & (1 << UDRE0)))
        ;
    UDR0 = data; // 데이터 전송
}

unsigned char UART1_receive(void) {
    while (!(UCSR0A & (1 << RXC0)))
        ;
    return UDR0;
}

int main(void) {
    UART_0_init(); // UART0 초기화

    while (1) {
        UART1_transmit(UART1_receive()); // 송신 가능 대기
    }

    return 0;
}

void EEPROM_write(unsigned int uiAddress, unsigned char ucData) {
    // 이전 쓰기 완료까지 대기
    while (EECR & (1 << EEPE)); // EEPE 비트 0 인지 확인
    // 주소와 데이터 레지스터 설정
    EEAR = uiAddress;
    EEDR = ucData;
    // EEMPE 비트 1로 설정
    EECR |= (1 << EEMPE);
    // EEPE 비트 1로 설정해 쓰기 시작
    EECR |= (1 << EEPE);
}

unsigned char EEPROM_read(unsigned int uiAddress) {
    // 이전 쓰기 완료까지 대기
    while (EECR & (1 << EEPE));
    // 주소 레지스터 설정
    EEAR = uiAddress;
    // EERE 비트 1로 설정해 읽기 시작
    EECR |= (1 << EERE);
    // 데이터 레지스터 데이터 반환
    return EEDR;
}

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

void loop() {
    char sSREG;
    sSREG = SREG;
    SREG = 0; // Interrupt disable 설정
    EECR = 0; // EEPM0,1 초기화, 읽기 지우기 가능
    EEPROM_write(0x01, '2');
    Serial.println(EEPROM_read(0x01));
    SREG = sSREG;
}
 

과제

void EEPROM_write(unsigned int uiAddress, unsigned char ucData) {
    // 이전 쓰기 완료까지 대기
    while (EECR & (1 << EEPE)); // EEPE 비트 0 인지 확인
    // 주소와 데이터 레지스터 설정
    EEAR = uiAddress;
    EEDR = ucData;
    // EEMPE 비트 1로 설정
    EECR |= (1 << EEMPE);
    // EEPE 비트 1로 설정해 쓰기 시작
    EECR |= (1 << EEPE);
}

unsigned char EEPROM_read(unsigned int uiAddress) {
    // 이전 쓰기 완료까지 대기
    while (EECR & (1 << EEPE));
    // 주소 레지스터 설정
    EEAR = uiAddress;
    // EERE 비트 1로 설정해 읽기 시작
    EECR |= (1 << EERE);
    // 데이터 레지스터 데이터 반환
    return EEDR;
}

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

void loop() {
    char sSREG;
    sSREG = SREG;
    SREG = 0; // Interrupt disable 설정
    EECR = 0; // EEPM0,1 초기화, 읽기 지우기 가능

    for (unsigned int i = 1; i <= 100; i++) {
        EEPROM_write(i, i);
    }

    delay(2000);

    for (unsigned int i = 100; i >= 1; i--) {
        Serial.print("레지스터 ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(EEPROM_read(i));
    }

    SREG = sSREG;

    delay(2000);
}
 

13주차

#define switchPin 2 // 스위치 핀 번호 정의
#define ledPin 13   // LED 핀 번호 정의

volatile int state = LOW; // LED 상태 변수

void setup() {
    pinMode(switchPin, INPUT_PULLUP); // 스위치 핀을 풀업 입력으로 설정
    pinMode(ledPin, OUTPUT);          // LED 핀을 출력으로 설정
    attachInterrupt(digitalPinToInterrupt(switchPin), INT0_ISR, FALLING); // 인터럽트 설정
    Serial.begin(9600); 
    while (!Serial) {;} // 시리얼 포트 연결 대기
    Serial.println("Program Start...."); 
    delay(1000); 
}

void loop() {
    Serial.println("Statement ");
    delay(300);
}

void INT0_ISR() { // 인터럽트 서비스 루틴
    Serial.println("LED Toggled!"); 
}

#define switchPin 2 // 스위치 핀 번호 정의
#define ledPin 13   // LED 핀 번호 정의

volatile int state = LOW; // LED 상태 변수

void setup() {
    pinMode(switchPin, INPUT_PULLUP); // 스위치 핀을 풀업 입력으로 설정
    pinMode(ledPin, OUTPUT);          // LED 핀을 출력으로 설정
    attachInterrupt(digitalPinToInterrupt(switchPin), INT0_ISR, FALLING); // 인터럽트 설정
    Serial.begin(9600); 
    while (!Serial) {;} // 시리얼 포트 연결 대기
    
    Serial.println("Program Start...."); 
    delay(1000); 
}

void loop() {
    Serial.println("Statement ");
    delay(300);
}

void INT0_ISR() { // 인터럽트 서비스 루틴
    state = !state; 
    digitalWrite(ledPin, state); 
    Serial.println("LED Toggled!"); 
}

#include <TimerOne.h>

void setup() {
    pinMode(13, OUTPUT);          // 핀 10을 출력으로 설정
    Timer1.initialize(500000);    // initialize timer1, and set a 1/2 second period
    Timer1.pwm(2, 512);           // setup pwm on pin 9, 50% duty cycle
    Timer1.attachInterrupt(callback); // attaches callback() as a timer overflow interrupt
}

void callback() {
    // D10을 읽어 반전(XOR) 한다.
    digitalWrite(13, digitalRead(13) ^ 1); // XOR
}

void loop() {
    // your program here...여기에서 할 일이 없다.
}

int ledState10 = LOW;              
unsigned long previousMillis10 = 0; 
const long interval10 = 1000;       

int ledState9 = LOW;               
unsigned long previousMillis9 = 0;  
const long interval9 = 500;        

void setup() {
    pinMode(10, OUTPUT);           
    pinMode(9, OUTPUT);             
}

void loop() {
    unsigned long currentMillis = millis();

    if (currentMillis - previousMillis10 >= interval10) {
        previousMillis10 = currentMillis;
        if (ledState10 == LOW) {
            ledState10 = HIGH;
        } else {
            ledState10 = LOW;
        }
        digitalWrite(10, ledState10);
    }

    if (currentMillis - previousMillis9 >= interval9) {
        previousMillis9 = currentMillis;
        if (ledState9 == LOW) {
            ledState9 = HIGH;
        } else {
            ledState9 = LOW;
        }
        digitalWrite(9, ledState9);
    }
}
 

14주차

int Sensor1value = 0;
int Sensor2value = 0;

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

void loop() {

void Sensorread() {
    Sensor1value = analogRead(0);
    Sensor2value = analogRead(1);
    Serial.print(Sensor1value);
    Serial.print(",");
    Serial.println(Sensor2value);
    delay(1000);
}
 

댓글

guest