728x90

라즈비안 업데이트 및 업그레이드

1
sudo apt-get update & upgrade
cs

nginx 설치

1
sudo apt-get install nginx
cs

서비스 시작
1
sudo /etc/init.d/nginx start 
cs


php5 설치

1
sudo apt-get install php5-fpm
cs

인증을 위한 php5-mcrypt 설치
 
1
sudo apt-get install php5-mcrypt
cs


nginx에서 php 활성화

1
2
cd /etc/nginx
sudo nano sites-enabled/default
cs



찾기(ctrl+w)로 index index.html index.htm; 행을 찾아 다음과 같이 수정


1
index index.php index.html index.htm;
cs


location ~ \.php$ { 가 있는 행을 찾아 다음과 같이 수정


1
2
3
4
location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/var/run/php5-fpm.sock;
}
cs


서비스 재시작

1
sudo /etc/init.d/nginx reload
cs


php 테스트

1
sudo nano index.php
cs


php파일 내용

1
<?php echo phpinfo(); ?>
cs

이후 웹에서 확인하면 php버전과 설정을 확인하는 웹페이지가 열린다.




sqlite3와 php모듈 설치 


1
sudo apt-get install sqlite3 php5-sqlite
cs



sqlite php API는 아래 사이트에서 확인

http://www.tutorialspoint.com/sqlite/sqlite_php.htm




[ 라즈베리 파이 -삼바 설정 ]


삼바 설정

 sudo nano /etc/samba/smb.conf



맨 아래에 다음과 같은 설정 추가


[Web Server]

comment = Server HTML root

path = /var/www/html

browsable = yes

public = no

security = user

guest ok = no

read only = no

writeable = yes

create mask = 0755

directory mask = 0755



삼바 재시작

sudo service smbd restart



권한 조정


sudo adduser $USER root



그 다음 chmod와 chown으로 폴더 접근 및 읽기/쓰기를 가능하게 한다.


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

wizfi 250, mqtt-sqlite 센서값 전송  (0) 2017.08.03
라즈베리파이3, mosquitto  (0) 2017.07.31
라즈베리 HTTP 서버 구축  (0) 2017.06.27
GCM  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
728x90

아두이노 스케치 (wizfi250 기준)



PubSubClient 라이브러리 설치 후 아래의 소스코드 업로드



#include <SPI.h>

#include <WizFi250.h>

#include <PubSubClient.h>


// Update these with values suitable for your network.


const char* ssid = "SK_WiFiGIGAF5E0";

const char* password = "----"; 

const char* mqtt_server = "192.168.---";


WiFiClient WizFi250Client;

PubSubClient client(WizFi250Client);

long lastMsg = 0;

char msg[50];

int value = 0;


void setup_wifi();

void callback(char* topic, byte* payload, unsigned int length);

void reconnect();


void setup() {

  pinMode(7, OUTPUT);     

  Serial.begin(115200);

  setup_wifi();

  client.setServer(mqtt_server, 1883);

  client.setCallback(callback);

}


void setup_wifi() {


  delay(10);

  // We start by connecting to a WiFi network

  Serial.println();

  Serial.print("Connecting to ");

  Serial.println(ssid);


  WiFi.init();

  WiFi.begin((char*)ssid, password);


  while (WiFi.status() != WL_CONNECTED) {

    delay(500);

    Serial.print(".");

  }


  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}


void callback(char* topic, byte* payload, unsigned int length) {

  int i = 0;


  Serial.println("Message arrived: topic: " + String(topic));

  Serial.println("Length: "+ String(length,DEC));


  //create character buffer with ending null terminator (string)

  for(i=0; i<length; i++){

    msg[i] = payload[i];

  }

  msg[i]= '\0';


  String msgString = String(msg);

  Serial.println("Payload: "+ msgString);

  int state = digitalRead(7);

  //전송된 메시가 "led"이면 LED를 받을 때마다 켜고 끈다.(토글)

  if (msgString == "led_on"){

    digitalWrite(7, HIGH);

    Serial.println("LED ON...");

  }

  else if (msgString == "led_off"){

    digitalWrite(7, LOW);

    Serial.println("LED OFF...");

  }

}


void reconnect() {

  // Loop until we're reconnected

  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...");

    // Attempt to connect

    if (client.connect("WizFi250Client")) {    // 클라이언트가 2대 이상일 경우 이름을 다르게 적어준다.

      Serial.println("connected");

      // Once connected, publish an announcement...

      client.publish("iot", "WizFi250 hello world");    // iot/room1 ... iot/room2 등으로 구분 가능

      // ... and resubscribe

      client.subscribe("iot");

    } else {

      Serial.print("failed, rc=");

      Serial.print(client.state());

      Serial.println(" try again in 5 seconds");

      // Wait 5 seconds before retrying

      delay(5000);

    }

  }

}

void loop() {


  if (!client.connected()) {

    reconnect();

  }

  client.loop();


  long now = millis();  

}



