teensy 3.2 and Breakout Board Micro SD Card Mini

Status
Not open for further replies.
Hi to everyone!
I have the teensy 3.2 and want to use with this SD card breakout board https://grobotronics.com/breakout-board-for-micro-sd-card-mini.html
use :
-- arduino IDE with Teensy loader 1.53
--the ready library from the arduino IDE 1.8.13--> SD->cardinfo
For a start to use only teensy 3.2 with SD board just to make sure it works!
i conected the :
microSD board Vcc -->Vin with 5volt from usb connect.
microSD board GND -->GND teensy 3.2
microSD board MOSI -->Pin number 11 teensy 3.2
microSD board MISO-->Pin number 12 teensy 3.2
microSD board SCK-->Pin number 13 teensy 3.2
microSD board CS-->Pin number 7 teensy 3.2 ((i have changed--> ""const int chipSelect = 7 ""on code);
but I get a message from serial :

<<Initializing SD card...Wiring is correct and a card is present.

Card type: SD2
Could not find FAT16/FAT32 partition.
Make sure you've formatted the card

>>

use microSD 128mb or 2Gb but tha same above situation!!
i have formated SD card with my laptop win10 to fat32,fat16 and more with officcial SD Card formatter.

where is the fault?
 
// include the SD library:
#include <SD.h>
#include <SPI.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
// Teensy audio board: pin 10
// Teensy 3.5 & 3.6 & 4.1 on-board: BUILTIN_SDCARD
// Wiz820+SD board: pin 4
// Teensy 2.0: pin 0
// Teensy++ 2.0: pin 20
const int chipSelect = 7; //this is my SD board

void setup()
{
//UNCOMMENT THESE TWO LINES FOR TEENSY AUDIO BOARD:
//SPI.setMOSI(7); // Audio shield has MOSI on pin 7
//SPI.setSCK(14); // Audio shield has SCK on pin 14

// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect.
}


Serial.print("\nInitializing SD card...");


// we'll use the initialization code from the utility libraries
// since we're just testing if the card is working!
if (!card.init(SPI_HALF_SPEED, chipSelect)) {
Serial.println("initialization failed. Things to check:");
Serial.println("* is a card inserted?");
Serial.println("* is your wiring correct?");
Serial.println("* did you change the chipSelect pin to match your shield or module?");
return;
} else {
Serial.println("Wiring is correct and a card is present.");
}

// print the type of card
Serial.print("\nCard type: ");
switch(card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Unknown");
}

// Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
if (!volume.init(card)) {
Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
return;
}


// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
Serial.println();

volumesize = volume.blocksPerCluster(); // clusters are collections of blocks
volumesize *= volume.clusterCount(); // we'll have a lot of clusters
if (volumesize < 8388608ul) {
Serial.print("Volume size (bytes): ");
Serial.println(volumesize * 512); // SD card blocks are always 512 bytes
}
Serial.print("Volume size (Kbytes): ");
volumesize /= 2;
Serial.println(volumesize);
Serial.print("Volume size (Mbytes): ");
volumesize /= 1024;
Serial.println(volumesize);


Serial.println("\nFiles found on the card (name, date and size in bytes): ");
root.openRoot(volume);

// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}


void loop(void) {

}


this is the code!
Now i found another library called sdFat.. I'm trying to find a solution !!
I need some simple code to sent the data of accelerometer and analoge sensor to microSD!
 
Now i found another library called sdFat.. I'm trying to find a solution !!
I need some simple code to sent the data of accelerometer and analoge sensor to microSD!

First of all, please use the '#' toolbar button to enclose the code. It allows us to read the code more naturally. The '#' toolbar button will add [ CODE ] and [ /CODE ] tags, and you put the code inside.

Second Teensy is undergoing a big change WRT to SD drives in the the 1.54 beta releases. If you use 1.54 beta 7 (the latest), the old SD code has a thin layer and now calls SdFat directly. So you would not need to muck about with switching to SdFat, as it is already done.
 
First of all, please use the '#' toolbar button to enclose the code. It allows us to read the code more naturally. The '#' toolbar button will add [ CODE ] and [ /CODE ] tags, and you put the code inside.
Thanks for the info!!

Second Teensy is undergoing a big change WRT to SD drives in the the 1.54 beta releases. If you use 1.54 beta 7 (the latest), the old SD code has a thin layer and now calls SdFat directly. So you would not need to muck about with switching to SdFat, as it is already done.

No i use the 1.53 teensy.
With sketch "DataLogger" and with a modification το code, i found little help for my project to log the data to SDcart.
From library of example from the arduino IDE->SdFat-->examplesV1-->DataLogger.
Αbove I say a little help ,because it spoiled another point in the code ..
My code is over 1000 line and i dont now if help to upload.
 
This is my full code!!
When I add to my sketch the IDE->SdFat-->examplesV1-->DataLogger SD card library , I get a problem with the <<time>> variable .The <<time>> I used to calculate angles from the MPU6050.

Code:
#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 αισθητηρα κίνησης προβολής μετρήσεων////////////////////////
 
ok i thing found the solution!it seems to work! i change the variable <time>

Before:
Code:
//Gyro Variables
float elapsedTime,time, timePrev;        //Variables for time control


Code:
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

after:
Code:
//Gyro Variables
float elapsedTime, timePrev;        //Variables for time control
float timenow =0;

and

Code:
timePrev = timenow;                        // the previous time is stored before the actual time read
  timenow = millis();                        // actual time read
  elapsedTime = (timenow - timePrev) / 1000; //divide by 1000 in order to obtain seconds

Now its Ok!
 
Status
Not open for further replies.
Back
Top