update

Author: tdamdouni

Traffic counting System based on OpenCV and python/cars.xml

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+import cv2
+print(cv2.__version__)
+
+cascade_src = 'cars.xml'
+video_src = 'dataset/video2.avi'
+#video_src = 'dataset/video2.avi'
+
+cap = cv2.VideoCapture(video_src)
+car_cascade = cv2.CascadeClassifier(cascade_src)
+
+while True:
+    ret, img = cap.read()
+    if (type(img) == type(None)):
+        break
+    
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    
+    cars = car_cascade.detectMultiScale(gray, 1.1, 1)
+
+    for (x,y,w,h) in cars:
+        cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),2)      
+    
+    cv2.imshow('video', img)
+    print "Found "+str(len(cars))+" car(s)"
+    b=str(len(cars))
+    a= float(b)
+    if a>=5:
+        print ("more traffic")
+    else:
+        print ("no traffic")    
+    if cv2.waitKey(33) == 27:
+        break
+
+cv2.destroyAllWindows()

Traffic counting System based on OpenCV and python/vehicle_detection_counting.py

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 twartzek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

_Learn/Ansmann-lithIon.PDF

@@ -0,0 +1,55 @@
+# BME680 interface with Raspberry Pi
+## Introduction
+
+This program serves as a working example to read the measurements from a BME680 via the raspberry pi. Actually I wanted to read out the sensor via python, but as the driver provided by Bosch is a C file, I created this small C program to communicate to the sensor. The compile program can then be called from python. 
+
+
+## Usage guide
+### Compiling the program
+Download the driver for the [BME680](https://github.com/BoschSensortec/BME680_driver) from github.
+Put the file from this repository into the same directory.
+
+As this program uses i2c-dev, check you can use `i2cdetect -y 1` to verify if your I²C communication works via bus 1. You might need to adapt the code according your I²C Bus in the line `g_i2cFid = open("/dev/i2c-1", O_RDWR);` to `g_i2cFid = open("/dev/i2c-0", O_RDWR);` if bus 0 is used. Also check the I²C address of your sensor. The provided code uses `BME680_I2C_ADDR_SECONDARY` (0x77) as the address. 
+
+
+After this adaption you can compile the program with
+`gcc bme680_main.c bme680.c -o bme680`
+
+
+### Command line interface 
+The program can be called with up to three parameters. However, be aware that no special input check is implemented.
+1. `./bme680`: This will print three measurement results with the time of the measurement on the standard output stream. The delay between each measurement is 3 seconds.
+```shell
+pi@raspberrypi:~/myproject/sensors/bme680 $ ./bme680 
+**** BME680 start measurements  ****
+2017-10-07 19:48:18 T: 19.51 degC, P: 1013.08 hPa, H: 69.61 %rH , G: 3954 ohms
+2017-10-07 19:48:21 T: 19.53 degC, P: 1013.06 hPa, H: 69.43 %rH , G: 9471 ohms
+2017-10-07 19:48:24 T: 19.54 degC, P: 1013.04 hPa, H: 69.28 %rH , G: 16839 ohms
+**** Measurement finished ****
+pi@raspberrypi:~/myproject/sensors/bme680 $ 
+```
+2. `./bme680 5 2`: The first parameter defines the delay between each measurement. The second parameter defines the number of measurements before the program is terminated.
+```shell
+pi@raspberrypi:~/myproject/sensors/bme680 $ ./bme680 5 2
+**** BME680 start measurements  ****
+2017-10-07 20:02:41 T: 19.51 degC, P: 1012.86 hPa, H: 69.87 %rH , G: 26970 ohms
+2017-10-07 20:02:46 T: 19.52 degC, P: 1012.84 hPa, H: 69.71 %rH , G: 44102 ohms
+**** Measurement finished ****
+pi@raspberrypi:~/myproject/sensors/bme680 $ 
+```
+3. `./bme680 5 2 output.txt`: You can also provide a third argument, which will be used to write the measurements into a file.
+
+### Usage within Python
+If you want to use this program in python, you can simply call it with `check_output`.
+
+```python
+from subprocess import check_output
+out = check_output(["bme680", str(measDelay), str(nMeas)])
+```
+If any problems with concurrent I²C bus usages occur, you can check if the file *~bme680i2c.lock* exists, as this is created at the start of the program and deleted shortly before termination.
+
+
+
+
+
+

_images/pi0w-hyperpixel-keyboard-project.JPG

@@ -0,0 +1,283 @@
+ /******************************
+ * Copyright (C) 2017 by Tobias Wartzek  
+ * @file	bme680_main.c
+ * @date	07.10.2017
+ * @version	1.0
+ * @brief Interface to BME680 from Raspberry Pi
+ * 
+ * 
+ * Read out temperature, pressure, humidity and gas sensor ohmic values 
+ * via I²C and Raspberry Pi.
+ * 
+ * History
+ * Version		Date		Detail
+ * 1.0			07.10.2017 	Initial creation
+ * 
+ ******************************/
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <linux/i2c-dev.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "bme680.h"
+
+#define     DESTZONE    "TZ=Europe/Stockholm"       // Our destination time zone
+
+
+
+// I2C Linux device handle
+int g_i2cFid;
+
+// open the Linux device
+void i2cOpen()
+{
+	g_i2cFid = open("/dev/i2c-1", O_RDWR);
+	if (g_i2cFid < 0) {
+		perror("i2cOpen");
+		exit(1);
+	}
+}
+
+// close the Linux device
+void i2cClose()
+{
+	close(g_i2cFid);
+}
+
+// set the I2C slave address for all subsequent I2C device transfers
+void i2cSetAddress(int address)
+{
+	if (ioctl(g_i2cFid, I2C_SLAVE, address) < 0) {
+		perror("i2cSetAddress");
+		exit(1);
+	}
+}
+
+
+
+void user_delay_ms(uint32_t period)
+{
+
+    sleep(period/1000);
+
+
+
+}
+
+int8_t user_i2c_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
+{
+    int8_t rslt = 0; /* Return 0 for Success, non-zero for failure */
+
+    uint8_t reg[1];
+	reg[0]=reg_addr;
+
+ 	if (write(g_i2cFid, reg, 1) != 1) {
+		perror("user_i2c_read_reg");
+		rslt = 1;
+	}
+	if (read(g_i2cFid, reg_data, len) != len) {
+		perror("user_i2c_read_data");
+		rslt = 1;
+	}
+
+    return rslt;
+}
+
+int8_t user_i2c_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
+{
+    int8_t rslt = 0; /* Return 0 for Success, non-zero for failure */
+
+
+	uint8_t reg[16];
+    reg[0]=reg_addr;
+	
+    for (int i=1; i<len+1; i++)
+       reg[i] = reg_data[i-1];
+
+    if (write(g_i2cFid, reg, len+1) != len+1) {
+		perror("user_i2c_write");
+		rslt = 1;
+        exit(1);
+	}
+
+    return rslt;
+}
+
+
+void write2file(char *outputFile, struct tm tm, struct bme680_field_data data)
+{
+	// Write measurement to output file if specified.
+	if(outputFile != NULL)
+	{
+		FILE *f = fopen(outputFile, "a");
+		if (f == NULL)
+		{
+			printf("Error opening file!\n");
+			//exit(1);
+		}
+		else
+		{
+			fprintf(f,"%d-%02d-%02d %02d:%02d:%02d ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+			fprintf(f,"T: %.2f degC, P: %.2f hPa, H: %.2f %%rH", data.temperature / 100.0f,
+					data.pressure / 100.0f, data.humidity / 1000.0f );
+			fprintf(f,", G: %d Ohms", data.gas_resistance);
+			fprintf(f,"\r\n");
+			fclose(f);
+		}
+	
+	}
+}
+
+int main(int argc, char *argv[] )
+{
+	// create lock file first
+	FILE *f = fopen("~bme680i2c.lock", "w");
+	if (f == NULL)
+	{
+		printf("Error opening file!\n");
+		exit(1);
+	}
+	fprintf(f,"I2C locked by BME680 readout. \r\n");
+	fclose(f);
+
+
+	int delay = 3;
+	int nMeas = 3;
+	char *outputFile = NULL;
+
+	// Input argument parser
+	if( argc == 2 ) {
+		delay = strtol(argv[1], NULL, 10);
+	}
+	else if( argc == 3 ) {
+		delay = strtol(argv[1], NULL, 10);
+		nMeas = strtol(argv[2], NULL, 10);
+	}
+	else if( argc == 4 ) {
+		delay = strtol(argv[1], NULL, 10);
+		nMeas = strtol(argv[2], NULL, 10);
+		outputFile = argv[3]; 
+	}
+	else {
+		
+	}
+
+
+	printf("**** BME680 start measurements  ****\n");
+
+	time_t t = time(NULL);
+    putenv(DESTZONE);               // Switch to destination time zone
+
+
+    // open Linux I2C device
+	i2cOpen();
+
+	// set address of the BME680
+	i2cSetAddress(BME680_I2C_ADDR_SECONDARY);
+
+    // init device
+	struct bme680_dev gas_sensor;
+
+	gas_sensor.dev_id = BME680_I2C_ADDR_SECONDARY;
+	gas_sensor.intf = BME680_I2C_INTF;
+	gas_sensor.read = user_i2c_read;
+	gas_sensor.write = user_i2c_write;
+	gas_sensor.delay_ms = user_delay_ms;
+
+	int8_t rslt = BME680_OK;
+	rslt = bme680_init(&gas_sensor);
+
+    uint8_t set_required_settings;
+
+	/* Set the temperature, pressure and humidity settings */
+	gas_sensor.tph_sett.os_hum = BME680_OS_2X;
+	gas_sensor.tph_sett.os_pres = BME680_OS_4X;
+	gas_sensor.tph_sett.os_temp = BME680_OS_8X;
+	gas_sensor.tph_sett.filter = BME680_FILTER_SIZE_3;
+
+	/* Set the remaining gas sensor settings and link the heating profile */
+	gas_sensor.gas_sett.run_gas = BME680_ENABLE_GAS_MEAS;
+	/* Create a ramp heat waveform in 3 steps */
+	gas_sensor.gas_sett.heatr_temp = 320; /* degree Celsius */
+	gas_sensor.gas_sett.heatr_dur = 150; /* milliseconds */
+
+	/* Select the power mode */
+	/* Must be set before writing the sensor configuration */
+	gas_sensor.power_mode = BME680_FORCED_MODE; 
+
+	/* Set the required sensor settings needed */
+	set_required_settings = BME680_OST_SEL | BME680_OSP_SEL | BME680_OSH_SEL | BME680_FILTER_SEL 
+		| BME680_GAS_SENSOR_SEL;
+
+	/* Set the desired sensor configuration */
+	rslt = bme680_set_sensor_settings(set_required_settings,&gas_sensor);
+
+	/* Set the power mode */
+	rslt = bme680_set_sensor_mode(&gas_sensor);
+
+
+
+	/* Get the total measurement duration so as to sleep or wait till the
+	 * measurement is complete */
+	uint16_t meas_period;
+	bme680_get_profile_dur(&meas_period, &gas_sensor);
+	user_delay_ms(meas_period + delay*1000); /* Delay till the measurement is ready */
+
+
+    struct bme680_field_data data;
+
+	struct tm tm = *localtime(&t);
+	
+	int i=0;
+	int backupCounter = 0;
+
+	while(i<nMeas && backupCounter < nMeas+5) {
+
+		// Get sensor data
+		rslt = bme680_get_sensor_data(&data, &gas_sensor);
+		
+		// Avoid using measurements from an unstable heating setup 
+		if(data.status & BME680_HEAT_STAB_MSK)
+		{
+			t = time(NULL);
+			tm = *localtime(&t);
+			printf("%d-%02d-%02d %02d:%02d:%02d ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+			printf("T: %.2f degC, P: %.2f hPa, H: %.2f %%rH", data.temperature / 100.0f,
+					data.pressure / 100.0f, data.humidity / 1000.0f );
+			printf(", G: %d Ohms", data.gas_resistance);
+			printf("\r\n");
+			write2file(outputFile, tm, data);
+			i++;
+		}
+
+		// Trigger a meausurement
+		rslt = bme680_set_sensor_mode(&gas_sensor); /* Trigger a measurement */
+
+		// Wait for a measurement to complete
+		user_delay_ms(meas_period + delay*1000); /* Wait for the measurement to complete */			
+
+		backupCounter++;
+	}
+
+
+	printf("**** Measurement finished ****\n");
+
+
+
+    // close Linux I2C device
+	i2cClose();
+	
+	// delete lock file
+	remove("~bme680i2c.lock");
+	
+	return 0;
+}
+