def seperated_image_ratio(frame1, frame2, unit):
#unit의 수만큼 이미지를 분할하여 분할된 이미지의 pixel_ratio를 array에 저장
ratio_arr = np.zeros((unit,unit), dtype = int)
U = int(frame1.shape[0]/unit)
# ratio 행렬 생성
for i in range(unit):
for j in range(unit):
img_trim1 = frame1[i*U:(i+1)*U, j*U:(j+1)*U] img_trim2 = frame2[i*U:(i+1)*U, j*U:(j+1)*U] ratio = int(pixel_ratio(img_trim1, img_trim2))
ratio_arr[i,j] = ratio return ratio_arr

def wetpoint_array(r_arr):
# 1. 각각의 unit의 인접한 unit의 ratio값의 차가 일정 값을 넘으면 wet list에 좌표 값 저장
# 2. unit의 ratio값이 일정 값을 넘으면 wet list에 좌표 값 저장
wet_arr = np.zeros(r_arr.shape, dtype = int)
ref1 = 25 # 인접한 unit간 ratio차이의 기준값
ref2 = 50 # unit의 ratio 기준값
for i in range(len(r_arr[0])):
for j in range(len(r_arr[1])):
R = r_arr[i,j] # 조건 1
Rlst = [] if (1<=i<=len(r_arr[0])-2 and 1<=j<=len(r_arr[1])-2):
for m in range(3):
for n in range(3):
Rlst.append(r_arr[i-1+m,j-1+n])
for r in Rlst:
if r-R > ref1:
wet_arr[i,j] = 1
# 조건 2
if np.mean(r_arr)-R > ref2 and R!=0:
wet_arr[i,j] = 1
return wet_arr

* 자동차에 내장되는 디스플레이 장치 주변 아두이노에 업로드 되는 코드
* 라즈베리파이 (센서 데이터 요청) -> 아두이노 (센서 데아터 처리) -> 라즈베리파이
* GPS 모듈을 통해 실시간 위도 및 경도 데이터 추출
* DHT11 온습도 센서를 통해 실시간 대기 온습도 추출
* 적외선 온도센서를 통한 실시간 노면 온도 추출
* HC-06을 통해 원격의 다른 차량에게 실시간 경고 신호 송신
* 다른 자동차 -> 아두이노 -> 라즈베리파이
* 주변 자동차에서 발생하는 경고 신호 수신해 라즈베리파이에 경고 신호 수신 내용 전달
*/

#include<SPI.h>
#define OBJECT 0xA0 // 대상 온도 커맨드
#define SENSOR 0xA1 // 센서 온도 커맨드
boolean Timer1_Flag;
const int chipSelectPin = 53;
int iOBJECT, iSENSOR; // 부호 2byte 온도 저장 변수

String GPS_DATA;
String BT_DATA;
boolean BT_FLAG;
String RASP_DATA;
boolean RASP_FLAG;
boolean ALARM_FLAG,SEND_FLAG;
unsigned long ALARM_TIME;
unsigned long GPS_LAST, BT_TIME;

String dummy_lattitude = “3733.3614″; // 실내 GPS 안잡히는 경우, 임시 위도 경도
String dummy_longitude = “12702.7910″;

#include “DHT.h”
#define DHTPIN 2 //온습도 센서 디지털 2번에 신호선 연결
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

String lattitude;
String longitude;
int hum;
int temp;
float road_temp;

int SPI_COMMAND(unsigned char cCMD) // 적외선 온도 센서에 온도 정보 요청
{
unsigned char T_high_byte, T_low_byte;
digitalWrite(chipSelectPin , LOW);
delayMicroseconds(10);
SPI.transfer(cCMD);
delayMicroseconds(10);
T_low_byte = SPI.transfer(0×22);
delayMicroseconds(10);
T_high_byte = SPI.transfer(0×22);
delayMicroseconds(10);
digitalWrite(chipSelectPin , HIGH);
return (T_high_byte<<8 | T_low_byte); // 온도값 return */

}
void setup() {

// put your setup code here, to run once:
Serial2.begin(9600);
Serial.begin(9600);
Serial3.begin(9600);
digitalWrite(chipSelectPin , HIGH);
pinMode(chipSelectPin , OUTPUT);
SPI.setDataMode(SPI_MODE3);
SPI.setClockDivider(SPI_CLOCK_DIV16);
SPI.setBitOrder(MSBFIRST);
SPI.begin();
}