// DHT11 센서값 json, db저장


#include <SPI.h>

#include <WizFi250.h>

#include <PubSubClient.h>

#include <DHT11.h>

#include <SimpleTimer.h>


#define DHTPIN 8  


SimpleTimer timer;

  

DHT11 dht11(DHTPIN); 

float temperature, humidity;

int err;

int setTemp;

char ch[60] = {0};

char ch2[60] = {0};


const char* ssid = "SK_WiFiGIGAF5E0";

const char* password = "1611010239";  

const char* mqtt_server = "192.168.35.163";


WiFiClient WizFi250Client;

WiFiClient client;


PubSubClient client2(WizFi250Client);

long lastMsg = 0;

char msg[50];

int value = 0;


void setup_wifi();

void callback(char* topic, byte* payload, unsigned int length);

void reconnect();


void setup() {

  pinMode(7, OUTPUT);     

  Serial.begin(115200);

  setup_wifi();

  client2.setServer(mqtt_server, 1883);

  client2.setCallback(callback);

  

  timer.setInterval(15000, notify);

}


void setup_wifi() {


  delay(10);

  // We start by connecting to a WiFi network

  Serial.println();

  Serial.print("Connecting to ");

  Serial.println(ssid);


  WiFi.init();

  WiFi.begin((char*)ssid, password);


  while (WiFi.status() != WL_CONNECTED) {

    delay(500);

    Serial.print(".");

  }


  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}


void callback(char* topic, byte* payload, unsigned int length) {

  int i = 0;


  Serial.println("Message arrived: topic: " + String(topic));

  Serial.println("Length: "+ String(length,DEC));


  //create character buffer with ending null terminator (string)

  for(i=0; i<length; i++){

    msg[i] = payload[i];

  }

  msg[i]= '\0';


  String msgString = String(msg);

  Serial.println("Payload: "+ msgString);

  int state = digitalRead(7);

  //전송된 메시가 "led"이면 LED를 받을 때마다 켜고 끈다.(토글)

  if (msgString == "led1_on"){

    digitalWrite(7, HIGH);

    Serial.println("LED ON...");

  }

  else if (msgString == "led1_off"){

    digitalWrite(7, LOW);

    Serial.println("LED OFF...");

  }


  if ( msgString == "temp_humidity#stat") {

     if ( (err=dht11.read(humidity, temperature) ) == 0 ) {      

      String str_temp(temperature);

      String str_hum(humidity);

      

      //str = "ROOM1#TEMP#" + str;

      //str.toCharArray(ch, str.length());

      

      String sensor_id = "\"Dummy-1\"";


      // Make JSON data      

      String msg = "{\"Sensor_ID\": ";

      msg += sensor_id;

      msg += ", \"Humidity\": ";

      msg += str_hum;

      msg += "}";

      msg.toCharArray(ch, msg.length() + 1);


      client2.publish("Home/BedRoom/DHT11/Humidity", ch);   


      // Make JSON data      

      String msg2 = "{\"Sensor_ID\": ";

      msg2 += sensor_id;

      msg2 += ", \"Temperature\": ";

      msg2 += str_temp;

      msg2 += "}";

      msg2.toCharArray(ch2, msg2.length() + 1);

      

      client2.publish("Home/BedRoom/DHT11/Temperature", ch2);   

    }

  }

}



void reconnect() {

  // Loop until we're reconnected

  while (!client2.connected()) {

    Serial.print("Attempting MQTT connection...");

    // Attempt to connect

    if (client2.connect("WizFi250Client0")) {

      Serial.println("connected");

      // Once connected, publish an announcement...

      // ... and resubscribe

      client2.subscribe("iot/room1");

      client2.subscribe("iot/temp");

      client2.subscribe("Home/BedRoom/DHT11/Humidity");

      client2.subscribe("Home/BedRoom/DHT11/Temperature");

      

    } else {

      Serial.print("failed, rc=");

      Serial.print(client2.state());

      Serial.println(" try again in 5 seconds");

      // Wait 5 seconds before retrying

      delay(5000);

    }

  }

}


void loop() {


  if (!client2.connected()) {

    reconnect();

  }

  client2.loop();

  timer.run();


  long now = millis();  

}


void notify() {

  // 일정 주기마다 실행

  if ( client2.state() == 0 ) {

     if ( (err=dht11.read(humidity, temperature) ) == 0 ) {      

      String str_temp(temperature);

      String str_hum(humidity);

      

      //str = "ROOM1#TEMP#" + str;

      //str.toCharArray(ch, str.length());

      

      String sensor_id = "\"Dummy-1\"";


      // Make JSON data      

      String msg = "{\"Sensor_ID\": ";

      msg += sensor_id;

      msg += ", \"Humidity\": ";

      msg += str_hum;

      msg += "}";

      msg.toCharArray(ch, msg.length() + 1);


      client2.publish("Home/BedRoom/DHT11/Humidity", ch);   


      // Make JSON data      

      String msg2 = "{\"Sensor_ID\": ";

      msg2 += sensor_id;

      msg2 += ", \"Temperature\": ";

      msg2 += str_temp;

      msg2 += "}";

      msg2.toCharArray(ch2, msg2.length() + 1);

      

      client2.publish("Home/BedRoom/DHT11/Temperature", ch2);   

    }

  }

}




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

