wed server+串口摄像头，有人感兴趣吗？

daiqx2

通过浏览器远程拍照和看照片，稍为改动就是远程报警器…

黑马

淘宝有个四百块的wifi摄像头，带若干控制接口，不过成像似乎不怎么样，价格也偏高

daiqx2

串口摄像头控制类库和wed server类库网上下载的，与sd操作读写文件，可以通过浏览器打开远程文件，不是一般只支持html输出的。人多有兴趣就的话就大家交流一下

Randy

兴趣是有，但是不太懂这一块，占位看你们交流！

daiqx2

几十块的串口摄像头就行，好像叫vc0776忘记了，回去就传代码。uno的ram不够用，mega才可以顺畅跑起来，大家要有心理准备。

沧海笑1122

感兴趣，串口摄像头（好像也叫jpg相机）近百元吧，2560控制，就地存在SD上，通过webserver调用，是这个意思吧？需要w5100吗？等着学习。

arduino-tinker

非常感兴趣！正想为我的小车配一个摄像头！

daiqx2

是用w5100+sd那种官方模块。串口摄像头30
万像素的淘宝大神是六七十块，二百万象素的一百多的

daiqx2

本来就想做个远程报警拍照的东西，然后做一个安卓客户端去轮询状态，然后调出现场照片。不过实验了硬件大部分功能可以实现后就没有搞下去，没意思了感觉上

daiqx2

在这里抛砖引玉。用stm32读模拟摄像头然后再wed服务器才是实现这个最好选择。低成本，好效果，高速度。

飞翔的红猪

楼主的代码和方案该抛出来了

daiqx2

因为最近才发现这里有一个arduino的好地方，这几天一直在外地，今晚或明天回家把它翻出来。只要有一个人感兴趣就会放出来的。

Randy

daiqx2 发表于 2012-6-12 16:59
因为最近才发现这里有一个arduino的好地方，这几天一直在外地，今晚或明天回家把它翻出来。只要有一个人感兴 ...

你现在才发现这里是好地方啊，这里可是国内最好的Arduino论坛哦！期待您的代码。

故意

{:soso_e113:}来这里的目的就是为了这个

daiqx2

1. // -*- c++ -*-
   
2. //
   
3. // Copyright 2010 Ovidiu Predescu <[email protected]>
   
4. // Date: December 2010
   
5. // Updated: 08-JAN-2012 for Arduno IDE 1.0 by <[email protected]>
   
6. //
   
7. 
   
8. #include <pins_arduino.h>
   
9. #include <SPI.h>
   
10. #include <Ethernet.h>
    
11. #include <Flash.h>
    
12. #include <SD.h>
    
13. #include <TinyWebServer.h>
    
14. #include <Adafruit_VC0706.h>
    
15. #include <SoftwareSerial.h>
    
16. /****************VALUES YOU CHANGE*************/
    
17. // The LED attached to PIN X on an Arduino board.
    
18. const int LEDPIN = 7;
    
19. 
    
20. // pin 4 is the SPI select pin for the SDcard
    
21. const int SD_CS = 4;
    
22. 
    
23. // pin 10 is the SPI select pin for the Ethernet
    
24. const int ETHER_CS = 10;
    
25. 
    
26. // Don't forget to modify the IP to an available one on your home network
    
27. byte ip[] = { 192, 168, 1, 177 };
    
28. /*********************************************/
    
29. 
    
30. static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
    
31. 
    
32. // The initial state of the LED
    
33. int ledState = LOW;
    
34. SoftwareSerial cameraconnection = SoftwareSerial(2, 3);
    
35. 
    
36. Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);
    
37. boolean has_cam=false;
    
38. void setLedEnabled(boolean state) {
    
39.   ledState = state;
    
40.   digitalWrite(LEDPIN, ledState);
    
41. }
    
42. 
    
43. inline boolean getLedState() { return ledState; }
    
44. 
    
45. boolean file_handler(TinyWebServer& web_server);
    
46. boolean blink_led_handler(TinyWebServer& web_server);
    
47. boolean led_status_handler(TinyWebServer& web_server);
    
48. boolean index_handler(TinyWebServer& web_server);
    
49. 
    