void loop()
{
if(Serial3.available()) // 다른 차량에서 발생한 외부에서 노면 미끄러움 정보를 수신한 경우
{
char data = Serial3.read();
BT_DATA += data;
BT_FLAG =true;
BT_TIME = millis();
}
else if(BT_FLAG == true && millis() – BT_TIME > 100)
{
BT_FLAG = false;
//Serial.println(BT_DATA.length());
if(BT_DATA.indexOf(‘B’) != -1)
{
Serial.println(“hello”);
ALARM_FLAG = true;
ALARM_TIME = millis();
SEND_FLAG = true;
}
BT_DATA =”";
}
if(millis() – ALARM_TIME > 3000 && ALARM_FLAG == true)
{
ALARM_FLAG = false; //경보 해제
SEND_FLAG = true;
}
//////////////////////////////////////////////////////////////////////////////////
if(Serial.available()) // 자동차 내장 라즈베리파이가 노면 미끄러움을 영상으로 인식한 경우
{
char data = Serial.read();
RASP_DATA += data;
RASP_FLAG = true;
}
else if(RASP_FLAG == true)
{
RASP_FLAG = false;
Serial3.println(RASP_DATA);
RASP_DATA =”";
}
if( RASP_DATA == “B”)
{
SEND_FLAG = true;
}
//////////////////////////////////////////////////////////////////////////////////
if(Serial2.available() && !Serial3.available() && !Serial.available())
{
char data;
data = (char)Serial2.read();
GPS_DATA += data;
GPS_LAST = millis();
}
if(millis() – GPS_LAST > 100)
{
//Serial.print(GPS_DATA);
int data_start = GPS_DATA.indexOf(“GPRMC”);
int data_end = GPS_DATA.indexOf(“GPVTG”);
if(data_start >0 && data_end >0)// 유효 데이터 확인
{
//Serial.print(data_start); Serial.print(” “); Serial.println(data_end);
GPS_DATA = GPS_DATA.substring(data_start, data_end);
//Serial.println(GPS_DATA);
int first_comma = GPS_DATA.indexOf(“,”);
int second_comma = GPS_DATA.indexOf(“,”, first_comma+1);
int third_comma = GPS_DATA.indexOf(“,”, second_comma+1);
int fourth_comma = GPS_DATA.indexOf(“,”, third_comma+1);
int fifth_comma = GPS_DATA.indexOf(“,”, fourth_comma+1);
int sixth_comma = GPS_DATA.indexOf(“,”, fifth_comma+1);

lattitude = GPS_DATA.substring(third_comma+1, fourth_comma); //위도
longitude = GPS_DATA.substring(fifth_comma+1, sixth_comma); //경도
//GPRMC,000505.021,V,,,,,0.00,0.00,060180,,,N*41
}
GPS_DATA = “”;
hum = dht.readHumidity(); //대기습도
temp = dht.readTemperature(); //대기온도
// 이 부분에 적외선 온도 센서 시작
iOBJECT = SPI_COMMAND(OBJECT); // 대상 온도 Read
road_temp = float(iOBJECT)/100,2;
// 이 부분에 적외선 온도 센서 끝
//Serial.print(“ROAD :”); Serial.println(road_temp);
// 라즈베리파이에 정보 송신
}

if(SEND_FLAG == true)
{
if(lattitude.length() <3)
lattitude = dummy_lattitude;
if(longitude.length() <3)
longitude = dummy_longitude;
SEND_FLAG = false;
Serial.print(“A ,”);
Serial.print(lattitude); Serial.print(“,”);
Serial.print(longitude); Serial.print(“,”);
Serial.print(hum); Serial.print(“,”);
Serial.print(temp); Serial.print(“,”);
Serial.print(road_temp); Serial.print(“,”);
Serial.print(ALARM_FLAG ? ‘T’ : ‘F’); Serial.print(“,”);
Serial.println();
}
}

import os
import cv2
import numpy as np
import math
import time
import sys
import socket
WARN_FLAG = False

