กล้อง JPEG ARDUINO ที่ใช้กับ IR และ PIR
ลองใช้ Arduino กับกล้อง JPEG แบบอินเทอร์เฟซแบบอนุกรมและลองใช้แอพพลิเคชันสองตัว: กล้องบันทึกภาพแรก (บนการ์ด SD) ในช่วงปกติในขณะที่กล้องสองใช้เซ็นเซอร์ PIR เพื่อตรวจจับการบุกรุกและถ่ายภาพสิ่งที่เกิดขึ้น
เมื่อเร็ว ๆ นี้กล้องขนาดเล็กที่มีอินเทอร์เฟซการสื่อสารแบบอนุกรมได้เปิดตัวในตลาดแล้ว เมื่อเทียบกับกล้องแบบดั้งเดิมจะช่วยให้สามารถเชื่อมต่อกับ Arduino หรือบอร์ดไมโครคอนโทรลเลอร์อื่น ๆ ได้ง่ายขึ้น
ง่ายมากที่จะเข้าใจว่าการใช้คอมโพสิตหรือ USB interface camera ต้องใช้ความพยายามเป็นอย่างมากทั้งด้านฮาร์ดแวร์และซอฟต์แวร์ หากคุณตัดสินใจที่จะเดิมพันกับกล้องอินเทอร์เฟซแบบอนุกรมทุกสิ่งทุกอย่างจะง่ายขึ้นเนื่องจากบอร์ดต้นแบบ (Arduino โดยเฉพาะ) และไมโครคอนโทรลเลอร์ (Microchip, Atmel ฯลฯ ) มีพอร์ตอนุกรมอย่างน้อยหนึ่งพอร์ตเป็นคุณลักษณะมาตรฐาน
แนวคิดพื้นฐานของกล้องเหล่านี้คือคุณสามารถส่งคำสั่งการตั้งค่าทั้งหมด, ถ่ายภาพหน้าจอและดูภาพผ่านลำดับไบต์ที่เหมาะสมผ่านทางพอร์ตอนุกรมของพวกเขา
ในกรณีของเราเราจะใช้กล้อง LinkSprite ที่เชื่อมต่อกับ Arduino Uno คุณสมบัติพิเศษของกล้องนี้คือความสามารถในการจับภาพแม้ในเวลากลางคืน; ในความเป็นจริงก็มีเซ็นเซอร์ความสว่างและไฟ LED อินฟราเรดเปิดใช้งานโดยอัตโนมัติเมื่อแสงที่ตรวจพบต่ำกว่าเกณฑ์ที่กำหนด (ดูภาพในหน้าเว็บเหล่านี้เพื่อให้ทราบว่าไฟ LED อินฟราเรดทำงานอย่างไร)
กล้องสามารถจับภาพความละเอียดสูงส่งเป็น JPEG ผ่านทางพอร์ตอนุกรม มีขั้วต่อสี่ขาที่หมุดสองขาสำหรับแหล่งจ่ายไฟ (5 V และ GND) และอีกสองพอร์ตสำหรับพอร์ตอนุกรม (RX และ TX)
บทความนี้จะแสดงวิธีการใช้กล้องนี้ในสองโครงการที่แตกต่างกันของ Arduino: ระบบแรกสร้างระบบจับเวลาเพื่อถ่ายภาพในช่วงเวลาหนึ่ง ๆ จัดเก็บไว้ใน SD-card ในขณะที่ระบบเตือนภัยอัตโนมัติแบบที่ 2 ใช้งานได้เฉพาะเมื่อ PIR พิเศษ (เรดาร์อินฟาเรดแบบพาสซีฟ) ตรวจจับวัตถุอุ่น ๆ ที่เคลื่อนที่ในฟิลด์มุมมองกล้อง ในทางปฏิบัติแอ็พพลิเคชันที่สองนี้เป็นอุปกรณ์เฝ้าระวังวิดีโอแบบไทม์ที่บันทึกสิ่งที่เกิดขึ้นในห้องที่เปิดใช้งานโดยการตรวจจับบุคคลที่เคลื่อนย้ายหรือยานพาหนะ แน่นอนพื้นที่ตรวจจับ PIR ต้องตรงกับมุมกล้องเดียวกันเพื่อให้ภาพที่ถ่ายได้แสดงให้เห็นถึง "ศัตรู" อย่างมีประสิทธิภาพ
ภาพจะถูกจัดเก็บไว้ในการ์ด SD ในไฟล์รูปแบบ JPEG ดังนั้นเราจำเป็นต้องมีโล่การ์ด Sd (มีให้เลือกใช้งานบน Futura Elettronica)
สุดท้ายเราจะใช้ไลบรารีซอฟต์แวร์(JPEGCamera) ที่พัฒนาโดยเราโดยเฉพาะสำหรับตัวอย่างการใช้กล้องเหล่านี้
ฮาร์ดแวร์ระบบ
เกี่ยวกับแอพพลิเคชันตัวแรกฮาร์ดแวร์ประกอบด้วย Arduino Uno Rev 3 และโล่การ์ด SD ที่ใช้ในการบันทึกภาพทั้งหมดที่เชื่อมต่อกับกล้องถ่ายรูปแบบอนุกรม โล่ SD มีจัมเปอร์สี่ตัวช่วยให้เราสามารถเลือกขา Arduino ที่เป็น "chip select" (คุณสามารถเลือกระหว่าง D4, D8, D9 และ D10); สำหรับ "chip select" เราหมายถึงบรรทัดคำสั่งที่ช่วยให้โล่
ในตัวอย่างของเราเราใช้ D4 ดังนั้นเราจึงต้องใส่จัมเปอร์ที่เกี่ยวข้อง
กล้องมีขั้วต่อสี่ขาที่ใช้สำหรับสายไฟและอินเทอร์เฟซแบบอนุกรมและมีสายไฟสี่สาย (สี: สีแดงสีน้ำตาลสีม่วงและสีเทา) ที่ลงท้ายด้วยจัมเปอร์หญิง โปรดทราบว่าสำหรับการสื่อสารแบบอนุกรมระหว่าง Arduino กับกล้องเราตัดสินใจที่จะไม่ใช้พอร์ตอนุกรมฮาร์ดแวร์ แต่เราใช้ซอฟต์แวร์ชุดหนึ่ง (ที่จับคู่ไว้บนหมุด Arduino D2 และ D3) ด้วยวิธีนี้ไลบรารีซอฟต์แวร์ช่วยให้พอร์ตฮาร์ดแวร์ฟรีสำหรับแก้จุดบกพร่อง
ในการเชื่อมต่อ Arduino เข้ากับกล้องคุณจำเป็นต้องต่อสายสีแดง (RXD) กับขา Arduino D3; สีน้ำตาล (TXD) ถึง D2; สีเทาเป็นสัญญาณ + 5V และสุดท้ายสีม่วงกับพื้น (GND)
สำหรับแอพพลิเคชันที่สองเราต้องเพิ่มเซ็นเซอร์ PIR เข้ากับฮาร์ดแวร์ที่อธิบายไว้ สิ่งที่เราใช้สำหรับต้นแบบของเราคืออุปกรณ์ที่มี "สติปัญญา" บนกระดานซึ่งจะใช้โหมดทริกเกอร์สองแบบที่แตกต่างออกไปซึ่งจะให้เวลาในการเลื่อนโปรแกรม (ระหว่างการตรวจจับการเคลื่อนไหวและการเรียกใช้สัญญาณ) ตั้งแต่ 0.3 ถึง 180 วินาทีมี มุมตรวจจับ 120 °และช่วงสูงสุด 7 เมตร เซ็นเซอร์มีขาสามขา (TTL 0V - เอาต์พุต 3.3V และขั้วลบ) ในการเชื่อมต่อกับ Arduino คุณต้องสร้างสายเคเบิลสามสายที่ต้องต่อสายไฟเข้ากับขั้วบวกและขั้วลบให้ต่อกับ Arduino + 5V และ GND ขณะที่เอาต์พุต TTL ไปที่ขา Arduino D5 อุปกรณ์จะส่งสัญญาณทริกเกอร์ที่เกิดจากการตรวจจับการเคลื่อนไหวของเซ็นเซอร์ PIR
ARDUINO LIBRARY
JPEGCamera
เพื่อให้ Arduino จัดการกล้อง JPEG เราได้พัฒนาไลบรารี ( JPEGCamera ) ที่มีฟังก์ชั่นกล้อง LinkSprite ทั้งหมด: การเริ่มต้น, จับภาพหน้าจอและบันทึกภาพ
ไลบรารีมีวัตถุที่เรียกว่า JPEGCamera ซึ่ง คุณสามารถเรียกใช้การจัดการฮาร์ดแวร์แบบสมบูรณ์ได้
เริ่มต้น ฟังก์ชั่นเริ่มต้นระบบการจัดการกล้องทั้งการ รีเซ็ต ร่างกายรีเซ็ตกล้องเป็น setImageSize กำหนดขนาดภาพที่จับ (คุณสามารถเลือกระหว่าง 160 x 120, 320 x 280 และ 640 x 480 พิกเซล) แล้วมีtakePictureฟังก์ชั่น , คำสั่งที่กล้องสามารถจับภาพขณะกรอบ (พื้นเป็นฟังก์ชั่นใช้หน้าจอ) และ readJpegFileSize, ซึ่งอ่านขนาด (ไบต์) ของไฟล์ภาพที่เก็บไว้ ฟังก์ชั่นอื่น ๆ ได้แก่ readJpegFileContent ซึ่งเกี่ยวข้องกับการอ่าน (packet ครั้ง) ข้อมูลภาพและ หยุดการจับภาพStopTakingPicturesซึ่งจะหยุดจับภาพหน้าจอ
readJpegFileContent ฟังก์ชั่นสมควรได้รับการกล่าวถึงเป็นพิเศษ: ขั้นตอนการอ่านข้อมูลทำงานร่วมกับแพ็คเก็ต (64 ไบต์ในกรณีของเรา) ได้ตลอดเวลาในการทำเช่นนี้จำเป็นต้องใช้เวลาในการเรียกขั้นตอนเพื่อระบุที่อยู่เริ่มต้น (ครั้งแรกเท่ากับ 0, 64 วินาที, ที่สามที่ 128 เป็นต้นไป) และขนาดแพ็คเก็จที่จะอ่าน (ในกรณีของเรา เสมอ 64 โปรดทราบว่าไม่สามารถเกินค่านั้นได้) ฟังก์ชั่นต้องใช้เมื่อป้อนอาร์เรย์ไบต์ที่จะบันทึกข้อมูล ยังส่งกลับพารามิเตอร์เอาต์พุตของiSendซึ่งระบุว่าการดำเนินการอ่านเสร็จสิ้นแล้ว
ตัวอย่างการฝึกอบรม 1
เริ่มต้นจากจุดเริ่มต้นที่เราจะวิเคราะห์แรกโค้ดตัวอย่างกล้อง JPEG, แอพลิเคชันภาพประหยัดอย่างต่อเนื่อง(รายการที่ 1)
เรามีไลบรารีที่จำเป็น ( JPEGCamera.h,SoftwareSerial.h - เนื่องจากเราจะใช้อินเตอร์เฟซแบบอนุกรมซอฟต์แวร์และ SD.h เพื่อบันทึกรูปภาพในการ์ด SD) และกำหนดขนาด (เป็นไบต์) ของแพ็คเก็ตข้อมูลเดียว เก็บไว้(chunk_size; 64 bytes)
จากนั้นเราจะกำหนดขา Arduino (D4) ซึ่งเราจะใช้เป็น SD-card chip select และตัวแปรบางตัวที่เราจะใช้ในโปรแกรม (โดยเฉพาะ jpegCamera ใช้สำหรับการจัดการกล้อง) ภายในฟังก์ชั่นการตั้งค่าที่เราเริ่มต้นบอร์ดและเราเรียก คำสั่งเริ่มต้นกล้อง; หลังจากที่เราเริ่มต้น ไลบรารีSDระบุว่าเราต้องการใช้ขา D4 เป็นตัวเลือกชิป
ในฟังก์ชันลูปเราจัดการการจับภาพและบันทึกภาพได้อย่างแท้จริง แรกเราตั้งค่าให้จับภาพขนาด 320 x 280 พิกเซลและผ่าน jpegCamera.takePicture เราจะเริ่มจับภาพหน้าจอเดียว
หลังจากนั้นเราสามารถกำหนดชื่อไฟล์ "save as" (เช่น imageXX.jpg ที่ XX ช่วงตั้งแต่ 00 ถึง 99) และผ่าน SD.open เราสามารถสร้างและเปิดไฟล์ในรูปแบบการเขียนบนการ์ด SD จากนั้นผ่าน ลูปในขณะที่เราจัดการกระบวนการอ่านและบันทึกภาพ ด้วย jpegCamera.readJpegFileContent เราอ่านไฟล์ข้อมูล jpeg หนึ่งไฟล์พร้อมกันและเราสามารถบันทึกข้อมูลได้โดยใช้ฟังก์ชันFile object write
เมื่อ ห่วงในขณะที่สิ้นสุดลงทุกไบต์ภาพได้รับการอ่านและบันทึก; แล้วเรารันไฟล์ วัตถุใกล้ ฟังก์ชั่นที่จะปิดตัวจัดการไฟล์และ jpegCamera.stopTakingPictures จะบอกกล้องที่จะหยุดการจับภาพ
ก่อนที่จะสิ้นสุดลูปให้รอสักครู่หนึ่งและเพิ่มตัวแปรที่นับจำนวนภาพที่ถ่าย
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
73
74
75
76
77
78
79
80
81
82
83
84
85
|
/*********************************************************************
* Inclusione librerie *
*********************************************************************/
#include <JPEGCamera.h>
#include “SoftwareSerial.h”
#include <SD.h>
// Chunk size per salvataggio immagine
#define CHUNK_SIZE 64
/*********************************************************************
* Definizione pin I/O Arduino *
*********************************************************************/
// Led scheda Arduino
const int pinBoardLed = 13;
// Pin Arduino Chip Select SD
const int pinSDChipSelect = 4;
/*********************************************************************
* Variabili programma *
*********************************************************************/
// Oggetto JPEG Camera
JPEGCamera jpegCamera;
// JPEG file
File jpegFile;
// Contatore immagine
byte i = 0;
/*********************************************************************
* Codice programma *
*********************************************************************/
// Inizializzazione Scheda
void setup() {
// Inizializzo I/O
pinMode(pinBoardLed, OUTPUT);
pinMode(pinSDChipSelect, OUTPUT);
// Accendo led Arduino
digitalWrite(pinBoardLed, HIGH);
// Inizializzo JPEG Camera
jpegCamera.begin();
// Init SD
pinMode(10, OUTPUT);
if (!SD.begin(pinSDChipSelect)) {
// Lampeggio led Arduino
for (;;) {
digitalWrite(pinBoardLed, HIGH);
delay(500);
digitalWrite(pinBoardLed, LOW);
delay(500);
}
}
// Spengo led Arduino
digitalWrite(pinBoardLed, LOW);
} // Chiusura funzione setup
// Programma Principale
void loop() {
boolean isEnd = false;
uint16_t address = 0x0000;
uint16_t chunkSize = CHUNK_SIZE;
byte body[CHUNK_SIZE];
// Imposto dimensione immagine
jpegCamera.setImageSize(jpegCamera.ImageSize320x280);
// Reset JPEG Camera
jpegCamera.reset();
// Scatto immagine
jpegCamera.takePicture();
// Identifico nome file
char fileName[12] = “image00.jpg”;
fileName[5] = ((i / 10) + 0x30);
fileName[6] = ((i % 10) + 0x30);
// Apro file
jpegFile = SD.open(fileName, FILE_WRITE);
// Leggo/salvo i dati immagine
isEnd = false;
while(isEnd == false) {
jpegCamera.readJpegFileContent(address, chunkSize, body, &isEnd);
address += chunkSize;
// Salvo i dati sul file
jpegFile.write(body, chunkSize);
}
// Chiudo file
jpegFile.close();
// Fermo immagine
jpegCamera.stopTakingPictures();
// Attesa
delay(1000);
// Prossimo file
i = ((i + 1) % 100);
} // Chiusura funzione loop
|
ตัวอย่างการพิมพ์ 2
ตัวอย่างที่สองนอกเหนือจากการใช้ฟังก์ชั่นที่ได้อธิบายไว้ในตัวอย่างก่อนหน้านี้จะใช้เซ็นเซอร์ PIR ด้วยเช่นกันดังนั้นจึงสามารถใช้เป็นเครื่องป้องกันการบุกรุกระบบต้นแบบได้
อัลกอริธึมทำงานดังนี้: Arduino จะเก็บภาพ (สูงสุด 5 - image01.jpg, ... , image05.jpg - เขียนทับที่เก่าแก่ที่สุดเป็นวัฏจักร) ในโฟลเดอร์ SD การ์ด (DIR000, .... , .DIR999); เมื่อตรวจพบสภาวะการเตือนภัยขั้นตอนการประหยัดวัฏจักรจะดำเนินต่อไป แต่เปลี่ยนชื่อไฟล์เป็น image06.jpg, ... ., image10.jpg และเพิ่มจำนวนชื่อโฟลเดอร์ จากนั้นทุกสิ่งทุกอย่างก็เป็นเช่นเดิม
บรรทัดแรกของซอฟต์แวร์นี้เหมือนกับภาพร่างก่อนหน้า (การรวมไลบรารีกระบวนการบันทึกคำนิยามของ Arduino pins และการประกาศตัวแปร)
การตั้งค่า ฟังก์ชั่นจะคล้ายกับที่ ในรายการ 1, การแก้ไขเพื่อระบุไดเรกทอรีฟรีครั้งแรก (หมายเลขโฟลเดอร์นั้นถูกระบุโดยdirCount ตัวแปร) แม้รอบวงกลม ค่อนข้างคล้ายกับตัวอย่างก่อนหน้านี้; ส่วนต่างๆจำเป็นต้องใช้ในการจัดการโฟลเดอร์และการตั้งชื่อไฟล์ระหว่างการตรวจจับการบุกรุก
นอกจากนี้ยังมีการเพิ่มคำสั่งฟังก์ชันสุดท้ายตรวจสอบว่ามีสัญญาณเตือนภัยที่มาจากเซ็นเซอร์ PIR หรือไม่ถ้าใช่กลไกการบันทึกไฟล์ที่ได้อธิบายไว้ข้างต้นจะถูกดำเนินการ
ร่างของโปรแกรมอยู่ใน รายการ 2
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/******************************************************************************
* Inclusione librerie *
******************************************************************************/
#include <JPEGCamera.h>
#include “SoftwareSerial.h”
#include <SD.h>
// Chunk size per salvataggio immagine
#define CHUNK_SIZE 64
/******************************************************************************
* Definizione pin I/O Arduino *
******************************************************************************/
// Led scheda Arduino
const int pinBoardLed = 13;
// Pin Arduino Chip Select SD
const int pinSDChipSelect = 4;
// Sensore PIR scheda Arduino
const int pinPIRSensor = 5;
/******************************************************************************
* Variabili programma *
******************************************************************************/
// Oggetto JPEG Camera
JPEGCamera jpegCamera;
// JPEG file
File jpegFile;
// Contatore directory
int dirCount = 0;
// Contatore immagine
byte fileCount = 1;
boolean flagSensorePIR = false;
/******************************************************************************
* Codice programma *
******************************************************************************/
// Inizializzazione Scheda
void setup() {
// Inizializzo I/O
pinMode(pinBoardLed, OUTPUT);
pinMode(pinSDChipSelect, OUTPUT);
pinMode(pinPIRSensor, INPUT);
// Accendo led Arduino
digitalWrite(pinBoardLed, HIGH);
// Inizializzo JPEG Camera
jpegCamera.begin();
// Init SD
pinMode(10, OUTPUT);
if (!SD.begin(pinSDChipSelect)) {
// Lampeggio led Arduino
for (;;) {
digitalWrite(pinBoardLed, HIGH);
delay(500);
digitalWrite(pinBoardLed, LOW);
delay(500);
}
}
// Identifico prima directory libera
for (;;) {
char dirName[7] = “DIR000”;
dirName[3] = ((dirCount / 100) + 0x30);
dirName[4] = (((dirCount % 100) / 10) + 0x30);
dirName[5] = ((dirCount % 10) + 0x30);
// Se directory non esiste
if (SD.exists(dirName) == false)
break;
// Prossima directory
dirCount++;
}
// Spengo led Arduino
digitalWrite(pinBoardLed, LOW);
} // Chiusura funzione setup
// Programma Principale
void loop() {
boolean isEnd = false;
uint16_t address = 0x0000;
uint16_t chunkSize = CHUNK_SIZE;
byte body[CHUNK_SIZE];
// Imposto dimensione immagine
jpegCamera.setImageSize(jpegCamera.ImageSize320x280);
// Reset JPEG Camera
jpegCamera.reset();
// Scatto immagine
jpegCamera.takePicture();
// Identifico prima directory libera
char dirName[7] = “DIR000”;
dirName[3] = ((dirCount / 100) + 0x30);
dirName[4] = (((dirCount % 100) / 10) + 0x30);
dirName[5] = ((dirCount % 10) + 0x30);
// Se directory non esiste
if (SD.exists(dirName) == false)
// Creo directory
SD.mkdir(dirName);
// Identifico nome file
char pathComplete[22] = “DIR000/image00.jpg”;
pathComplete[3] = ((dirCount / 100) + 0x30);
pathComplete[4] = (((dirCount % 100) / 10) + 0x30);
pathComplete[5] = ((dirCount % 10) + 0x30);
pathComplete[12] = ((fileCount / 10) + 0x30);
pathComplete[13] = ((fileCount % 10) + 0x30);
// Apro file
jpegFile = SD.open(pathComplete, FILE_WRITE);
// Leggo/salvo i dati immagine
isEnd = false;
while(isEnd == false) {
jpegCamera.readJpegFileContent(address, chunkSize, body, &isEnd);
address += chunkSize;
// Salvo i dati sul file
jpegFile.write(body, chunkSize);
// Se sensore PIR non rilevato
if (flagSensorePIR == false) {
// Se sensore PIR attivo
if (digitalRead(pinPIRSensor) == HIGH) {
// Prossimo file è il 6 (verrà incrementato in seguito)
fileCount = 5;
flagSensorePIR = true;
}
}
}
// Chiudo file
jpegFile.close();
// Fermo immagine
jpegCamera.stopTakingPictures();
// Attesa
delay(100);
// Se sensore PIR non rilevato
if (flagSensorePIR == false) {
// Se sensore PIR attivo
if (digitalRead(pinPIRSensor) == HIGH) {
// Prossimo file è il 6
fileCount = 6;
flagSensorePIR = true;
}
// Se sensore PIR non attivo
else {
// Prossimo file number
if (fileCount == 5)
fileCount = 1;
else
fileCount++;
}
}
// Se sensore PIR rilevato
else {
// Se salvati 5 file
if (fileCount == 10) {
// Resetto file
fileCount = 1;
// Prossima directory
dirCount++;
// Indico reset PIR
flagSensorePIR = false;
}
else
fileCount++;
}
} // Chiusura funzione loop
|
จากร้านค้า
http://www.open-electronics.org/wp-content/uploads/2015/11/JPEG.zip
จากโมดูล arduino sd card ไปยังโทรศัพท์ Android โดยใช้
โมดูลaruio uno และบลูทู ธ HC-05
เป็นไปได้กับฮาร์ดแวร์นี้?
ขอบคุณ