50. TinyWebServer::PathHandler handlers[] = {
    
51.   // Work around Arduino's IDE preprocessor bug in handling /* inside
    
52.   // strings.
    
53.   //
    
54.   // `put_handler' is defined in TinyWebServer
    
55.   {"/", TinyWebServer::GET, &index_handler },
    
56.   {"/upload/" "*", TinyWebServer::PUT, &TinyWebPutHandler::put_handler },
    
57.   {"/blinkled", TinyWebServer::POST, &blink_led_handler },
    
58.   {"/ledstatus" "*", TinyWebServer::GET, &led_status_handler },
    
59.   {"/" "*", TinyWebServer::GET, &file_handler },
    
60.   {NULL},
    
61. };
    
62. 
    
63. const char* headers[] = {
    
64.   "Content-Length",
    
65.   NULL
    
66. };
    
67. 
    
68. TinyWebServer web = TinyWebServer(handlers, headers);
    
69. 
    
70. boolean has_filesystem = true;
    
71. Sd2Card card;
    
72. SdVolume volume;
    
73. SdFile root;
    
74. SdFile file;
    
75. SdFile imgFile;
    
76. uint16_t jpglen;
    
77. int32_t time;
    
78. byte wCount;
    
79. boolean WriteFileing=false;
    
80. char Filenamenow[13];
    
81. void send_file_name(TinyWebServer& web_server, const char* filename) {
    
82.   if (!filename) {
    
83.     web_server.send_error_code(404);
    
84.     web_server << F("Could not parse URL");
    
85.   } else {
    
86.     TinyWebServer::MimeType mime_type
    
87.       = TinyWebServer::get_mime_type_from_filename(filename);
    
88.     web_server.send_error_code(200);
    
89.     web_server.send_content_type(mime_type);
    
90.     web_server.end_headers();
    
91.     if (file.open(&root, filename, O_READ)) {
    
92.       Serial << F("Read file "); Serial.println(filename);
    
93.       web_server.send_file(file);
    
94.       file.close();
    
95.     } else {
    
96.       web_server << F("Could not find file: ") << filename << "\n";
    
97.     }
    
98.   }
    
99. }
    
100. 
     
101. boolean file_handler(TinyWebServer& web_server) {
     
102.   char* filename = TinyWebServer::get_file_from_path(web_server.get_path());
     
103.   send_file_name(web_server, filename);
     
104.   free(filename);
     
105.   return true;
     
106. }
     
107. 
     
108. boolean blink_led_handler(TinyWebServer& web_server) {
     
109.   web_server.send_error_code(200);
     
110.   web_server.send_content_type("text/plain");
     
111.   web_server.end_headers();
     
112.   // Reverse the state of the LED.
     
113.   setLedEnabled(!getLedState());
     
114.   Client& client = web_server.get_client();
     
115.   if (client.available()) {
     
116.     char ch = (char)client.read();
     
117.     if (ch == '0') {
     
118.       setLedEnabled(false);
     
119.     } else if (ch == '1') {
     
120.       setLedEnabled(true);
     
121.       PicSave();
     
122.     }
     
123.   }
     
124.   return true;
     
125. }
     
126. 
     
127. boolean led_status_handler(TinyWebServer& web_server) {
     
128.   web_server.send_error_code(200);
     
129.   web_server.send_content_type("text/plain");
     
130.   web_server.end_headers();
     
131.   Client& client = web_server.get_client();
     
132.   client.println(getLedState(), DEC);
     
133.   return true;
     
134. }
     
135. 
     
136. boolean index_handler(TinyWebServer& web_server) {
     
137.   send_file_name(web_server, "INDEX.HTM");
     
138.   return true;
     
139. }
     
140. 
     
141. void file_uploader_handler(TinyWebServer& web_server,
     
142.                            TinyWebPutHandler::PutAction action,
     
143.                            char* buffer, int size) {
     
144.   static uint32_t start_time;
     
145.   static uint32_t total_size;
     
146. 
     
147.   switch (action) {
     
148.   case TinyWebPutHandler::START:
     
149.     start_time = millis();
     
150.     total_size = 0;
     
151.     if (!file.isOpen()) {
     
152.       // File is not opened, create it. First obtain the desired name
     
153.       // from the request path.
     
154.       char* fname = web_server.get_file_from_path(web_server.get_path());
     
155.       if (fname) {
     
156.         Serial << F("Creating ") << fname << "\n";
     
157.         file.open(&root, fname, O_CREAT | O_WRITE | O_TRUNC);
     
158.         free(fname);
     
159.       }
     
160.     }
     
161.     break;
     
162. 
     
163.   case TinyWebPutHandler::WRITE:
     
164.     if (file.isOpen()) {
     
165.       file.write(buffer, size);
     
166.       total_size += size;
     
167.     }
     
168.     break;
     
169. 
     
170.   case TinyWebPutHandler::END:
     
171.     file.sync();
     
172.     Serial << F("Wrote ") << file.fileSize() << F(" bytes in ")
     
173.            << millis() - start_time << F(" millis (received ")
     
174.            << total_size << F(" bytes)\n");
     
175.     file.close();
     
176.   }
     
177. }
     