”’
1. 웹캠 이미지 리드
2. ROI 설정
3. 픽셀 값의 평균으로 필터링: 평균값보다 크면 255(white), 작으면 0(black)
4. 설정한 unit 크기로 이미지를 분할해 각각의 픽셀 수 차이 계산
5. wet으로 판단되는 unit을 box로 표시
6. box의 갯수가 일정 값 이상이면 count: while문으로 순환하기 때문에 count를 세서 지속적으로 wet일때만 젖은 도로라고 판단
7. count가 일정 값 이상이면 ‘WET ROAD DETECTED’ 출력
”’
”’
wet 판단 기준
# unit의 ratio값이 일정값 이하
# 인접한 unit의 ratio값 차이가 일정값 이상
# 위의 두 조건을 만족하면서 unit이 2*2 이상으로 밀집되어있을 때
”’
”’
설정해야 하는 변수
# Threshold 값(TH)
# image trim의 x,y 값
# 이미지를 분할할 unit의 크기: 300*300 이미지 이므로 unit은 300의 약수
# wet_point_list 함수의 ref1, ref2
”’

def im_trim(img, x, y, w, h): # 분석 가능한 이미지로 ROI 설정

(a, b) = img.shape[:2] center = (b/3 , a/1.5)
angle90 = 90
scale = 1.0
M = cv2.getRotationMatrix2D(center, angle90, scale)
img = cv2.warpAffine(img, M, (a, b))
”’
x = 100; y = 100; #자르고 싶은 지점의 x좌표와 y좌표 지정
w = 200; h = 200; #x로부터 width, y로부터 height를 지정
”’
img_trim = img[y:y+h, x:x+w] #trim한 결과를 img_trim에 담는다

return img_trim

def grayscale(img): # 그레이스케일로 이미지 변환
return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

def Filter(img, value = 0): # 픽셀 값 평균을 기준으로 필터링
average = img.mean()

if value == 0:
ret,img_filter = cv2.threshold(img, average, 255, cv2.THRESH_BINARY)
else:
ret,img_filter = cv2.threshold(img, average*value, 255, cv2.THRESH_BINARY)
#ret,img_filter = cv2.threshold(img, value, 255, cv2.THRESH_BINARY)

return img_filter

def count_pixel(img): # 픽셀 값이 0인 픽셀 COUNT
number = cv2.countNonZero(img)

return number

def pixel_ratio0(img1, img2): # 픽셀 값 0 비율 계산
ratio = 1-abs((count_pixel(img2)-count_pixel(img1))/img1.size)
return ratio*100

def same_bright(frame, gap): # 두 이미지의 밝기를 동일하게 조절
if gap>=0:
M = np.ones(frame.shape, dtype = “uint8″) * abs(int(gap))
transform = cv2.add(frame, M)
else:
M = np.ones(frame.shape, dtype = “uint8″) * abs(int(gap))
transform = cv2.subtract(frame, M)

return transform

def seperated_image_ratio(frame1, frame2, unit): #unit의 수만큼 이미지를 분할하여 분할된 이미지의 pixel_ratio를 array에 저장
ratio_arr = np.zeros((unit,unit), dtype = int)
U = int(frame1.shape[0]/unit)
white = (255,255,255)
black = (0,0,0)

# 격자 그리기
for x in range(unit): cv2.line(frame2, (U*x, 0), (U*x, U*unit), black, 1, 4)
for y in range(unit): cv2.line(frame2, (0, U*y), (U*unit, U*y), black, 1, 4)

# ratio 행렬 생성
for i in range(unit):
for j in range(unit):
img_trim1 = frame1[i*U:(i+1)*U, j*U:(j+1)*U] img_trim2 = frame2[i*U:(i+1)*U, j*U:(j+1)*U] ratio = int(pixel_ratio0(img_trim1, img_trim2))
ratio_arr[i,j] = ratio

# unit의 좌표 값과 ratio값 이미지에 표시

