#include <Arduino.h> //Για την οθονηOLED
#include <U8g2lib.h> //Για την οθονηOLED
#ifdef U8X8_HAVE_HW_SPI //Για την οθονηOLED
#include <SPI.h> //Για την οθονηOLED
#endif //Για την οθονηOLED
U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
/////////////////////////// Αρχή μεταβλητών για την SD μνήμη///////////////////////////////
#include "SdFat.h"
//Αλλάζουμε την τιμή του pin ανάλογα με αυτό που ταιριάζει στην περίπτωση μας.
const uint8_t chipSelect = 7;
// Interval between data records in milliseconds.
// The interval must be greater than the maximum SD write latency plus the
// time to acquire and write data to the SD to avoid overrun errors.
// Run the bench example to check the quality of your SD card.
const uint32_t SAMPLE_INTERVAL_MS = 1000;
// Log file base name. Must be six characters or less.
#define FILE_BASE_NAME "Fire"
//------------------------------------------------------------------------------
// File system object.
SdFat sd;
// Log file.
SdFile file;
// Time in micros for next data record.
//uint32_t logTime;
//==============================================================================
// User functions. Edit writeHeader() and logData() for your requirements.
//const uint8_t ANALOG_COUNT = 4;
//------------------------------------------------------------------------------
// Write data header.
void writeHeader() {
file.print(F("Time(sec)"));
file.print(F(",PPM"));
file.print(F(",object*C"));
file.print(F(",Ambient*C"));
file.print(F(",Angle X"));
file.println();
}
// Error messages stored in flash.
#define error(msg) sd.errorHalt(F(msg))
/////////////////////////// Τέλος μεταβλητών για την SD μνήμη///////////////////////////////
#include <Wire.h>
#include <Adafruit_MLX90614.h> //Για τον αισθητήρα υπερυθρων θερμοκρασίας.
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
/////////////////////////////Αισθητήρας Μονοξειδίου του άνθρακα MQ7///////////////////////////////
// Εισαγάγετε την τάση της πλακέτας Arduino σε βολτ (τάση αναφοράς):
float Ub2=6.3; //Για σύνδεση παροχής με μπαταρίες 4Χ1.2volt ΝΙΜΗ.
//float Ub1=4.1; //Για σύνδεση παροχής με μπαταρία LI-ion 3.6volt.
float Uv1=4.1; //μεγιστη τάση εξόδου του αισθητήρα ΜQ7 λόγω του διαιρέτη τάσης.
float Ur=5.1; //Τάση στον αισθητήρα ΜQ7 .
// Εισαγάγετε την μεταβλητή αντίσταση του αισθητήρα σε ohms:
int RL=5150; //1800
// Εισαγάγετε την αντίσταση του αισθητήρα Ro σε ohms:
int R0=1000; //600
int H=0; //Μεταβλητή για την τιμή από την αναλογική είσοδο A0 της αναλογικής εξόδου του αισθητήρα ΜQ7.
float Um=0; //Mεταβλητή για την τάση Vcc του αισθητήρα σε volt. τ
float Rs; //Μεταβλητή για την αντίσταση του αισθητήρα Rs κατά τη μέτρηση.
float R; //Mεταβλητή για τον λόγο Rs/Ro
int C; //Mεταβλητή για συγκέντρωση CO σε ppm
float B=0; //Mεταβλητή για τάση μπαταρίας
float S1=0; //Mεταβλητή για τάση μπαταρίας
float SB=0; //Mεταβλητή για τάση μπαταρίας
/////////////////////////////Αισθητήρας Μονοξειδίου του άνθρακα MQ7///////////////////////////////
//unsigned long previousTimee=0; //Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTimeSD=0; //Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTime=0; //Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTime1=0; //Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTime2=0; //Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTime3=0; //πρωτος ελεγχος για μηδενισμο χρόνου μέτρησης_Μεταβλητή χρόνου απο την οποία θα αρχίσω να μετράω το χρονικό διάστημα.
unsigned long previousTimefall=0; //πότε ξεκίνησε η ακινησια.
unsigned long intervaalSD=400; //δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. να μετράει όταν φτάνει αυτή η τιμή για τις καταγραφές στην microSD.
unsigned long intervaal=500; //δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. να μετράει όταν φτάνει αυτή η τιμή για τις μετρησεις θερμοκρασιας.
unsigned long intervali=250; //δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. να μετράει όταν φτάνει αυτή η τιμή για τις προηγούμενες μετρησεις κινησης.
unsigned long intervali1=300; //δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. να μετράει όταν φτάνει αυτή η τιμή για τις τωρινές μετρησεις κινησης.
unsigned long intervali2=2000; //Δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. Αφου παραμεινει ακινητο να ξεπερασει αυτο τον χρονο και επειτα να ηχησει το buzzer για την κινηση.
unsigned long intervali3=1000; //Δηλώνω μεταβλήτη χρόνου για σύγκριση π.χ. Απο κατασταση ακινησιας θα πρεπει να ξεπερασει αυτο τον χρονο και επειτα να σταματησει να ηχεί το buzzer για την ακινησία..
int buzzer=5;
//int LaserbuttonPushCounter = 0; // counter for the number of button presses
int LaserlastButtonState = LOW; // previous state of the button
int LaserbuttonState ; // Μεταβλητή για την κατασταση του button του Lazerpointer
const int LaserbuttonPin =3; // Δηλώνω τον αριθμό του pin gia to button του laserpointer
const int LaserPin =4; // Δηλώνω τον αριθμό του pin gia to Laserpointer
unsigned long LaserlastDebounceTime = 0; // the last time the output pin was toggled
unsigned long LaserdebounceDelay =10; // the debounce time; increase if the output flickers
int LaserState = LOW; // the current state of the output pin
///////////////ΑΡΧΗ_ Συναρτήσεις για τον MPU6050 αισθητηρα κίνησης////////////////////////
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
Adafruit_MPU6050 mpu;
bool state;
int angleX;
//----------------------Για υπολογισμό γωνίας Υ αρχή-------------------------
//Gyro Variables
float elapsedTime,time, timePrev; //Variables for time control
//int gyro_error=0; //We use this variable to only calculate once the gyro data error
//float Gyr_rawX, Gyr_rawY, Gyr_rawZ; //Here we store the raw data read
float Gyro_angle_x, Gyro_angle_y; //Here we store the angle value obtained with Gyro data
//float Gyro_raw_error_x, Gyro_raw_error_y; //Here we store the initial gyro data error
//Acc Variables
//int acc_error=0; //We use this variable to only calculate once the Acc data error
float rad_to_deg = 180/3.141592654; //This value is for pasing from radians to degrees values
//float Acc_rawX, Acc_rawY, Acc_rawZ; //Here we store the raw data read
float Acc_angle_x, Acc_angle_y; //Here we store the angle value obtained with Acc data
//float Acc_angle_error_x, Acc_angle_error_y; //Here we store the initial Acc data error
float Total_angle_x, Total_angle_y;
//----------------------Για υπολογισμό γωνίας Υ τέλος-------------------------
float previousValAcceleraX1=0; //προηγούμενη τιμή επιτάχυνσης1
float previousValAcceleraY1=0;
float previousValAcceleraZ1=0;
float previousValgyrox1=0; //προηγούμενη τιμή περιστροφών1
float previousValgyroy1=0;
float previousValgyroz1=0;
float previousValAcceleraX2=0; //προηγούμενη τιμή επιτάχυνσης2
float previousValAcceleraY2=0;
float previousValAcceleraZ2=0;
float previousValgyrox2=0; //προηγούμενη τιμή περιστροφών2
float previousValgyroy2=0;
float previousValgyroz2=0;
///////////////ΤΕΛΟΣ _ Συναρτήσεις για τον MPU6050 αισθητηρα κίνησης////////////////////////
void setup(void) {
u8g2.begin(); //Για την οθονηOLED
mlx.begin();
//button.invertReading();
//pinMode( pinButton, INPUT );
pinMode(LaserPin, OUTPUT);
pinMode(LaserbuttonPin, INPUT);
pinMode( buzzer, OUTPUT );
//pinMode(13,OUTPUT);
digitalWrite(buzzer,LOW);
digitalWrite(LaserPin,LOW);
//digitalWrite(13,LOW);
Wire.begin();
//Serial.begin(115200);
//while (!Serial); // Αναμονή μέχρι να ανοίξει η εποικινωνία.
//Serial.println("\Test I2C starting..");
u8g2.clearBuffer(); // clear the internal memory
u8g2.setFont(u8g2_font_ncenB08_tr); //Γραμματοσειρά σε μία γραμμή απο τις 6 γραμμες
u8g2.drawStr(20,10,"Good day"); // (θεση στηλη,θεση γραμμή,κειμενο)
u8g2.drawStr(30,20,"auth");
u8g2.drawStr(20,30,"Mechanical");
u8g2.drawStr(20,40,"Engineering");
u8g2.sendBuffer(); // transfer internal memory to the display
delay(1000);
u8g2.clearBuffer(); // clear the internal memory
u8g2.drawStr(20,10,"Test I2C "); //(θεση στηλη,θεση γραμμή,κειμενο)
u8g2.drawStr(12,20,"starting..");
u8g2.sendBuffer();
delay(1500);
u8g2.clearBuffer(); // clear the internal memory
////////////////////////////////////// Εναρξη ελέγχου επικοινωνίας αισθητήρων Ι2C///////////////////////////////
int nDevices = 0;
//Serial.println("Scanning...");
u8g2.drawStr(10,10,"Scanning...");
u8g2.sendBuffer();
delay(500);
u8g2.clearBuffer();
for (byte address = 1; address < 127; ++address) { // ψάχνω όλες τις 127 διευθύνσεις
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
byte error = Wire.endTransmission();
if (error == 0) {
//Serial.print("I2C device found at address 0x");
u8g2.drawStr(0,10,"I2C device found"); //(θεση στηλη,θεση γραμμή,κειμενο)
u8g2.drawStr(20,20,"at address");
u8g2.drawStr(10,30,"--> 0x");
//(θεση στηλη,θεση γραμμή,κειμενο)
if (address < 16) {
//Serial.print("0");
u8g2.drawStr(60,30,"0"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
}
//Serial.print(address, HEX);
//Serial.println(" !");
//Serial.println(nDevices+1);
//Serial.println("I2C sensor OK");
u8g2.setCursor(44,30); //(θεση στηλη,θεση γραμμή)
u8g2.print(address,HEX);
u8g2.setCursor(60, 30);
u8g2.print(" !!");
u8g2.setCursor(0, 30);
u8g2.println(nDevices+1);
u8g2.sendBuffer();
delay(2500);
u8g2.clearBuffer();
u8g2.drawStr(0,10,"I2C sensor OK"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
delay(500);
u8g2.clearBuffer();
//Serial.println(nDevices);
++nDevices;
} else if (error == 4) {
//Serial.print("Unknown error at address 0x");
u8g2.drawStr(0,10,"Unknown error");
u8g2.drawStr(20,20,"at address");
u8g2.drawStr(10,30,"-->0x");
u8g2.sendBuffer();
if (address < 16) {
//Serial.print("0");
u8g2.drawStr(60,30,"0");
u8g2.sendBuffer();
}
//Serial.println(address, HEX);
u8g2.setCursor(44,30); //(θεση στηλη,θεση γραμμή)
u8g2.print(address, HEX);
u8g2.sendBuffer();
delay(1500);
u8g2.clearBuffer();
}
}
if (nDevices == 0) {
//Serial.println("No I2C devices found\n");
u8g2.drawStr(0,10,"No I2C"); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(10,20,"devices found");
u8g2.sendBuffer();
delay(6500);
u8g2.clearBuffer();
u8g2.drawStr(10,10,"Please OFF");
u8g2.drawStr(10,20,"this device");
u8g2.sendBuffer();
delay(6500);
u8g2.clearBuffer();
}
else if (nDevices == 1) {
//Serial.println("Missing one I2C sensor");
u8g2.drawStr(4,0,"Missing one"); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(2,1,"I2C sensor");
u8g2.sendBuffer();
delay(6500);
}
else {
//Serial.println("Complete I2C Scan\n");
u8g2.clearBuffer();
u8g2.drawStr(0,10,"I2C Scan");
u8g2.drawStr(0,20,"Completed !!"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
delay(1500);
}
delay(500); // Wait 5 seconds
///////////////////////////////////Τέλος ελέγχου επικοινωνίας αισθητήρων Ι2C///////////////////////////////////
///////////////Αρχη setup για τον MPU6050 αισθητηρα κίνησης////////////////////////
// Try to initialize!
/* if (xxx>90||xxx<90) {
Serial.println("Failed to find MLX chip");
u8x8.drawString(2,0,"Failed to find "); //(θεση στηλη,θεση γραμμή)
u8x8.drawString(2,1,"MLX90614 chip");
delay(1500);
u8x8.clear();
u8x8.drawString(2,1,"Please OFF");
u8x8.drawString(2,3,"this device");
while (1) {
delay(10);
}
}
Serial.println("MLX90614 Found!");
u8x8.drawString(1,0,"MLX90614 Found!");
u8x8.drawString(6,3,"OK");
delay(500);
u8x8.clear();
*/
// Try to initialize!
if (!mpu.begin()) {
//Serial.println("Failed to find MPU6050 chip");
u8g2.clearBuffer();
u8g2.drawStr(0,10,"Failed to find"); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(0,20,"MPU6050 chip");
u8g2.sendBuffer();
delay(6500);
u8g2.clearBuffer();
u8g2.drawStr(0,10,"Please OFF");
u8g2.drawStr(0,20,"this device");
u8g2.sendBuffer();
while (1) {
delay(10);
}
}
//Serial.println("MPU6050 Found!");
u8g2.clearBuffer();
u8g2.drawStr(0,10,"MPU6050 Found!");
u8g2.drawStr(40,30,"OK");
u8g2.sendBuffer();
delay(1500);
// Εδω αλλάζουμε το ευρος μέτρησης και μετριέται σε μονάδες G.
mpu.setAccelerometerRange(MPU6050_RANGE_4_G);
//Serial.print("Accelerometer range set to: ");
u8g2.clearBuffer();
u8g2.drawStr(0,10,"Accelerometer");
u8g2.drawStr(0,20,"range set :");
u8g2.sendBuffer();
switch (mpu.getAccelerometerRange()) {
case MPU6050_RANGE_2_G:
//Serial.println("+-2G");
u8g2.drawStr(60,20,"+-2G");
u8g2.sendBuffer();
break;
case MPU6050_RANGE_4_G:
//Serial.println("+-4G");
u8g2.drawStr(60,20,"+-4G"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
break;
case MPU6050_RANGE_8_G:
//Serial.println("+-8G");
u8g2.drawStr(60,20,"+-8G");
u8g2.sendBuffer();
break;
case MPU6050_RANGE_16_G:
//Serial.println("+-16G");
u8g2.drawStr(60,20,"+-16G");
u8g2.sendBuffer();
break;
}
//Εδω αλλαζουμε την ευαισθησια στo ευρος της περιστροφής σε degrees per second (dps)
mpu.setGyroRange(MPU6050_RANGE_500_DEG);
//Serial.print("Gyro range set to: ");
u8g2.drawStr(0,30,"Gyro");
u8g2.drawStr(0,40,"set:");
u8g2.sendBuffer();
switch (mpu.getGyroRange()) {
case MPU6050_RANGE_250_DEG:
//Serial.println("+- 250deg/s");
u8g2.drawStr(40,40,"+-250deg/s"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
break;
case MPU6050_RANGE_500_DEG:
//Serial.println("+- 500 deg/s");
u8g2.drawStr(40,40,"+-500deg/s");
u8g2.sendBuffer();
break;
case MPU6050_RANGE_1000_DEG:
//Serial.println("+- 1000 deg/s");
u8g2.drawStr(40,40,"+-1000deg/s");
u8g2.sendBuffer();
break;
case MPU6050_RANGE_2000_DEG:
//Serial.println("+- 2000 deg/s");
u8g2.drawStr(40,40,"+-2000deg/s"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
break;
}
//Εδώ ρυθμίζουμε την συχνότητα δειγματοληψίας,δλδ τον ρυθμό δεδομένων.
mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
//Serial.print("Filter bandwidth set to: ");
u8g2.drawStr(0,50,"Fil/bandwidth");
u8g2.drawStr(0,60,"set:");
u8g2.sendBuffer();
switch (mpu.getFilterBandwidth()) {
case MPU6050_BAND_260_HZ:
//Serial.println("260 Hz");
u8g2.drawStr(45,60,"260 Hz");
u8g2.sendBuffer();
break;
case MPU6050_BAND_184_HZ:
//Serial.println("184 Hz");
u8g2.drawStr(45,60,"184 Hz"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
break;
case MPU6050_BAND_94_HZ:
//Serial.println("94 Hz");
u8g2.drawStr(45,60,"94 Hz");
u8g2.sendBuffer();
break;
case MPU6050_BAND_44_HZ:
//Serial.println("44 Hz");
u8g2.drawStr(45,60,"44 Hz");
u8g2.sendBuffer();
break;
case MPU6050_BAND_21_HZ:
//Serial.println("21 Hz");
u8g2.drawStr(45,60,"21 Hz");
u8g2.sendBuffer();
break;
case MPU6050_BAND_10_HZ:
//Serial.println("10 Hz");
u8g2.drawStr(45,65,"10 Hz");
u8g2.sendBuffer();
break;
case MPU6050_BAND_5_HZ:
//Serial.println("5 Hz");
u8g2.drawStr(45,60,"5 Hz");
u8g2.sendBuffer();
break;
}
//Serial.println("");
delay(2000);
///////////////Telos setup για τον MPU6050 αισθητηρα κίνησης////////////////////////
digitalWrite(LaserPin, LaserState);
u8g2.clearBuffer();
u8g2.sendBuffer();
u8g2.drawStr(15,10,"scanning microSD");
u8g2.sendBuffer();
delay(2000);
///////////////////////////////////////Αρχή ελέγχου για την κάρτα SD/////////////////////////////////////
const uint8_t BASE_NAME_SIZE = sizeof(FILE_BASE_NAME) - 1;
char fileName[13] = FILE_BASE_NAME "00.csv";
// Initialize at the highest speed supported by the board that is
// not over 50 MHz. Try a lower speed if SPI errors occur.
if (!sd.begin(chipSelect, SD_SCK_MHZ(16))) {
//sd.initErrorHalt();
u8g2.drawStr(45,30,"No SD "); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(45,40,"Found"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
}
// Find an unused file name.
if (BASE_NAME_SIZE > 6) {
error("FILE_BASE_NAME too long");
}
while (sd.exists(fileName)) {
if (fileName[BASE_NAME_SIZE + 1] != '9') {
fileName[BASE_NAME_SIZE + 1]++;
} else if (fileName[BASE_NAME_SIZE] != '9') {
fileName[BASE_NAME_SIZE + 1] = '0';
fileName[BASE_NAME_SIZE]++;
} else {
error("Can't create file name");
}
}
if (!file.open(fileName, O_WRONLY | O_CREAT | O_EXCL)) {
error("file.open");
}
// Read any Serial data.
do {
delay(10);
}
/////////////////////////////////////////////////////////////
while (Serial.available() && Serial.read() >= 0);
//Serial.print(F("Logging to: "));
//Serial.println(fileName);
//Serial.println(F("Type any character to stop"));
/////////////////////////////////////////////////////////////
// Write data header.
u8g2.drawStr(40,30,"microSD "); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(45,40,"Found"); //(θεση στηλη,θεση γραμμή)
u8g2.sendBuffer();
delay(2000);
writeHeader();
///////////////////////////////////////Τέλος ελέγχου για την κάρτα SD/////////////////////////////////////
}
void loop(void) {
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);
//-------------------------Τιμές για γωνία X,Υ αρχή-----------------------------
timePrev = time; // the previous time is stored before the actual time read
time = millis(); // actual time read
elapsedTime = (time - timePrev) / 1000; //divide by 1000 in order to obtain seconds
//////////////////////////////////////Gyro read/////////////////////////////////////
/*Now we integrate the raw value in degrees per seconds in order to obtain the angle
* If you multiply degrees/seconds by seconds you obtain degrees */
/*---X---*/
Gyro_angle_x = g.gyro.x*elapsedTime;
/*---X---*/
Gyro_angle_y = g.gyro.y*elapsedTime;
//////////////////////////////////////Acc read/////////////////////////////////////
/*Now in order to obtain the Acc angles we use euler formula with acceleration values
after that we substract the error value found before*/
/*---X---*/
Acc_angle_x = (atan((a.acceleration.y)/sqrt(pow((a.acceleration.x),2) + pow((a.acceleration.z),2)))*rad_to_deg) ;
/*---Y---*/
Acc_angle_y = (atan(-1*(a.acceleration.x)/sqrt(pow((a.acceleration.y),2) + pow((a.acceleration.z),2)))*rad_to_deg) ;
//////////////////////////////////////Total angle and filter/////////////////////////////////////
/*---X axis angle---*/
Total_angle_x = (0.98 *(Total_angle_x + Gyro_angle_x) + 0.02*Acc_angle_x);
/*---Y axis angle---*/
Total_angle_y = (0.98 *(Total_angle_y + Gyro_angle_y) + 0.02*Acc_angle_y); //διόρθωση 0.02 και 0.98.
//-------------------------Τιμές για γωνία X,Υ τέλος- -------------------------
/*/////////////Αρχή_LaserPointer με switch push button //////////////////
LazerbuttonState = digitalRead(LaserbuttonPin); //Διαβάζω την κατάσταση του button
if (LazerbuttonState == HIGH) {
// turn LED on:
digitalWrite(LaserPin, HIGH);
} else {
// turn LED off:
digitalWrite(LaserPin, LOW);
}
/////////////Τέλος_LaserPointer με switch push button //////////////////
*/
/////////////Αρχή_LaserPointer με push button και Debounce Time //////////////////
// read the state of the switch into a local variable:
unsigned long currentTime2=millis();
int reading = digitalRead(LaserbuttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited long enough
// since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != LaserlastButtonState) {
// reset the debouncing timer
LaserlastDebounceTime = currentTime2;
}
if ((currentTime2 - LaserlastDebounceTime) >LaserdebounceDelay) {
// whatever the reading is at, it's been there for longer than the debounce
// delay, so take it as the actual current state:
// if the button state has changed:
if (reading != LaserbuttonState) {
LaserbuttonState = reading;
// only toggle the LED if the new button state is HIGH
if (LaserbuttonState == HIGH) {
LaserState = !LaserState;
}
}
}
// set the LED:
digitalWrite(LaserPin, LaserState);
// save the reading. Next time through the loop, it'll be the lastButtonState:
LaserlastButtonState = reading;
/////////////Τέλος_LaserPointer με push button //////////////////
unsigned long currentTime1=millis(); //θέτω στην μεταβλητή currentTime το νούμερο της millis.
float tim=0.1; //Τιμή την οποια συγκρίνω τις διαφορες των μετρησεων κινησης. καλή τιμή to 0.5
float tim2=0.03; //Τιμή την οποια συγκρίνω τις διαφορες των μετρησεων κινησης. καλή τιμή to 0.03
if(currentTime1-previousTime1>intervali ){ //katagrafh προηγουμενων μετρησεων σε χρονο intervali
previousTime1=currentTime1;
previousValAcceleraX1=a.acceleration.x;
previousValAcceleraY1=a.acceleration.y;
previousValAcceleraZ1=a.acceleration.z;
previousValgyrox1=g.gyro.x;
previousValgyroy1=g.gyro.y;
previousValgyroz1=g.gyro.z;
}
if(currentTime1-previousTime2>intervali1 ) { //καταγραφη παρον μετρησεων σε χρονο ontervali1
previousTime2=currentTime1;
previousValAcceleraX2=a.acceleration.x;
previousValAcceleraY2=a.acceleration.y;
previousValAcceleraZ2=a.acceleration.z;
previousValgyrox2=g.gyro.x;
previousValgyroy2=g.gyro.y;
previousValgyroz2=g.gyro.z;
}
//////////////////////////Αρχή _ Έλεγχος ακινησίας////////////////////////////////////////////
///////////Για επιτάχυνση στον άξονα Χ//////////////////
//Εφόσον οι διαφορες των μετρησεων ειναι πάνω απο μια τιμη τοτε μην ηχείς.
/*
if ( Total_angle_x<=20 && Total_angle_x>=-20) {
state=true;
}
else {state=false;
}
*/
//--------------συνθηκη για να ηχήσει το buzzer ακινησίας----------------
if ((currentTime1-previousTime3>intervali2) && ( Total_angle_x<=20 && Total_angle_x>=-20) && ((previousValAcceleraX2-previousValAcceleraX1) <= tim && (previousValAcceleraY2-previousValAcceleraY1)
<= tim && (previousValAcceleraZ2-previousValAcceleraZ1) <= tim && (previousValgyrox2-previousValgyrox1) <= tim2 && (previousValgyroy2-previousValgyroy1)
<= tim2&& (previousValgyroz2-previousValgyroz1) <= tim2))
{
//previousTime3=currentTime1;
previousTimefall=currentTime1;
digitalWrite(buzzer,HIGH);
}
//Συνθηκη εφοσον ξεκινησε η κινηση και σηκωθηκε.Σε πόσο χρόνο να σταματησει το buzzer απο την αρχη της κινησης.
else if(((currentTime1-previousTimefall)>intervali3)&& ((previousValAcceleraX2-previousValAcceleraX1) >= tim || (previousValAcceleraY2-previousValAcceleraY1)
>= tim || (previousValAcceleraZ2-previousValAcceleraZ1) >= tim2 ||(previousValgyrox2-previousValgyrox1)>= tim2 || (previousValgyroy2-previousValgyroy1)
>= tim || (previousValgyroz2-previousValgyroz1) >= tim2) )
{
//εδω μπορώ να αλλαξω τον χρόνο intervali3 τον οποιο θελω να συνεχισει να χτυπαει και εφοσον υπαρχει κινηση μετα απο την ακινησια. πχ 3000
previousTime3=currentTime1;
//previousTimefall=currentTime1;
digitalWrite(buzzer,LOW);
}
//////////////////////////Τέλος _ Έλεγχος ακινησίας////////////////////////////////////////////
///////////////////////////////Αρχη loop για τον αισθητηρα MQ7////////////////////////////////////
H=analogRead(14); // Διαβάζει την τάση στην είσοδο Α0 που βγάζει ο αισθητήρας MQ7
//delay (5);
float V1=(Uv1*H)/675; // Μετατρέπουμε τη τιμής στην είδοσο Αο σε τάση Volt ,υπόψην και τον διαιρέτη τάσης.
Um=(Ur*H)/1023; // Μετατρέπουμε τη τιμής στην είδοσο Αο σε τάση Volt.
Rs=((-Um)/Um)*RL; // Yπολογίζει την τιμή της αντίστασης του αισθητήρα Rs κάθε φορά,
//(5 - τάση που διαβάζει η είσοδος Αο σε Vολτ), RL ειναι η τιμή της αντιστασης του αισθητηρα.
R=(Rs/R0); //Υπολογίζεται κάθε φορά ο λόγος των αντιστάσεων Rs/Ro.
C=(pow(R,-1.409))*106.13; //C=(pow(R,-1.409))*106.13; to c σε ppm C=(pow(R,-1.52))*99.04;
B=analogRead(15); // διαβάζoυμε την αναλογική τιμή στην είσοδο Α1 και υπολογίζω περαιτέρω την κατάσταση της μπαταρίας σε%, αποθηκευμένη στη μεταβλητή SB
//////////////Για σύνδεση με μπαταρία LI-ion 3.6volt//////////////////////
//SB=(Ub1*B)/1024; // Μετατρέπουμε τη τιμή στην είδοσο Α1 σε τάση Volt ,υπόψην και τον διαιρέτη τάσης.
//////////////Για σύνδεση με μπαταρίες 4Χ1.2volt ΝΙΜΗ//////////////////////
SB=(Ub2*B)/1024; // Μετατρέπουμε τη τιμή στην είδοσο Α1 σε τάση Volt ,υπόψην και τον διαιρέτη τάσης.
//S1=(1024-B)/1.9;
//SB=100-S1; //Τιμή της μπαταρίας σε ποσοστό %.
//lcd.setCursor(0,0);
//lcd.print("Konc.CO:");
//lcd.setCursor(8,0);
if (Um>5.1)
{C=5000;}
//if (Um<0.231) //Um<0.531
//{C=0;}
//Serial.print("ppm");
//Serial.println(C);
/*lcd.print(C);
lcd.setCursor(13,0);
lcd.print("ppm");
*/
/*lcd.setCursor(0,2);
lcd.print("Us="); //Η τάση που έχει ο αισθητήρας
lcd.print(Um); //Η τάση που βγάζει ο αισθητήρας στην έξοδό του, Αout.
lcd.setCursor(7,2);
lcd.print("V");
lcd.setCursor(9,2);
lcd.print("Bat");
lcd.setCursor(12,2);
*/
//Serial.print("Us=");
//Serial.println(H);
//if (SB<5)
//{SB=0;}
//lcd.print(SB);
//lcd.setCursor(15,2);
//lcd.print("%");
//delay (500);
//lcd.clear();
///////////////////////////////Τέλος loop για τον αισθητηρα MQ7////////////////////////////////////
///////////////////Αρχή για τις καταγραφές στην κάρτα μνήμης micro SD///////////////////////////
// Force data to SD and update the directory entry to avoid data loss.
if (!file.sync() || file.getWriteError()) {
error("write error");
}
if (Serial.available()) {
// Close file and stop.
file.close();
Serial.println(F("Done"));
SysCall::halt();
}
///////////////////Τέλος για τις καταγραφές στην κάρτα μνήμης micro SD///////////////////////////
//////////////////////////Αρχή_ εκτύπωση θερμοκρασιας υπερυθρων////////////////////////////////////////////
unsigned long currentTimeSD=millis();
unsigned long currentTime=millis(); //θέτω στην μεταβλητή currentTime το νούμερο της millis.
//u8x8.setFlipMode(0); //αν βαλω 1 την γυριζει αναποδα την οθονη
if (currentTime-previousTime>intervaal){ // Συγκρίνω το χρονικό διάστημα που έχει περάσει με το χρόνο που έχω δώσει στην μεταβλητή interval.
previousTime=currentTime;
previousTimeSD=currentTimeSD;
//Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempC(),00);
//Serial.print("*C\tObject = "); Serial.print(mlx.readObjectTempC(),00); Serial.println("*C");
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_ncenB08_tr); //Γραμματοσειρά ύψος 10 pixel.
//u8x8.drawString(4,1,"Temp *C"); //(θεση στηλη,θεση γραμμή)
u8g2.drawStr(47,40,"Batt");
// u8g2.drawStr(47,50,"Lith"); //για μπαταρία LI-ion 3.6volt
u8g2.drawStr(45,50,"Mh"); //για μπαταρία NIMH 4X1.2volt
u8g2.setCursor(47,62);
u8g2.print(B,00);
u8g2.drawStr(68,30,"V");
u8g2.setCursor(47,30);
u8g2.print(SB,02);
u8g2.setCursor(70,10);
u8g2.drawStr(55,10,"MQ");
u8g2.setCursor(75,10);
u8g2.print(H);
u8g2.setCursor(100,10);
u8g2.drawStr(120,10,"V");
u8g2.print(V1,02);
u8g2.drawStr(0,22,"ANTIK *C");
u8g2.drawStr(78,22,"PERIBA");
u8g2.drawStr(0,10,"ppm:");
u8g2.setCursor(30,10); u8g2.print(C);
u8g2.sendBuffer();
//u8g2.setFont(u8g2_font_fub20_tr); //φοντο για μεγεθος 20 pixel
u8g2.setFont(u8g2_font_osb29_tr); //φοντο για μεγεθος 29 pixel
u8g2.setCursor(0,60); //(θεση στηλη,θεση γραμμή)
u8g2.print(mlx.readObjectTempC(),00); //θερμοκρασια αντικειμένου
u8g2.setCursor(70,60); //(θεση στηλη,θεση γραμμή)
u8g2.print(mlx.readAmbientTempC(),00); //θερμοκρασια αντικειμένου
u8g2.sendBuffer();
}
if (currentTimeSD-previousTimeSD>intervaalSD){ // Συγκρίνω το χρονικό διάστημα που έχει περάσει με το χρόνο που έχω δώσει στην μεταβλητή intervaal.
//////////////////////Αρχή καταγραφής στην κάρτα SD////////////////////////
file.print("timewithRTC);
file.write(',');
file.print(C);
file.write(',');
file.print(mlx.readObjectTempC(),00);
file.write(',');
file.print(mlx.readAmbientTempC(),00);
file.write(',');
file.print(Total_angle_x);
file.println();
//////////////////////Τέλος καταγραφής στην κάρτα SD////////////////////////
///////////////////////////εκτύπωση αισθητήρα ΜQ7/////////////////////////////////
// Serial.print("ppm Co:");Serial.println(C,01);
///////////////////////////εκτύπωση αισθητήρα ΜQ7///////////////////////////////
//Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempF());
//Serial.print("*F\tObject = "); Serial.print(mlx.readObjectTempF()); Serial.println("*F");
//Serial.println();
//delay(1400);
//Serial.println();
//////////////////////////Τελος_ εκτύπωση θερμοκρασιας υπερυθρων////////////////////////////////////////////
///////////////Αρχη loop για τον MPU6050 αισθητηρα κίνησης για προβολή μετρήσεων////////////////////////
/* Get new sensor events with the readings */
/* Print out the values */
/* Serial.print("Accelerometer ");
Serial.print("X: ");
Serial.print(a.acceleration.x, 2);
Serial.print(" m/s^2, ");
Serial.print("Y: ");
Serial.print(a.acceleration.y, 2);
Serial.print(" m/s^2, ");
Serial.print("Z: ");
Serial.print(a.acceleration.z, 2);
Serial.println(" m/s^2");
Serial.print("Gyroscope ");
Serial.print("X: ");
Serial.print(g.gyro.x, 2);
Serial.print(" rps, ");
Serial.print("Y: ");
Serial.print(g.gyro.y, 2);
Serial.print(" rps, ");
Serial.print("Z: ");
Serial.print(g.gyro.z, 2);
Serial.println(" rps");
Serial.println();
Serial.print("Xº: ");
Serial.print(Total_angle_x);
Serial.print("Yº: ");
Serial.print(Total_angle_y);
Serial.println();
*/
/*
//Serial.println("gyrozzzz: ");
//Serial.print(previousValgyroz2);
*/
}
delay(10);
/*Serial.print("Temperature: ");
Serial.print(temp.temperature);
Serial.println(" degC");
*/
}
///////////////Τελος loop για τον MPU6050 αισθητηρα κίνησης προβολής μετρήσεων////////////////////////