178. 
     
179. void setup() {
     
180.   Serial.begin(9600);
     
181.   Serial << F("Free RAM: ") << FreeRam() << "\n";
     
182. 
     
183.   pinMode(LEDPIN, OUTPUT);
     
184.   setLedEnabled(false);
     
185. 
     
186.   pinMode(SS_PIN, OUTPUT);        // set the SS pin as an output
     
187.                                 // (necessary to keep the board as
     
188.                                 // master and not SPI slave)
     
189.   digitalWrite(SS_PIN, HIGH);        // and ensure SS is high
     
190. 
     
191.   // Ensure we are in a consistent state after power-up or a reset
     
192.   // button These pins are standard for the Arduino w5100 Rev 3
     
193.   // ethernet board They may need to be re-jigged for different boards
     
194.   pinMode(ETHER_CS, OUTPUT);         // Set the CS pin as an output
     
195.   digitalWrite(ETHER_CS, HIGH); // Turn off the W5100 chip! (wait for
     
196.                                 // configuration)
     
197.   pinMode(SD_CS, OUTPUT);       // Set the SDcard CS pin as an output
     
198.   digitalWrite(SD_CS, HIGH);         // Turn off the SD card! (wait for
     
199.                                 // configuration)
     
200. 
     
201.   // initialize the SD card.
     
202.   Serial << F("Setting up SD card...\n");
     
203.   // Pass over the speed and Chip select for the SD card
     
204.   if (!card.init(SPI_FULL_SPEED, SD_CS)) {
     
205.     Serial << F("card failed\n");
     
206.     has_filesystem = false;
     
207.   }
     
208.   // initialize a FAT volume.
     
209.   if (!volume.init(&card)) {
     
210.     Serial << F("vol.init failed!\n");
     
211.     has_filesystem = false;
     
212.   }
     
213.   if (!root.openRoot(&volume)) {
     
214.     Serial << F("openRoot failed");
     
215.    
     
216.     has_filesystem = false;
     
217.   }
     
218. 
     
219.   if (has_filesystem) {
     
220.     // Assign our function to `upload_handler_fn'.
     
221.     TinyWebPutHandler::put_handler_fn = file_uploader_handler;
     
222.      if(initCam()>0)
     
223.      has_cam=true;
     
224.   }
     
225. 
     
226.   // Initialize the Ethernet.
     
227. // Serial << F("Setting up the Ethernet card...\n");
     
228.   Ethernet.begin(mac, ip);
     
229. 
     
230.   // Start the web server.
     
231. // Serial << F("Web server starting...\n");
     
232.   web.begin();
     
233. 
     
234.   Serial << F("Ready to accept HTTP requests.\n");
     
235. }
     
236. 
     
237. void loop() {
     
238.   if (has_filesystem) {
     
239.     web.process();
     
240.     Writefiles();
     
241.   }
     
242. }
     
243. uint8_t initCam()
     
244. {
     
245. if (!cam.begin()) {
     
246.    // serial.println("Camera Found:");
     
247.   //} else {
     
248.     Serial.println("No camera found?");
     
249.     return 0;
     
250.   }
     
251.   // Print out the camera version information (optional)
     
252. // char *reply = cam.getVersion();
     
253. // if (reply == 0) {
     
254. //   serial.print("Failed to get version");
     
255. // } //else {
     
256.    // serial.println("-----------------");
     
257.    // serial.print(reply);
     
258.   //  serial.println("-----------------");
     
259. //  }
     
260. 
     
261.   cam.setImageSize(VC0706_640x480);        // biggest
     
262. //  serial.print("Image size: ");
     
263.   Serial.println("640x480");
     
264.   return 1;
     
265. }
     
266. uint8_t PicSave()
     