라즈베리파이에서 nginx, php, php-sqlite 설치  (0) 2017.08.10
라즈베리파이3, mosquitto  (0) 2017.07.31
라즈베리 HTTP 서버 구축  (0) 2017.06.27
GCM  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
728x90

Install Mosquitto:

CODE: SELECT ALL

wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
sudo apt-key add mosquitto-repo.gpg.key
rm mosquitto-repo.gpg.key
cd /etc/apt/sources.list.d/
sudo wget http://repo.mosquitto.org/debian/mosquitto-repo.list
sudo apt-get update
sudo apt-get install mosquitto mosquitto-clients



Test Mosquitto:

(broker) Terminal window 1:

mosquitto -v


...port 1833 


(sub) Terminal window 2:

mosquitto_sub -t test




(pub) Terminal window 3:

mosquitto_pub -t test -m "Good morning"




허용된 유저만 접속하도록 설정



사용자 유저/패스워드를 담는 파일

sudo nano mosquitto_auth.txt   



mosquitto 설정 파일 수정

sudo nano /etc/mosquitto/mosquitto.conf



다음과 같이 수정한다.
allow_anonymous false

password_file /etc/mosquitto/mosquitto_auth.txt


사용자 추가

 sudo mosquitto_passwd /etc/mosquitto/mosquitto_auth.txt <사용자_이름>


비밀번호 입력 및 재 입력을 통해 추가한다.



이후 MQTT Dashboard에서 사용자 이름과 패스워드를 넣고 접속을 해야만 pub 이 가능한 걸 볼 수 있다.




mosquitto start / stop / restart

sudo /etc/init.d/mosquitto start



mosquitto 인증 플러그인


기존의 설치된 mosquitto를 제거, 아래 사이트에서 wget으로 최신 버전을 받아 압축해제한다.

https://mosquitto.org/download/



config.mk 파일 수정

WITH_SRV:=yes를 no로 수정



make 하고 make install 한다.



mosquitto-auth-plug 다운

https://github.com/jpmens/mosquitto-auth-plug


압축 해제 후 config.mk 파일을 적절하게 수정 (config.mk.in을 mk로 바꿔서 수정한다. 사전에 openssl 설치 및 컴파일도 필요)


# Select your backends from this list

BACKEND_CDB ?= no

BACKEND_MYSQL ?= yes

BACKEND_SQLITE ?= no

BACKEND_REDIS ?= no

BACKEND_POSTGRES ?= no

BACKEND_LDAP ?= no

BACKEND_HTTP ?= no

BACKEND_JWT ?= no

BACKEND_MONGO ?= no

BACKEND_FILES ?= no


# Specify the path to the Mosquitto sources here

# MOSQUITTO_SRC = /usr/local/Cellar/mosquitto/1.4.12


MOSQUITTO_SRC = /usr/local/mosquitto


# Specify the path the OpenSSL here


#OPENSSLDIR = /usr/bin

OPENSSLDIR = /usr/local/openssl


# Specify optional/additional linker/compiler flags here

# On macOS, add

#       CFG_LDFLAGS = -undefined dynamic_lookup

# as described in https://github.com/eclipse/mosquitto/issues/244


# CFG_LDFLAGS = -undefined dynamic_lookup  -L/usr/local/Cellar/openssl/1.0.2l/lib

# CFG_CFLAGS = -I/usr/local/Cellar/openssl/1.0.2l/include -I/usr/local/Cellar/mosquitto/1.4.12/include


#CFG_LDFLAGS = -undefined dynamic_lookup  -L/usr/local/openssl/

#CFG_CFLAGS = -I/usr/local/openssl/include -I/usr/local/mosquitto-1.4.14/include

#CFG_CFLAGS = -DRAW_SALT


make하여 생긴  auth-plug.so 파일을 mosquitto 경로(/usr/local/mosquitto) 로 옮겨준다.

mosquitto.conf 에서 # security 항목을 찾아 적절히 수정한다. 


#auth_plugin

auth_plugin /usr/local/mosquitto/auth-plug.so

auth_opt_backends mysql

auth_opt_host localhost

auth_opt_port 3306

auth_opt_dbname 


auth_opt_user root

auth_opt_pass 


auth_opt_userquery SELECT pw FROM users WHERE username = '%s'

#auth_opt_superquery SELECT IFNULL(COUNT(*), 0) FROM users WHERE username = '%s' AND super = 1

