인공지능&로봇 자료실

 $ sudo nano /etc/nginx/sites-available/default

server {

listen 8080;

location / {

proxy_pass http://127.0.0.1:30001/;

proxy_http_version 1.1;

proxy_set_header Upgrade $http_upgrade;

proxy_set_header Connection "upgrade";

}

}

 $ sudo service nginx restart 

 $ su

 $ sudo passwd

 $ curl https://get.acme.sh | sh -s email='이메일주소'

 $ mkdir /home/pi/node-server/ssl

 $ export DuckDNS_Token="duckDNS 토큰"

 # export CERT_FOLDER="/home/pi/node-server/ssl"

 $ acme.sh --insecure --issue \

   -d "robotstory-iot.duckdns.org" --dns dns_duckdns \

   --cert-file "$CERT_FOLDER/cert.pem" \

   --key-file "$CERT_FOLDER/privkey.pem" \

   --fullchain-file "$CERT_FOLDER/fullchain.pem" \

   --capath "$CERT_FOLDER/chain.pem"

 $ acme.sh --set-default-ca --server letsencrypt

 $ acme.sh list

 $ nano /etc/nginx/sites-available/default

server {

        listen 443 ssl;

        listen [::]:443 ssl;

        server_name robotstory-iot.duckdns.org;

        ssl on;

        ssl_certificate /home/pi/node-server/ssl/fullchain.pem;

        ssl_certificate_key /home/pi/node-server/ssl/privkey.pem;

        ssl_trusted_certificate /home/pi/node-server/ssl/chain.pem;

        location / {

                proxy_pass http://127.0.0.1:30001/;

                proxy_http_version 1.1;

                proxy_set_header Upgrade $http_upgrade;

                proxy_set_header Connection "upgrade";

        }

}

 $ service nginx restart

 $ exit

 $ sudo nano /home/pi/node-server/html/script.js

const btn = document.getElementById('switch');

let webSocket;

const socketInit = () => {

webSocket = new WebSocket("wss://robotstory-iot.duckdns.org");

webSocket.onmessage = (e) => {

if (e.data == 'on') {

btn.className = "on";

btn.innerText  = "ON";

}

else if (e.data == 'off') {

btn.className = "off";

btn.innerText  = "OFF";

}

}

webSocket.onclose = () => {

btn.className = "unknown";

btn.innerText  = "UNKNOWN";

setTimeout(socketInit, 300);

}

btn.onclick = () => {

if (btn.className == 'on') {

webSocket.send('off');

}

else if (btn.className == 'off') {

webSocket.send('on');

}

}

}

socketInit();

 $ sudo nano /home/pi/node-server/app.js

const express = require('express');

const wsModule = require('ws');

const mqtt = require('mqtt');

const clova = require('./clova');

const {

SERVER_PORT, 

MQTT_SERVER_IP, 

PUBLISH_TOPIC, 

SUBSCRIBE_TOPIC

} = require('./config');

// *** Web Application Server Create

const app = express();

app.use(express.json());

app.use(express.urlencoded({ extended: true }));

app.use(express.static(__dirname + '/html'));

// *** Clova Server

app.use('/clova', clova);

// *** 404 Error

app.use((req, res) => {

res.status(404).send('Not Found');

});

const HTTPServer = app.listen(SERVER_PORT, () => {

    console.info(`Server is running on ${SERVER_PORT} port`);

});

// ****************************

// *** MQTT Client Create

const mqtt_client = mqtt.connect(`mqtt://${MQTT_SERVER_IP}`);

let status = '';

mqtt_client.on('connect', function () {

mqtt_client.subscribe(SUBSCRIBE_TOPIC, {qos: 1});

});

// ****************************

// *** WebSocket Create

const webSocketServer = new wsModule.Server({server: HTTPServer});

let clients = [];

mqtt_client.on('message', (topic, msg) => {

for (let client of clients) {

if (client.readyState === client.OPEN) {

client.send(msg.toString().toLowerCase());

}

}

});

webSocketServer.on('connection', (client, req) => {

const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;

clients.push(client);

mqtt_client.publish(PUBLISH_TOPIC, '', {qos: 1});

console.info(`Enter the new client: ${ip}`);

client.on('message', (msg) => {

try {

if (msg.toString().toLowerCase() == 'on') {

mqtt_client.publish(PUBLISH_TOPIC, 'on', {qos: 1});

} 

else if (msg.toString().toLowerCase() == 'off') {

mqtt_client.publish(PUBLISH_TOPIC, 'off', {qos: 1});

}

}

catch (err) {

console.error(err);

client.send('error');

}

});

client.on('error', (err) => {

console.error(`Client ${ip} connection error: ${err}`); 

});

client.on('close', () => {

const idx = clients.indexOf(client);

if (idx != -1) {

clients.splice(idx, 1);

}

console.info(`Client ${ip} connection has been closed.`);

});

});

 $ sudo nano /home/pi/node-server/config.js

