하루y

라즈베리 설치

1. 준비물

2. sd 카드 포맷

- sd formatter 설치

https://www.sdcard.org/downloads/formatter_4/

- sd 카드 포맷

. 옵션 Overwrite 선택 후 format.

3. O/S 설치

- O/S 다운로드

. https://www.raspberrypi.org/downloads/

. RASPBIAN 다운로드

- Win32 Disk Imager 설치

. https://sourceforge.net/projects/win32diskimager/

* 라즈베리 설치 후 할 일

http://kbc20000.blog.me/220923788944

. 한글 설정은 네트워크 설정 후 할 것.

. wifi 로켈일은 US 해아 wifi 설정되고, koKR로 하면 못 잡음!!

http://cosmosjs.blog.me/221051663695

http://webnautes.tistory.com/903

=> wifi 설정

=> X-window 이면, 우측 상단 wifi 에서 ap 선택하면 됨.

http://kkokkal.tistory.com/1292

==> 한글 참조 설정. fonts를 받아야 하기 때문에 network/wifi 설정 후 할 것.

http://webnautes.tistory.com/903

==> 한글을 사용하기 위해서, 폰트를 설치해야 하는 데 apt-get update 이후 해야 됨. 이전에는 리소스를 찾지 못함.

$ sudo apt-get update

$ sudo apt-get install ibus ibus-hangul

$ sudo apt-get install ttf-unfonts-core

[출처] 라즈베리파이3 한글입력을 위한 설치와 설정|작성자 코스모스

==> ttf-unfonts-core 리소스를 찾을 수 없어서, apt-get 안내에 따라, fonts-unfonts-core 로 대신 설치함. (성공!!!!)

4. linux 접속

- putty 를 이용한 ssh 포트 접속

- vnc 접속

. https://www.realvnc.com/en/connect/download/viewer/ 에서 vnc viewr 받아서 접속

토양수분센서에 따른 특성 분석 후 적용이 필요함.

// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

#include "DHT.h"

#define DHT_TYPE DHT11   // DHT 11

// 핀설정
#define DHT_PIN 6     // what digital pin we're connected to
#define SOIL_SENSOR_PIN A0     // what digital pin we're connected to
#define SOIL_RELAY_PIN 8 // 토양센서에 결과에 따른 제어 relay 핀

#define DHT_USE_YN 0
#define SOIL_SENSOR_USE_YN 1
#define WATER_RELAY_USE_YN 1

#define SOIL_HUMIDITY_INDEX 40 // 물을 주기 위한 습도 임계치값. 임계치 이하면, 물을 공급한다.
#define WATER_SUPPLY_TIME 10 // 물 공급 시간 (기본:10초)
#define WATER_SUPPLY_INTERVAL_TIME (60 * 1) // 물공급 인터벌 시간. 기본: 10 분(60초 * 10분)

#define LOOP_INTERVAL_TIME 2 // 루프 인터벌 시간 (기본:2초)

DHT dht(DHT_PIN, DHT_TYPE);

// loop 에서 센서 처리 여부
int checkedSensor = 0;
// 물공급 delya time
int waterDelayTime = 0;

void setup() {
  Serial.begin(9600);
  pinMode(SOIL_RELAY_PIN, OUTPUT);
  
  if(DHT_USE_YN) {
    Serial.println("DHT beging...");
    dht.begin();    
  }
}

// DHT 센서 처리
void processDhtSensor() {  
  // DHT 센서 처리 ////////////////////////////
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }  

  Serial.print("Humidity: ");
  Serial.print(h);
  Serial.print(" %\t");
  
  Serial.print("Temperature: ");
  Serial.print(t);
  Serial.print(" *C");
}

void processSoilSensor() {
  // 토양 센서 처리 //////////////////////////
  int soilAnalogValue = analogRead(SOIL_SENSOR_PIN);
  int soilDigitalValue = map(soilAnalogValue, 0, 630, 0, 100); // Max(물에 잠길때) : 540 ~ 630, Min: 0
  soilDigitalValue = constrain(soilDigitalValue, 0, 100);
  
  Serial.print("Soil moisture(Digital/Analog): ");
  Serial.print(soilDigitalValue);
  Serial.print(" (%) / ");
  Serial.print(soilAnalogValue);
             
  if(WATER_RELAY_USE_YN && soilDigitalValue < SOIL_HUMIDITY_INDEX) {
    // 습도가 0보다는 크고, 인덱스값보다 작을 때 물을 공급한다. 
    if(soilDigitalValue < 1) {
      Serial.print("\t토양센스가 습도를 측정하고 있지 않습니다.");          
    } else {
      waterDelayTime -= LOOP_INTERVAL_TIME;
      if(waterDelayTime < 1) { // 물공급 인터벌 시간이 지나야, 추가로 물을 공급할 수 있다.
        waterDelayTime = WATER_SUPPLY_INTERVAL_TIME;
        digitalWrite(SOIL_RELAY_PIN, HIGH);  
        Serial.print("\trelay on(");    
        Serial.print(WATER_SUPPLY_TIME);    
        Serial.print("초)");    
        delay(WATER_SUPPLY_TIME * 1000);  
        digitalWrite(SOIL_RELAY_PIN, LOW);  
        Serial.print("\trelay off");        
      } else {
        Serial.print("\t물공급 인터벌 시간이 아직 지나지 않았습니다.(");          
        Serial.print(waterDelayTime);          
        Serial.print("초 남음.)");                  
      }      
    }
  }
}