auth_opt_aclquery SELECT topic FROM acls WHERE username = '%s'


port 1883

protocol mqtt



mosquitto 브로커 시작

mosquitto -c /usr/local/mosquitto/mosquitto.conf




라즈베리파이 wlan 절전 해제


 sudo nano /etc/network/interfaces



wlan 항목 찾아서 wireless-power off 추가

auto wlan0

allow-hotplug wlan0

iface wlan0 inet dhcp

wireless-power off

    wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf





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

라즈베리파이에서 nginx, php, php-sqlite 설치  (0) 2017.08.10
wizfi 250, mqtt-sqlite 센서값 전송  (0) 2017.08.03
라즈베리 HTTP 서버 구축  (0) 2017.06.27
GCM  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
728x90


sudo python -m SimpleHTTPServer 80


 pip install flask

sudo python app.py host='0.0.0.0'


가상환경 구축


pip install virtualenv

virtualenv "프로젝트폴더명" 

cd 프로젝트폴더명

source bin\activate


pip install 시 에러가 난다면 시간 동기화 문제 때문일 수 있다. 그럴땐 아래와 같이 해결한다.


rdate 설치

sudo apt-get install rdate


시간 얻어오기

rdate -p time.bora.net


시간 설정

rdate -s time.bora.net



혹은 수동으로 시간 설정하려면


sudo date -s "2017-06-27 18:25:45"



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
from firebase import firebase
from flask import Flask, render_template, request
import threading
from subprocess import Popen, PIPE
from time import sleep
 
app = Flask(__name__)
 
thread = None
 