267. {  if(WriteFileing)
     
268.     return 0;
     
269.    if(has_cam==false)  
     
270.     return 0;
     
271.   if(!cam.takePicture())
     
272.     Serial.println("Failed to snap!");
     
273. // else
     
274.    // serial.println("Picture taken!");
     
275.   
     
276.   // Create an image with the name IMAGExx.JPG
     
277.   char filename[13];
     
278.   strcpy(filename, "IMAGE00.JPG");
     
279.   for (int i = 0; i < 40; i++) {
     
280.     filename[5] = '0' + i/10;
     
281.     filename[6] = '0' + i%10;
     
282.     // create if does not exist, do not open existing, write, sync after write
     
283.     if (! checkExists(root,filename)) {
     
284.    //*//*  if(i==19)
     
285.    //*  Delxx(20,40);
     
286.     //* if(i==39)
     
287.    //*  Delxx(0,20);
     
288.      
     
289.      strcpy(Filenamenow, "IMAGE00.JPG");
     
290.      Filenamenow[5] = '0' + i/10;
     
291.     Filenamenow[6] = '0' + i%10;
     
292.       break;
     
293.     }
     
294.   }
     
295.   
     
296.   // Open the file for writing
     
297.   
     
298.    imgFile.open(&root,filename, O_CREAT | O_WRITE);
     
299. 
     
300.   // Get the size of the image (frame) taken  
     
301.   jpglen = cam.frameLength();
     
302.   Serial.print("Storing ");
     
303.   Serial.print(jpglen, DEC);
     
304.   Serial.print(" byte image.");
     
305.   time = millis();
     
306.   //pinMode(8, OUTPUT);
     
307.   // Read all the data up to # bytes!
     
308.   wCount = 0; // For counting # of writes
     
309.   WriteFileing=true;
     
310. 
     
311. // Serial.println(" ms elapsed");
     
312.   return 1;
     
313. }
     
314. void Writefiles()
     
315. {
     
316.   if (!WriteFileing)
     
317.   return;
     
318.   if (jpglen > 0) {
     
319.     // read 32 bytes at a time;
     
320.     uint8_t *buffer;
     
321.     uint8_t bytesToRead = min(32, jpglen); // change 32 to 64 for a speedup but may not work with all setups!
     
322.     buffer = cam.readPicture(bytesToRead);
     
323.     imgFile.write(buffer, bytesToRead);
     
324.     if(++wCount >= 64) { // Every 2K, give a little feedback so it doesn't appear locked up
     
325.     //  serial.print('.');
     
326.       wCount = 0;
     
327.     }
     
328.    //Serial.print("Read ");
     
329.     //Serial.print(bytesToRead, DEC);
     
330.    //Serial.println(" bytes");
     
331.     jpglen -= bytesToRead;
     
332.    return;
     
333.   }
     
334.   imgFile.close();
     
335. 
     
336.   time = millis() - time;
     
337.   Serial.println("done!");
     
338.   Serial.print(time);
     
339.   Serial.print(Filenamenow);
     
340.   WriteFileing=false;
     
341. }
     
342. boolean checkExists(SdFile& parentDir, char *filePathComponent) {
     
343. 
     
344.   SdFile child;
     
345. 
     
346.   boolean exists = child.open(parentDir, filePathComponent, O_RDONLY);
     
347.   
     
348.   if (exists) {
     
349.      child.close();
     
350.   }
     
351.   
     
352.   return exists;
     
353. }
     
354. void delExists(SdFile& parentDir, char *filePathComponent) {
     
355. 
     
356.   SdFile child;
     
357. 
     
358.   boolean exists = child.open(parentDir, filePathComponent, O_WRITE);
     
359.   
     
360.   if (exists) {
     
361.      child.remove();
     
362.      child.close();
     
363.     Serial.println("del!");
     
364.     Serial.println(filePathComponent);
     
365.   }
     
366.   
     
367.   
     
368. }
     
369. void Delxx(int starf,int endf)
     
370. {
     
371.   char filename[13];
     
372.   strcpy(filename, "IMAGE00.JPG");
     
373.   for (int i = starf; i < endf; i++) {
     
374.     filename[5] = '0' + i/10;
     
375.     filename[6] = '0' + i%10;
     
376.     // create if does not exist, do not open existing, write, sync after write
     
377.     delExists(root,filename);
     
378.   }
     
379. 
     
380. 
     
381. }

复制代码