text = ‘(‘+str(i)+’,'+str(j)+’)’
#cv2.putText(frame2, text, (j*U+int(U*0.2), i*U+int(U*0.4)), 1, 0.5, black)
cv2.putText(frame2, str(ratio), (j*U+int(U*0.3), i*U+int(U*0.8)), 1, 0.6, black)

return ratio_arr

def wetpoint_list(r_arr): # 1. 각각의 unit의 인접한 unit의 ratio값의 차가 일정 값을 넘으면 wet list에 좌표 값 저장
# 2. unit의 ratio값이 일정 값을 넘으면 wet list에 좌표 값 저장

wet = [] ref1 = 25 # 인접한 unit간 ratio차이의 기준값
ref2 = 50 # unit의 ratio 기준값
for i in range(len(r_arr[0])):
for j in range(len(r_arr[1])):

R = r_arr[i,j]

Rlst = [] if (1<=i<=len(r_arr[0])-2 and 1<=j<=len(r_arr[1])-2):
for m in range(3):
for n in range(3):
Rlst.append(r_arr[i-1+m,j-1+n])
for r in Rlst:
if r-R > ref1:
wet.append((i,j))
if wet != []:
if wet[-1] == (i,j):
break

if wet != []:
if wet[-1] != (i,j):
if np.mean(r_arr)-R > ref2 and R!=0:
wet.append((i,j))
return wet

def wet_list_filter(arr, wet): # wet리스트의 좌표값을 r_arr와 같은 크기의 2차원 array의 좌표에 1로 표시
# 2*2구역의 값이 모두 1이면 wet_lst에 좌표값 저장

wet_arr = np.zeros(arr.shape, dtype = int)
wet_lst = []

# wet 리스트의 좌표 값을 wet_arr에 1로 표시
for n in wet:
x = n[1] y = n[0] wet_arr[x,y] = 1

#2*2 구역의 값이 모두 1이면 wet_lst에 좌표값 저장
for i in range(len(arr[0])):
for j in range(len(arr[1])):
if i+1<len(arr[0])-1 and j+1<len(arr[1])-1:
if wet_arr[i,j]*wet_arr[i+1,j]*wet_arr[i,j+1]*wet_arr[i+1,j+1] == 1:
wet_lst.append((i,j))
wet_lst.append((i+1,j))
wet_lst.append((i,j+1))
wet_lst.append((i+1,j+1))

wet_lst = list(set(wet_lst))

return wet_lst

def boxing_wet(frame, lst, unit): # wet list의 젖은 픽셀 좌표를 box로 화면에 표시
U = int(frame.shape[0]/unit)
thick = 2
for n in lst:
x = n[0] y = n[1] cv2.line(frame, (U*x, U*y), (U*x, U*(y+1)), (0,0,255), thick, 4)
cv2.line(frame, (U*x, U*y), (U*(x+1), U*y), (0,0,255), thick, 4)
cv2.line(frame, (U*(x+1), U*y), (U*(x+1), U*(y+1)), (0,0,255), thick, 4)
cv2.line(frame, (U*x, U*(y+1)), (U*(x+1), U*(y+1)), (0,0,255), thick, 4)

def nothing(x):
pass #더미 함수 생성… 트랙 바 생성시 필요하므로

def recvall(sock, Count):
buf = b”
while Count:
newbuf = sock.recv(Count)
if not newbuf: return None
buf += newbuf
Count -= len(newbuf)
return buf

def SEND_WARN():
for i in range(3):
Message = ’3′
client_socket.send(Message.encode()) ##알람 경보 활성화
print(“send”)
length = recvall(client_socket,16)
stringData = recvall(client_socket, int(length))

def SEND_SAFE():
Message = ’4′
client_socket.send(Message.encode()) ##알람 경보 활성화
length = recvall(client_socket,16)
stringData = recvall(client_socket, int(length))
def get_img_channel(channel):
message = channel
client_socket.send(message.encode()) ## 1번 이미지 전송 요청
length = recvall(client_socket,16)
stringData = recvall(client_socket, int(length))
data = np.frombuffer(stringData, dtype=’uint8′)
img = cv2.imdecode(data,1)
return img

HOST = ’192.168.0.9′
PORT = 9999
client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))