firebase = firebase.FirebaseApplication('https://androidpushservice-17$
#raspberry cpu temperature
def get_cpu_temperature():
        process = Popen(['vcgencmd', 'measure_temp'], stdout=PIPE)
        output, _error = process.communicate()
        return float(output[output.index('=') + 1:output.rindex("'")])
def background_thread():
        count = 0
        while True:
                cpu_temp = get_cpu_temperature()
                #database update
                firebase.patch('/raspberrypi3', {'temperature': cpu_te$
                sleep(30)
@app.route("/")
@app.route("/index")
def main():
        global thread
        if thread is None:
                thread = threading.Thread(target=background_thread)
                thread.start()
        return render_template('main.html')
if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True)
cs



온습도 (DHT-11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import Adafruit_DHT
import time
 
sensor = Adafruit_DHT.DHT11
pin = 4
 
while True:
    humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)
 
    if humidity is not None and temperature is not None:
        print('Temp={0:0.1f}*C humidity={1:0.1f}%'.format(temperature, humidity))
        time.sleep(2)
    else:
        print('Failed to get reading. Try again!')
cs


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
from firebase import firebase
from flask import Flask, render_template, request
import threading
from subprocess import Popen, PIPE
from time import sleep
import Adafruit_DHT
import time
 
app = Flask(__name__)
 
thread = None
 
sensor = Adafruit_DHT.DHT11
pin = 23
 
firebase = firebase.FirebaseApplication('https://androidpushservice-172000.firebaseio.com/', None)
 
#raspberry cpu temperature
def get_cpu_temperature():
        process = Popen(['vcgencmd''measure_temp'], stdout=PIPE)
        output, _error = process.communicate()
        return float(output[output.index('='+ 1:output.rindex("'")])
 
def background_thread():
        count = 0
        while True:
                cpu_temp = get_cpu_temperature()
                humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)
 
                if humidity is not None and temperature is not None:
                        print('Temp={0:0.1f}*C humidity={1:0.1f}%'.format(temperature, humidity))
                        print('Rpi 3 Cpu_Temp={0:0.1f}*C'.format(cpu_temp))
                else:
                        print('Failed to get reading. Try again!')
 
                #database update
                firebase.patch('/raspberrypi3', {'temperature': cpu_temp})
                firebase.patch('/raspberrypi3', {'room_temp' : temperature})
                firebase.patch('/raspberrypi3', {'room_humidity' : humidity})
                sleep(30)
 
@app.route("/")
@app.route("/index")
def main():
        global thread
        if thread is None:
                thread = threading.Thread(target=background_thread)
                thread.start()
        return render_template('main.html')
 
if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True, port=80)
cs



라이브러리 예제를 통한 실행


pi@raspberrypi78:~/Documents/app/Adafruit_Python_DHT/examples $ sudo ./AdafruitDHT.py 11 23

Temp=28.0*  Humidity=35.0%



LED 제어
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
66
67
68
69
70
71
72
 # -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
 
from flask import Flask, render_template, request
import RPi.GPIO as GPIO
 
app = Flask(__name__)
 
GPIO.setmode(GPIO.BCM)
 
leds = {
        21 : {'name' : 'Red LED''state' : GPIO.LOW},
        20 : {'name' : 'Green LED''state' : GPIO.LOW},
        16 : {'name' : 'Blue LED''state' : GPIO.LOW}
        }
 
for led in leds :
        GPIO.setup(led, GPIO.OUT)
        GPIO.output(led, GPIO.LOW)
 
def getGpioState():
        for led in leds:
                leds[led]['state'= GPIO.input(led)
 
        return leds
 
@app.route("/")
def main():
#for port in ports:
#ports[port]['state'] = GPIO.input(port)
        ledState = getGpioState()
 
        gpioState = {
                'leds' : ledState
        }
 
        return render_template('main.html'**gpioState)
 
@app.route("/<led>/<act>")
def action(led, act):
        led = int(led)
        leds = getGpioState()
        dev = leds[led]['name']
 
        if act == "on":
                GPIO.output(led, GPIO.HIGH)
                msg = dev + "를 켭니다."
        elif act == "off":
                GPIO.output(led, GPIO.LOW)
                msg = dev + "를 끕니다."
        elif act == "toggle":
                GPIO.output(led, not GPIO.input(led))
                msg = "토글 " + dev + "."
        else:
                msg = "예기치 않은 동작입니다!"
 
#for port in ports:
#ports[port]['state'] = GPIO.input(port)
 
        leds = getGpioState()
 
        gpioState = {
                'msg' : msg,
                'leds' : leds
        }
 
        return render_template('main.html'**gpioState)
 
if __name__ == "__main__":
        app.run(host='0.0.0.0', port=80, debug=True)
cs


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

wizfi 250, mqtt-sqlite 센서값 전송  (0) 2017.08.03
라즈베리파이3, mosquitto  (0) 2017.07.31
GCM  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
라즈베리 파이3, 기본 설정  (0) 2017.06.10
728x90



https://firebase.google.com/docs/




https://git-scm.com/downloads

Git Bash를 이용한 GCM 예제 다운로드


경로 지정 (D:\adt-bundle\sdk, 디렉토리가 없으면 미리 만든다)

1
 cd /d/adt-bundle/sdk
cs

GCM 예제 다운로드


1
 git clone https://github.com/google/gcm
cs


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

라즈베리파이3, mosquitto  (0) 2017.07.31
라즈베리 HTTP 서버 구축  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
라즈베리 파이3, 기본 설정  (0) 2017.06.10
아두이노 LCD  (0) 2017.06.01
728x90

Pi4J는 라즈베리파이에서 자바를 통해 GPIO제어를 할 수 있게하는 라이브러리이다.


간단한 Pi4J 설치법

1
curl -s get.pi4j.com | sudo bash
cs



GPIO 예제 참조


http://pi4j.com/example/control.html



예제 작성 

1
sudo nano Server.java
cs



컴파일

1
javac -classpath .:classes:/opt/pi4j/lib/'*' Server.java
cs


실행

1
sudo java -classpath .:classes:/opt/pi4j/lib/'*' Server
cs



만약 컴파일된 파일이 실행이 되지 않는다면 아래와 같이 해결 가능


커널(펌웨어) 버전 확인 (17. 6.19 기준)

1
uname -a
cs


커널 버전 변경 ( 해쉬값은 이곳에서 확인 https://github.com/Hexxeh/rpi-firmware )

1
sudo rpi-update 52241088c1da59a359110d39c1875cda56496764
cs


업데이트가 끝나면 리붓

1
sudo reboot
cs


다시 커널 버전을 확인해보자. 버전이 바뀐 것을 확인할 수 있다.

1
uname -a
cs



자바 버전 변경 (설치된 jdk중 선택)

sudo update-alternatives --config java; sudo update-alternatives --config java

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

라즈베리 HTTP 서버 구축  (0) 2017.06.27
GCM  (0) 2017.06.27
라즈베리 파이3, 기본 설정  (0) 2017.06.10
아두이노 LCD  (0) 2017.06.01
아두이노 기초  (0) 2017.05.25
728x90

라즈베리 파이3, 기본 설정

 

홈페이지  https://www.raspberrypi.org/

 

Raspbian Jessie 풀버전 다운로드

https://downloads.raspberrypi.org/raspbian_latest

 

 

Win32DiskImager 다운로드 (0.95 추천)

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


SD카드 포맷을 위한 포매터

https://www.sdcard.org/downloads/formatter_4/eula_windows/index.html


 

Device항목에 sd카드 드라이브명 확인후,

다운받은 Raspbian 이미지를 디스크 모양 아이콘을 눌러 선택하고 Write를 누른다.

 

 

 

 

[라즈베리 파이, 기본 세팅]

전원을 꼽는 순간 부팅된다.


sudo : SUbstitute user DO 의 줄임말, 관리자 권한의 계정으로 명령을 내림

su - : root권한 획득


$ : 일반계정

# : 루트계정 (sudo)


Ctrl + D : 로그아웃, 한번 더 입력하면 창을 닫는다.


apt-get 프로그램을 받음, 설치시 install 명령어를 뒤에 같이 씀

-> install (대상)

예) sudo apt-get install vim


sudo raspi-config // 라즈베리 파이 환경설정

1. Expand Filesystem // 파일시스템 확장(SD 카드 전체용량 사용하도록 확장)
2. Change User Password // pi계정 비밀번호 변경

5. Internationalisation Options  //언어, 키보드,타임존 등을 설정

sudo apt-get update  // 각 업데이트 저장소 에서 업데이트 패키지 목록을 갱신

apt-get 프로그램 받아서 설치해줌




[ 네트워크 설정 ]



네트워크 설정 파일을 찾아서 편집

1
cd /etc/network/
cs

interfaces 수정

1
sudo nano interfaces
cs

다음과 같이 수정한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# interfaces(5) file used by ifup(8) and ifdown(8)
 
# Please note that this file is written to be used with dhcpcd
# For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'
 
# Include files from /etc/network/interfaces.d:
source-directory /etc/network/interfaces.d
 
auto lo
iface lo inet loopback
 
auto eth0
allow-hotplug eth0
iface eth0 inet manual
 
auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
cs


Ctrl + x 누르고 Y눌러 저장 후 엔터눌러 종료



wap_supplicant.conf 수정

1
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
cs

다음과 같이 수정한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=US
 
network={
        ssid="Xiaomi"
        psk="12345678"
        key_mgmt=WPA-PSK
}
 
network={
        ssid=""
        psk=""
        key_mgmt=WPA-PSK
}
cs


네트워크 재시작

1
 sudo service networking reload
cs


그 다음 sudo reboot 또는 셧다운 메뉴를 통해 라즈베리 재시작



ifconfig를 통해 eth0또는 wlan의 ip주소를 확인한다 ( inet addr:192.168.~ )



원격 데스크탑 연결을 하려면

 sudo apt-get install xrdp  


원격 데스크탑 연결에서 사용자 명 pi를 넣어 접속


putty에서 접속하려면
호스트네임에 라즈베리파이 ip주소를 넣어 접속하고 기본 계정명(pi)와 비밀번호를 입력해 접속한다.



IP고정 및 포트포워딩


1
 sudo nano /etc/dhcpcd.conf
cs


최하단에 아래의 설정을 추가 (IP나 라우터, dns등은 자신의 네트워크 환경에 맞게 설정)

1
2
3
4
5
6
7
8
9
10
11
interface eth0
static ip_address=210.119.12.~
static routers=210.119.12.1
static domain_name_servers=210.119.0.2
static netmask=255.255.255.0
 
interface wlan0
static ip_address=
static router=
static domain_name_servers=8.8.8.8
static netmask=255.255.255.0
cs



그 다음 공유기 설정에서 포워딩 IP 주소를 고정 IP주소로 설정, DMZ 설정에도 마찬가지로 고정 IP주소로 설정하면 된다.

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

GCM  (0) 2017.06.27
라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
아두이노 LCD  (0) 2017.06.01
아두이노 기초  (0) 2017.05.25
ATMEGA USART-C# App 연동  (0) 2016.12.12
728x90

D pin에 다음과 같이 연결한다.

RS - 12, RW - 11, EN - 10

DATA 4~7 - D4~1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <LiquidCrystal.h>
 
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(121154321);
 
void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(162);
  // 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(01);
  // print the number of seconds since reset:
  lcd.print(millis() / 1000);
}
cs

LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,      uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)



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