void loop() {
  delay(LOOP_INTERVAL_TIME * 1000);
  
  checkedSensor = 0;
  
  // DHT 센서 처리
  if(DHT_USE_YN) {
    processDhtSensor();  
    checkedSensor++;
    Serial.print("\t");
  }

  // 토양 센서 처리
  if(SOIL_SENSOR_USE_YN) {
    processSoilSensor();
    checkedSensor++;
    Serial.print("\t");
  }

  if(checkedSensor > 0) {
    Serial.println("");  
  }
}

#include <SoftwareSerial.h>
#include "ESP8266.h"

#define DEBUG true

#define SSID "U+Net5B6F"
#define PASS "1000019118"
#define DST_IP "211.172.246.98" //baidu.com

SoftwareSerial esp8266Serial = SoftwareSerial(2, 3);
ESP8266 wifi = ESP8266(esp8266Serial);

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

    // ESP8266
    esp8266Serial.begin(9600);
    wifi.begin();
    wifi.setTimeout(1000);

    /****************************************/
    /******       Basic commands       ******/
    /****************************************/
    // test
    Serial.print("test: ");
    Serial.println(getStatus(wifi.test()));

    // restart
    Serial.print("restart: ");
    Serial.println(getStatus(wifi.restart()));

    // getVersion
    char version[16] = {};
    Serial.print("getVersion: ");
    Serial.print(getStatus(wifi.getVersion(version, 16)));
    Serial.print(" : ");
    Serial.println(version);

    // setWifiMode
    ************************************/
    // joinAP
    Serial.print("joinAP: ");
    Serial.println(getStatus(wifi.joinAP(SSID, PASS)));
    
    // getIP
    Serial.println("getIP: ");
    sendData("AT+CIFSR\r\n", 1000, DEBUG); // wifi mode : 1:station,2:AP, 3:dual

    /****************************************/
    /******       TCP/IP commands      ******/
    /****************************************/
    //서버모드로 하기전에 다중접속모드를 on 해야, 서버시작시 오류가 발생하지 않음.
    sendData("AT+CIPMUX=1\r\n", 1000, DEBUG);
    // createServer
    unsigned int port = 80;
    Serial.print("createServer: ");
    Serial.println(getStatus(wifi.createServer(port))); // port

}

void loop()
{
    /****************************************/
    /******        WiFi commands       ******/
    /****************************************/

    // read data
    unsigned int id;
    int length;
    int totalRead = 0;
    unsigned int bufferSize = 256;    
    char buffer[bufferSize] = {};

    if ((length = wifi.available()) > 0) {
      id = wifi.getId();
      if (length > 0) {
        do {        
          totalRead += wifi.read(buffer, bufferSize);
          Serial.print("Received ");
          Serial.print(totalRead);
          Serial.print("/");
          Serial.print(length);
          Serial.print(" bytes from client ");
          //Serial.print("from client ");
          Serial.print(id);
          Serial.println(": ");
          Serial.println((char*)buffer);
          wifi.flush();
        } while (totalRead < length);
      }
    }
}


void getConnectionStatue(ESP8266 wifi) {
    ESP8266ConnectionStatus connectionStatus;
    ESP8266Connection connections[5];
    unsigned int connectionCount;
    Serial.print("getConnectionStatus: ");
    Serial.print(getStatus(wifi.getConnectionStatus(connectionStatus, connections, connectionCount)));
    Serial.print(" : ");
    Serial.println(connectionCount);
    for (int i = 0; i < connectionCount; i++) {
      Serial.print(" - Connection: ");
      Serial.print(connections[i].id);
      Serial.print(" - ");
      Serial.print(getProtocol(connections[i].protocol));
      Serial.print(" - ");
      Serial.print(connections[i].ip);
      Serial.print(":");
      Serial.print(connections[i].port);
      Serial.print(" - ");
      Serial.println(getRole(connections[i].role));
    }
  delay(200);
}

String getStatus(bool status)
{
    if (status)
        return "OK";

    return "KO";
}

String getStatus(ESP8266CommandStatus status)
{
    switch (status) {
    case ESP8266_COMMAND_INVALID:
        return "INVALID";
        break;

    case ESP8266_COMMAND_TIMEOUT:
        return "TIMEOUT";
        break;

    case ESP8266_COMMAND_OK:
        return "OK";
        break;

    case ESP8266_COMMAND_NO_CHANGE:
        return "NO CHANGE";
        break;

    case ESP8266_COMMAND_ERROR:
        return "ERROR";
        break;

    case ESP8266_COMMAND_NO_LINK:
        return "NO LINK";
        break;

    case ESP8266_COMMAND_TOO_LONG:
        return "TOO LONG";
        break;

    case ESP8266_COMMAND_FAIL:
        return "FAIL";
        break;

    default:
        return "UNKNOWN COMMAND STATUS";
        break;
    }
}

String getRole(ESP8266Role role)
{
    switch (role) {
    case ESP8266_ROLE_CLIENT:
        return "CLIENT";
        break;

    case ESP8266_ROLE_SERVER:
        return "SERVER";
        break;

    default:
        return "UNKNOWN ROLE";
        break;
    }
}

String getProtocol(ESP8266Protocol protocol)
{
    switch (protocol) {
    case ESP8266_PROTOCOL_TCP:
        return "TCP";
        break;

    case ESP8266_PROTOCOL_UDP:
        return "UDP";
        break;

    default:
        return "UNKNOWN PROTOCOL";
        break;
    }
}

void sendData(String command, const int timeout, boolean debug) {
  String response = "";
  esp8266Serial.print(command);
  long int time = millis();

  while((time + timeout) > millis()) {
    while(esp8266Serial.available()) {
      char c = esp8266Serial.read();
      response += c;
    }
  }

  if(debug) {
    Serial.println(response);
  }
}