cv2.namedWindow(‘Binary’) #트랙바를 붙일 윈도우를 생성
cv2.resizeWindow(‘Binary’, 400, 120)
cv2.createTrackbar(‘threshold’,'Binary’, 0, 150, nothing) #트랙바를 이름이’Binary’인 윈도우에 붙임’
cv2.setTrackbarPos(‘threshold’, ‘Binary’, 100) #초기값 100
cv2.createTrackbar(‘X’,'Binary’, 0, 100, nothing) #트랙바를 이름이’Binary’인 윈도우에 붙임’
cv2.setTrackbarPos(‘X’, ‘Binary’, 40) #초기값 40
cv2.createTrackbar(‘Y’,'Binary’, 150, 250, nothing) #트랙바를 이름이’Binary’인 윈도우에 붙임’
cv2.setTrackbarPos(‘Y’, ‘Binary’, 200) #초기값 200

count = 0
unit = 15 #pixel이 300*300 이므로 unit은 300의 약수여야함
f1 =”
f2 =”
while True:
if WARN_FLAG == True:
SEND_WARN()
WARN_FLAG = False
print(time.time())
f1 = get_img_channel(’1′) # 1번 이미지 전송 요청
f2 = get_img_channel(’2′) # 2번 이미지 전송 요청

TH = cv2.getTrackbarPos(‘threshold’,'Binary’)*0.01 # threshold 필터링 값ㅂ
x = cv2.getTrackbarPos(‘X’,'Binary’) # frame2의 x축 값 변경
y = cv2.getTrackbarPos(‘Y’,'Binary’) # frame2의 y축 값 변경

if True:
frame1_rgb = im_trim(f1, 72, 100, 300, 300)
frame2_rgb = im_trim(f2, x, y, 300, 300) # x 초기값 40, y 초기값 200

frame1 = grayscale(frame1_rgb)
frame2 = grayscale(frame2_rgb)

average1 = frame1.mean()
average2 = frame2.mean()
gap = average1 – average2

frame2_c = same_bright(frame2, gap)

average2_c = frame2_c.mean()

thresh1 = Filter(frame1, TH)
thresh2 = Filter(frame2_c, TH)

thresh3 = cv2.bitwise_xor(thresh1, thresh2) # t1, t2 이미지 겹치는 부분 0으로 변환
xor_ratio = count_pixel(thresh3) * 100/ thresh3.size

unit_arr = seperated_image_ratio(thresh1, thresh2, unit)
p_ratio = int(np.mean(unit_arr))

wet = wetpoint_list(unit_arr)
wet = wet_list_filter(unit_arr, wet)
boxing_wet(frame1_rgb, wet, unit)

if len(wet) > 3:
count += 1
else:
count = 0

sign = 0
if count > 10: ## 노면이 젖은 부분을 검출하는 부분
sign = 1

print(”,\
‘W.P ‘+str(len(wet)),\
‘R: ‘+ str(p_ratio),\
‘TH: ‘ + str(TH),\
‘GAP: ‘ + str(int(gap)),\
‘A1: ‘ + str(int(average1)),\
‘XOR: ‘ + str(int(xor_ratio)),\
‘COUNT: ‘ + str(count),\
‘WET ROAD DETECTED!!!’,\
”,\
sep = ‘ | ‘)
wet = [] WARN_FLAG = True

else:
SEND_SAFE()
print(”,\
‘W.P ‘+str(len(wet)),\
‘R: ‘+ str(p_ratio),\
‘TH: ‘ + str(TH),\
‘GAP: ‘ + str(int(gap)),\
‘A1: ‘ + str(int(average1)),\
‘XOR: ‘ + str(int(xor_ratio)),\
‘COUNT: ‘ + str(count),\
”,\
sep = ‘ | ‘)

cv2.imshow(“1″, thresh1)
cv2.imshow(“2″, thresh2)
cv2.imshow(’55′, f2)
#cv2.imshow(“3″, thresh3)
cv2.imshow(“ORIGIN1″, frame1_rgb)
#cv2.imshow(“ORIGIN2″, frame2_c)
if cv2.waitKey(1) & 0xFF == ord(‘q’):
break
# 사용자가 키보드 q 누르면 Opencv 종료

cv2.destroyAllWindows() # 리소스 반환
cv2.waitKey(0)
client_socket.close()

# -*- coding: utf-8 -*-
# 원격 동키카 제어 및 카메라 스트리밍 코드
# 동키카는 흑백 영상을 Streaming
”’
2020.02.12
동키카 PWM / STREAMING + 외부 연산장치 연산결과에 따른 GPIO 출력
노면 상태가 젖은 경우 라즈베리파이 GPIO 21 번이 HIGH 상태가 되었다가 특정 시간이 지난 뒤에 자동으로 LOW됨
”’
import cv2
import numpy
import time
import pygame
import socket
import time
import RPi.GPIO as GPIO
from _thread import *

#라즈베리파이 GPIO
import RPi.GPIO as GPIO
GPIO_SIGNAL = 21
GPIO.setmode(GPIO.BCM)
GPIO.setup(21, GPIO.OUT)
GPIO.output(GPIO_SIGNAL,False)
import Adafruit_PCA9685
pwm = Adafruit_PCA9685.PCA9685() #pwm = Adafruit_PCA9685.PCA9685(address=0×41, busnum=2)
pwm.set_pwm_freq(60) # 서보모터 60Hz로 펄스주기를 설정.

#### 동키카 PWM 펄스 조절 부분 #########
# 이 부분의 값을 적절히 조절해서 전진/후진/정지/좌/우 조절할 것#
PWM_GO_SLOW = 395
PWM_GO_FAST = 400
PWM_GO = PWM_GO_FAST

PWM_BACK = 370
PWM_STOP = 380

PWM_LEFT = 260
PWM_RIGHT = 500
PWM_CENTER = 380
#### 동키카 PWM 펄스 조절 부분 #########

# Settings for joystick
axisUpDown = 1 # Joystick axis to read for up / down position
axisUpDownInverted = False # Set this to True if up and down appear to be swapped
axisLeftRight = 3 # 라즈베리파이에서는 3 / 컴퓨터에서는 4로 지정하면 됨
axisLeftRightInverted = False # Set this to True if left and right appear to be swapped

pygame.init()
pygame.joystick.init()
joystick = pygame.joystick.Joystick(0)
joystick.init()

HOST = ”
PORT = 9999

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((HOST, PORT))
server_socket.listen()
print(‘server start’)
A =b’hello’
B =b’world’
global GO
global TILT
global CONT_DATA
GO = 0
TILT = 0
tt =1
last_ch_data =0
ALARM = False
init_time = time.time()

#PCA9685 관련 펄스 초기설정 함수
def set_servo_pulse(channel, pulse):
pulse_length = 1000000 # 1,000,000 us per second
pulse_length //= 60 # 60 Hz
print(‘{0}us per period’.format(pulse_length))
pulse_length //= 4096 # 12 bits of resolution
print(‘{0}us per bit’.format(pulse_length))
pulse *= 1000
pulse //= pulse_length
pwm.set_pwm(channel, 0, pulse)
pwm.set_pwm_freq(60)
# Function to handle pygame events
def PygameHandler(events):
#조이스틱 이벤트 발생한 경우
for event in events:
if event.type == pygame.JOYAXISMOTION:
upDown = joystick.get_axis(axisUpDown)
leftRight = joystick.get_axis(axisLeftRight)
global GO
global TILT
if upDown < -0.1:
#print(“GO”)
GO = 1
elif upDown > 0.1:
#print(“BACK”)
GO = -1
else:
GO = 0

if leftRight < -0.1:
#print(“LEFT”)
TILT = 1
elif leftRight > 0.1:
#print(“RIGHT”)
TILT = -1
else:
TILT = 0

return GO, TILT

# 그레이스케일로 이미지 변환
def grayscale(img):
return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

## time.sleep의 system 독점을 방지하기 위한 내용
def millis_python():
now_time = time.time()
now_time = (now_time – init_time)
return now_time

# 쓰레드 함수 ( 소켓 통신 개시 이후 무한 loop 문 처럼 작동하는 구문 )
def threaded(client_socket, addr):
global tt
print(‘Connected by :’, addr[0], ‘:’, addr[1])
stringData = b”
while True:
try:
data = client_socket.recv(1024)
if not data:
print(‘Disconnected by ‘ + addr[0],’:',addr[1])
pwm.set_pwm(0, 0, PWM_STOP)
break
ch_data = int(data)
if ch_data == 1:
stringData = A
#client_socket.send(str(len(A)).ljust(16).encode())
#client_socket.send(A)
last_ch_data =1
#stringData = queue1.get()
if ch_data == 2:
stringData = B
last_ch_data =2
#client_socket.send(str(len(B)).ljust(16).encode())
#client_socket.send(B)
#stringData = queue2.get()
if ch_data == 3: ### WARN SIGNAL
GPIO.output(GPIO_SIGNAL,False)
PWM_GO = PWM_GO_SLOW
print(“EEEE”)
tt = millis_python()
stringData =b’AA’

if ch_data == 4:
stringData =b’AA’
PWM_GO = PWM_GO_FAST

client_socket.send(str(len(stringData)).ljust(16).encode())
client_socket.send(stringData)
## 이 부분에 PWM 제어 신호 넣으면 됨
CONT_DATA = PygameHandler(pygame.event.get())
print(GO, TILT)
if GO == 1:
print(“FORWARD”)
pwm.set_pwm(0, 0, PWM_GO) #0번서보
elif GO == -1:
print(“BACKWARD”)
pwm.set_pwm(0, 0, PWM_BACK) #0번서보
else: # 이 부분에 전진모터 중립
pwm.set_pwm(0, 0, PWM_STOP) #0번서보

if TILT == 1:
print(“LEFT”)
pwm.set_pwm(3, 0, PWM_LEFT) #3번서보
elif TILT == -1:
print(“RIGHT”)
pwm.set_pwm(3, 0, PWM_RIGHT) #3번서보
else: # 이 부분에 조향서보모터 중립
pwm.set_pwm(3, 0, PWM_CENTER) #3번서보

## 특정 시간이 지나면 자동으로 알람을 해제하는 부분 ( 5초 이상 경과 시 OFF )
if (millis_python() – tt > 4):
PWM_GO = PWM_GO_FAST
GPIO.output(GPIO_SIGNAL,True)
ALARM = False

except ConnectionResetError as e:
print(‘Disconnected by ‘ + addr[0],’:',addr[1])
pwm.set_pwm(0, 0, PWM_STOP)
break
client_socket.close()
def webcam():
# capture1 = cv2.VideoCapture(0) # 카메라 채널 바꿔주면 됨
# capture2 = cv2.VideoCapture(2) # 카메라 채널 바꿔주면 됨
while True:
ret1, frame1 = capture1.read()
ret2, frame2 = capture2.read()
if ret1 == True:
encode_param=[int(cv2.IMWRITE_JPEG_QUALITY),50] frame1 = grayscale(frame1)
result, imgencode = cv2.imencode(‘.jpg’, frame1, encode_param)
data1 = numpy.array(imgencode)
stringData1 = data1.tostring()
global A
A = stringData1
cv2.imshow(‘CH1′, frame1)

if ret2 == True:
encode_param=[int(cv2.IMWRITE_JPEG_QUALITY),50] frame2 = grayscale(frame2)
result, imgencode = cv2.imencode(‘.jpg’, frame2, encode_param)
data2 = numpy.array(imgencode)
stringData2 = data2.tostring()
global B
B = stringData2
cv2.imshow(‘CH2′, frame2)
key = cv2.waitKey(1)
if key == 27:
break

GPIO.output(GPIO_SIGNAL,True)
capture1 = cv2.VideoCapture(0) # 카메라 채널 바꿔주면 됨
capture2 = cv2.VideoCapture(2) # 카메라 채널 바꿔주면 됨
start_new_thread(webcam, ())

while True:
print(‘wait’)
client_socket, addr = server_socket.accept()

#threaded(client_socket, addr)

start_new_thread(threaded, (client_socket, addr ))

server_socket.close()
GPIO.cleanup()

—————— main.py ——————-

#-*- coding: utf-8 -*-

from flask import Flask, render_template, Response, request, url_for
from flask_googlemaps import GoogleMaps
from flask_googlemaps import Map, icons
from flask import current_app as current_app
from flask_mail import Mail, Message
import dbModule
import os, datetime
import glob

app = Flask(__name__, template_folder=”templates”)

app.config['GOOGLEMAPS_KEY'] = “########”
GoogleMaps(app)
UPLOAD_FOLDER = ‘./uploads’
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

app.config['MAIL_SERVER'] = os.environ.get(‘MAIL_SERVER’, ‘smtp.gmail.com’)
app.config['MAIL_PORT'] = int(os.environ.get(‘MAIL_PORT’, ’587′))
app.config['MAIL_USERNAME'] = os.environ.get(‘MAIL_USERNAME’, ‘#######’)
app.config['MAIL_PASSWORD'] = os.environ.get(‘MAIL_PASSWORD’, ‘#######’)
app.config['MAIL_USE_TLS'] = int(os.environ.get(‘MAIL_USE_TLS’, True))
app.config['MAIL_USE_SSL'] = int(os.environ.get(‘MAIL_USE_SSL’, False))

mail = Mail(app)

db_class = dbModule.Database()
@app.route(‘/email’, methods=['POST'])
def email():
name = request.form['name'] email_address = request.form['email'] phone = request.form['phone'] message = request.form['message']

msg = Message(‘A new message from TWOEYES’, sender=email_address, recipients=['#######'])
msg.body = “You have received a new message from your website contact form.\nHere are the details:\n\nName: %s\n\nEmail: %s\n\nPhone: %s\n\nMessage: %s” % (name, email_address, phone, message)
mail.send(msg)

return ‘Sent’
@app.route(‘/data’, methods=['GET'])
def getData():
lat = request.args.get(‘req_lat’)
lng = request.args.get(‘req_lng’)
t1 = request.args.get(‘req_t1′)
t2 = request.args.get(‘req_t2′)
h = request.args.get(‘req_h’)
date = request.args.get(‘req_date’)
time = request.args.get(‘req_time’)

sql = “”"insert into data(lat, lng, t1, t2, h, date, time) values (%s, %s, %s, %s, %s, %s, %s)”"”
db_class.execute(sql, (lat, lng, t1, t2, h, date, time))
db_class.commit()

return ‘Data’
@app.route(‘/image’, methods=['POST'])
def postImage():
file = request.files['file'] if file:
#filename = secure_filename(file.filename)
filename = datetime.datetime.now().strftime(‘%y%m%d_%H%M%S’)+’.jpg’
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))

return ‘Image’
@app.route(‘/’)
def index():

sql = “select * from data order by date”
row = db_class.executeAll(sql)

db_class.execute(“select count(*) from data”)
cnt = db_class.cursor.fetchone()

cnt = cnt.get(‘count(*)’)

gps_list=[]

for i in range(0, cnt):
row_lat = float(row[i].get(‘lat’))
row_lng = float(row[i].get(‘lng’))

gps_list.append((row_lat, row_lng))
#print(gps_list)

sndmap = Map(
style=”height: 450px; width: 1150px;”,
identifier=”sndmap”,
varname=”sndmap”,
zoom=16, #13

lat=row[0].get(‘lat’),
lng=row[0].get(‘lng’),
markers=gps_list
)

list_of_files = glob.glob(‘./uploads/*’)
latest_file = max(list_of_files, key=os.path.getctime)

return render_template(‘index.html’, sndmap=sndmap, GOOGLEMAPS_KEY=request.args.get(‘apikey’), row=row, len=len(row), latest_file=latest_file)
if __name__ == ‘__main__’:
app.run(host=’0.0.0.0′, port=5000, debug=True)
—————— dbModule.py ——————-

import pymysql

class Database():
def __init__(self):
self.db= pymysql.connect(host=’18.213.156.121′,
user=’#####’,
password=’#######’,
db=’TWOEYES’,
charset=’utf8′)
self.cursor= self.db.cursor(pymysql.cursors.DictCursor)

def execute(self, query, args={}):
self.cursor.execute(query, args)

def executeOne(self, query, args={}):
self.cursor.execute(query, args)
row= self.cursor.fetchone()
return row

def executeAll(self, query, args={}):
self.cursor.execute(query, args)
row= self.cursor.fetchall()
return row

def commit(self):
self.db.commit()
—————— contact.js ——————-

$(function() {

$(“#contactForm input,#contactForm textarea”).jqBootstrapValidation({
preventSubmit: true,
submitError: function($form, event, errors) {
// additional error messages or events
},
submitSuccess: function($form, event) {
event.preventDefault(); // prevent default submit behaviour
// get values from form
var name = $(“input#name”).val();
var email = $(“input#email”).val();
var phone = $(“input#phone”).val();
var message = $(“textarea#message”).val();
var firstName = name;
// Check the space of name for success/fail message
if (firstName.indexOf(‘ ‘) >= 0) {
firstName = name.split(‘ ‘).slice(0, -1).join(‘ ‘);
}
$this = $(“#sendMessageButton”);
$this.prop(“disabled”, true);
$.ajax({
url: “http://18.213.156.121:5000/email”,
type: “POST”,
data: {
name: name,
phone: phone,
email: email,
message: message
},
cache: false,
success: function() {
// Success message
$(‘#success’).html(“<div class=’alert alert-success’>”);
$(‘#success > .alert-success’).html(“<button type=’button’ class=’close’ data-dismiss=’alert’ aria-hidden=’true’>&times;”)
.append(“</button>”);
$(‘#success > .alert-success’)
.append(“<strong>Your message has been sent. </strong>”);
$(‘#success > .alert-success’)
.append(‘</div>’);
//clear all fields
$(‘#contactForm’).trigger(“reset”);
},
error: function() {
// Fail message
$(‘#success’).html(“<div class=’alert alert-danger’>”);
$(‘#success > .alert-danger’).html(“<button type=’button’ class=’close’ data-dismiss=’alert’ aria-hidden=’true’>&times;”)
.append(“</button>”);
$(‘#success > .alert-danger’).append($(“<strong>”).text(“Sorry ” + firstName + “, it seems that my mail server is not responding. Please try again later!”));
$(‘#success > .alert-danger’).append(‘</div>’);
//clear all fields
$(‘#contactForm’).trigger(“reset”);
},
complete: function() {
setTimeout(function() {
$this.prop(“disabled”, false);
}, 1000);
}
});
},
filter: function() {
return $(this).is(“:visible”);
},
});

$(“a[data-toggle=\"tab\"]“).click(function(e) {
e.preventDefault();
$(this).tab(“show”);
});
});

// When clicking on full hide fail/success boxes
$(‘#name’).focus(function() {
$(‘#success’).html(”);
});