라즈베리파이, Pi4J를 통한 GPIO 제어  (0) 2017.06.20
라즈베리 파이3, 기본 설정  (0) 2017.06.10
아두이노 기초  (0) 2017.05.25
ATMEGA USART-C# App 연동  (0) 2016.12.12
7/21 Atmega128 포트/ win32 api  (0) 2016.07.21
728x90

Arduino IDE 다운로드

https://www.arduino.cc/en/Main/Software




아두이노 웹 시뮬레이터

https://circuits.io/lab


// led 번갈아 깜박


led의 긴 핀은 Cathode(전류가 흘러나오는 쪽), 짧은 쪽이 Anode(전류가 흘러들어가는 쪽)이다.

led의 긴핀 (다리가 구부러진 쪽)을 D13에 짧은 쪽을 저항을 통해 GND에 연결한다.



void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second

  digitalWrite(12, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(12, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}



// fnd 0~9 표시



int a = 2, b = 3, c = 4, d = 5, e = 6, f = 8, g = 7;  // 선을 꽂을 때, 교차되지 않도록 f와 g를 바꿈
int led[7] = { a, b, c, d, e, f, g };

int digit[10][7] = { {1, 1, 1, 1, 1, 1, 0}, // 0
                     {0, 1, 1, 0, 0, 0, 0}, // 1
                     {1, 1, 0, 1, 1, 0, 1}, // 2
                     {1, 1, 1, 1, 0, 0, 1}, // 3
                     {0, 1, 1, 0, 0, 1, 1}, // 4
                     {1, 0, 1, 1, 0, 1, 1},
                     {0, 0, 1, 1, 1, 1, 1},
                     {1, 1, 1, 0, 0, 1, 0},
                     {1, 1, 1, 1, 1, 1, 1},
                     {1, 1, 1, 0, 0, 1, 1} };

void setup() {
  // put your setup code here, to run once:
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  for (int i=0; i<10; i++) {
    for (int j=0; j<7; j++) {
      digitalWrite(led[j], digit[i][j]);
    }
    delay(1000);
  }
}


// 건전지 전압 측정



//  택트 스위치로 LED 끄고 켜기


int sw = 2;
int led = 13;

void setup() {
  pinMode(sw, INPUT);
  pinMode(led, OUTPUT);
}

void loop() {
  if (digitalRead(sw) == HIGH)
  {
    digitalWrite(led, LOW);
  }
  else
  {
    digitalWrite(led, HIGH);    
  }
}



// pwm LED 단계적으로 밝아지게

아두이노에 pwm 표시가 있는 포트에 연결 (pwm 지원 아날로그 출력 포트에 연결)


analogWrite 함수를 사용한 pwm은 490Hz 주파수(1/490 sec 간격)로 HIGHT와 LOW를 오가며 전압을 변화시킨다.


밝기를 변화시킬 LED와 함께 사용할 저항 값은 다음과 같이 계산한다.


LED와 함께 사용할 저항 값 (Ω) = ( 전원 전압(V) - LED 규격 전압(V) )  /  정격 전류 (A)

     85 Ω =                   ( 5 V - 3.3 V )                 /   0. 02            


저항값이 꼭 정확히 맞아야 하는건 아니므로, 밝기 변화 단계는 적어지지만 무난하게 100 Ω 을 사용하면 된다.

byte n = 5;

void setup() {
  // put your setup code here, to run once:  
}

void loop() {
  for (int x = 0; x<n; x++)
  {
    analogWrite(9, x * 255 / n);  // pwm 아날로그 출력
    delay(1000);
  }
}


// 기울기 센서

void setup() { 
  pinMode(2, INPUT_PULLUP);
  pinMode(13, OUTPUT);
} 

void loop()
{ 
  boolean sw = false;

  while (sw == digitalRead(2));
  digitalWrite(13, LOW);
  delay(3000);
  digitalWrite(13, HIGH);
}


// piezo 스피커로 소리 출력

byte n = 5;

void setup() {
  // put your setup code here, to run once:  
}

void loop() {
  analogWrite(9, 255 / 2);
}


// PWM 아날로그 출력을 통한 모터 작동


int INA = 9; 
 
void setup() { }
 
void loop() { 
  for (int i=0; i<256; i+=5)  {
    analogWrite(INA, 255 - i);
    delay(100);
  }      
  delay(1000); 
}



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

라즈베리 파이3, 기본 설정  (0) 2017.06.10
아두이노 LCD  (0) 2017.06.01
ATMEGA USART-C# App 연동  (0) 2016.12.12
7/21 Atmega128 포트/ win32 api  (0) 2016.07.21
7/8 LCD제어2  (0) 2016.07.08
728x90

128usart.7z

main.c

SeialTest (3).7z


---------------------------------

SeialTest.7z



#include <avr/io.h>

#include <util/delay.h>


#define  CLR   0x01      //Clear Display 명령

#define  HOME  0x02      //Return Home 명령 

#define  FNC   0x38      //Function Set 명령 0b00111000

                //Data Length = 8bit. 행수 2행, 문자 폰트 5x8


#define CTL PORTL

#define DB PORTD


#define    RXC          7


void uart0_init(void)

{

UCSR0A = 0x00;

  UCSR0B = 0x18; //Enable transmitter

  UCSR0C = 0X06;        // No psrity, 1stop bit, 8bit data


  UBRR0L = 0x67; //set baud rate lo 16Mhz baud rate 9600!!

  UBRR0H = 0x00; //set baud rate hi

}


unsigned char USART_Receive(void)

{

/* Wait for data to be received */

while(!(UCSR0A &(1<<RXC)))

;


/* Get and return received data from buffer */

return UDR0;

}


void LCD_PortSetting(void)

{

  DDRD = 0xFF;        //data bus line

  DDRL = 0xFF;        //control line (0~2 제어핀 사용)

  //D0: RS ,D1: R/W ,D2: EN

}


void IR_Write(unsigned char Data)  

{

  CTL &= 0xFC;    //RS = 0, Write Enable

  _delay_us(1);    //Enable 까지 최소 대기 시간 40ns

  CTL |= 0x04;    //Enable 활성화

  _delay_us(1);    //

  DB = Data;    //Data

  _delay_us(1);

  CTL = 0b00000010;  //Disable, Read Mode  


}


void DR_Write(unsigned char Data)

{

  CTL = 0x01;    //RS = 1, Write Enable

  _delay_us(1);    //Enable 까지 최소 대기 시간 40ns

  CTL |= 0x04;    //Enable 활성화

  _delay_us(1);    //

  DB = Data;    //Data

  _delay_us(1);

  CTL = 0b00000010;  //Disable, Read Mode  

}


void LCD_Char(unsigned char ucChar)

{

  _delay_ms(1); // 명령어 쓰기 전 일정 시간 지연, Busy Flage 확인 대용

  DR_Write(ucChar);  

}


void LCD_Position(unsigned char ucCol, const char ucRow)

{

    IR_Write(0x80 | (ucRow + ucCol * 0x40));

}



void LCD_String(unsigned char ucLine,unsigned char ucRow, const char* ccString)        //    문자열 출력 함수

{                                                    // ucPosition 값에 따라 LCD_Position 값이 달라짐

    LCD_Position(ucLine, ucRow);

    while(*ccString != 0)                            //    *ccString이 null을 가리킬때까지

    {

        LCD_Char(*ccString);

        ccString++;                                    //    문자열의 주소값이 자료형만큼 증가

        if(*ccString <= 0x0F)

        {

            LCD_Position(1,0);

            _delay_ms(2);

        }

    }

}



void LCD_drive()

{

  _delay_ms(50);

  IR_Write(FNC);

  _delay_ms(5);

  IR_Write(FNC);

  _delay_us(100);

  IR_Write(FNC);

  _delay_ms(2);

  IR_Write(0x0E); // DDD RAM내용 표시, 커서 ON, 커서 깜빡임 OFF

  _delay_ms(2);  

  IR_Write(CLR); // Display Clear

  _delay_ms(30);

  IR_Write(0x06); // Entry Mode Set, 커서위치를 오른쪽으로 증가

  _delay_ms(2);

}



void LCD_Usart()

{

int cnt=0;

LCD_Delete();

_delay_ms(2);

LCD_Position(0,0);

while(1)

{

while((UCSR0A&0x80)==0x80)

{

LCD_Char(UDR0);

cnt++;

if(cnt==16)

{

cnt=0;

LCD_Delete();

_delay_ms(2);

}

}

}

}


void LCD_Delete(void)

{

    _delay_ms(1);

    IR_Write(0x01);

}


int main(void)

{

uart0_init();

  LCD_PortSetting();

  LCD_drive();    

  _delay_ms(2);


  DDRB = 0xFF;

PORTB = 0x00;


while(1)

{

LCD_Usart();

}

  return 0;

}



---------------------------------------------------------------------------

















#include <avr/io.h>


/////////// USART0 ///////////////////////////////////////////////

#define UDR0 (*((volatile unsigned char*)0xC6))


#define UCSR0A (*((volatile unsigned char*)0xC0))

#define UCSR0B (*((volatile unsigned char*)0xC1))

#define UCSR0C (*((volatile unsigned char*)0xC2))


#define UBRR0L (*((volatile unsigned char*)0xC4))

#define UBRR0H (*((volatile unsigned char*)0xC5))


#define    TXEN         3

#define    RXEN         4

#define    USBS        3

#define    UCSZ0        1

#define    UDRE        5

#define    RXC          7



#define FOSC 16000000 // Clock Speed

#define BAUD 9600 // Serial 

#define MYUBRR FOSC/16l/BAUD-1


void USART_Init(unsigned int ubrr);

void USART_Transmit(unsigned char data);

unsigned char USART_Receive(void);


int main(void)

{

int i;

USART_Init(MYUBRR);

USART_Transmit("T");

DDRB = 0xFF;

PORTB = 0x00;


while(1)

{

switch(USART_Receive())

{

case '1' : 

PORTB = 0xFF;

break;

case '2' :

PORTB = 0x00;

break;

case '3' :

PORTA = 0xFB;

break;

}

}

return 0;

}


void USART_Init(unsigned int ubrr)

{

/* Set baud rate */

UBRR0H = (unsigned char) (ubrr>>8);

UBRR0L = (unsigned char) ubrr;

/* Enable receiver and transmitter */

UCSR0B = (1<<RXEN) | (1<<TXEN);

/* Set frame format : 8data, 1stop bit */

UCSR0C = 3<<UCSZ0;

}


void USART_Transmit(unsigned char data)

{

/* Wait for empty transmit buffer */

while(! (UCSR0A & (1<<UDRE)))

;

UDR0 = data;

}


unsigned char USART_Receive(void)

{

/* Wait for data to be received */

while(!(UCSR0A &(1<<RXC)))

;


/* Get and return received data from buffer */

return UDR0;

}



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

아두이노 LCD  (0) 2017.06.01
아두이노 기초  (0) 2017.05.25
7/21 Atmega128 포트/ win32 api  (0) 2016.07.21
7/8 LCD제어2  (0) 2016.07.08
7/5 LCD 제어  (0) 2016.07.05

+ Recent posts