module.exports = {

SERVER_PORT: process.env.SERVER_PORT || 30001,

MQTT_SERVER_IP: '127.0.0.1',

PUBLISH_TOPIC: 'cmnd/tasmota/POWER',

SUBSCRIBE_TOPIC: 'stat/tasmota/POWER',

}

 $ sudo mkdir /home/pi/node-server/clova && sudo nano /home/pi/node-server/clova/index.js

const express = require('express');

const mqtt = require('mqtt');

const router = express.Router();

const {MQTT_SERVER_IP, PUBLISH_TOPIC, SUBSCRIBE_TOPIC} = require('../config');

const client = mqtt.connect(`mqtt://${MQTT_SERVER_IP}`);

router.post('/', function (req, res) {

let command = req.body.header.name;

switch (command) {

case "DiscoverAppliancesRequest":

DiscoverAppliancesRequest(req, res);

break;

case "HealthCheckRequest":

HealthCheckRequest(req, res);

break;

case "TurnOnRequest":

TurnOnRequest(req, res);

break;

case "TurnOffRequest":

TurnOffRequest(req, res);

break;

default:

res.sendStatus(403);

break;

}

});

router.get('/login', function (req, res) {

console.log(req.query);

let url = decodeURIComponent(req.query.redirect_uri)+"?state="+req.query.state+"&code="+"FakeToken"+"&token_type=Bearer";

res.redirect(url);

});

router.post('/token',function(req,res){

  res.send(`

  {

"access_token":"fakeAccess",

"refresh_token":"fakeRefresh"

  }

  `);

});

function DiscoverAppliancesRequest(req, res) {

let messageId = req.body.header.messageId;

let resultObject = new Object();

resultObject.header = new Object();

resultObject.header.messageId = messageId;

resultObject.header.name = "DiscoverAppliancesResponse ";

resultObject.header.namespace = "HomeIOT";

resultObject.header.payloadVersion = "1.0";

resultObject.payload = new Object();

resultObject.payload.discoveredAppliances = new Array();

let switchbot = new Object();

switchbot.applianceId = "ESP01-001";

switchbot.manufacturerName = " Ai-Thinker";

switchbot.modelName = "ESP-01";

switchbot.friendlyName = "전등";

switchbot.version = "9.5.0"

switchbot.isIr = false;

switchbot.actions = ["HealthCheck", "TurnOn", "TurnOff"];

switchbot.applianceTypes = ["SWITCH"];

resultObject.payload.discoveredAppliances.push(switchbot);

res.send(resultObject);

}

function HealthCheckRequest(req, res) {

const client = mqtt.connect(`mqtt://${MQTT_SERVER_IP}`);

client.on('connect', function () {

client.subscribe(SUBSCRIBE_TOPIC, {qos: 1});

let messageId = req.body.header.messageId;

let resultObject = new Object();

resultObject.header = new Object();

resultObject.header.messageId = messageId;

resultObject.header.name = "HealthCheckResponse ";

resultObject.header.namespace = "HomeIOT";

resultObject.header.payloadVersion = "1.0";

resultObject.payload = new Object();

resultObject.payload.isReachable = true;

client.on('message', (topic, msg) => {

if (msg.toString().toLowerCase() == "on") {

resultObject.payload.isTurnOn = true;

} 

else {

resultObject.payload.isTurnOn = false;

}

res.send(resultObject);

client.end();

});

client.publish(PUBLISH_TOPIC, "", {qos: 1});

});

}

function TurnOnRequest(req, res) {

client.publish(PUBLISH_TOPIC, "ON");

let applianceId = req.body.payload.appliance.applianceId;

let messageId = req.body.header.messageId;

let resultObject = new Object();

resultObject.header = new Object();

resultObject.header.messageId = req.body.header.messageId;

resultObject.header.name = "TurnOnConfirmation";

resultObject.header.payloadVersion = "1.0";

resultObject.payload = new Object();

res.send(resultObject);

}

function TurnOffRequest(req, res) {

client.publish(PUBLISH_TOPIC, "OFF");

let applianceId = req.body.payload.appliance.applianceId;

let messageId = req.body.header.messageId;

let resultObject = new Object();

resultObject.header = new Object();

resultObject.header.messageId = req.body.header.messageId;

resultObject.header.name = "TurnOffConfirmation";

resultObject.header.payloadVersion = "1.0";

resultObject.payload = new Object();

res.send(resultObject);

}

module.exports = router;