Ajout de la lib LTC2439 et MesureADC

lib/LTC2439/LTC2439.cpp

@@ -0,0 +1,154 @@
+//
+//  LTC2439.cpp
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#include "LTC2439.h"
+
+
+
+#ifdef DEBUG
+    
+#endif
+
+
+LTC::LTC(int CSpin){
+    SPI.begin();
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT);
+    pinMode(CSpin, HIGH);
+    
+    pinConv = 12;
+    selectPin = CSpin;
+    SPI.end();
+}
+
+LTC::LTC(int CSpin, int SDOpin){
+    SPI.begin();
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT);
+    pinMode(CSpin, HIGH);
+    
+    pinConv = SDOpin;
+    selectPin = CSpin;
+    SPI.end();
+}
+LTC::LTC(int CSpin, int SDOpin, int F0pin){
+    SPI.begin();
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT);
+    pinMode(CSpin, HIGH);
+
+    pinMode(F0pin, OUTPUT);
+    pinMode(F0pin, LOW);
+    
+    pinConv = SDOpin;
+    selectPin = CSpin;
+    pinF0 = F0pin;
+    SPI.end();
+}
+
+long LTC::readValue(int channel){
+
+    //envoie de la commande
+
+    digitalWrite(selectPin, LOW);
+    
+    pinMode(pinConv, INPUT);
+    
+    while(digitalRead(pinConv) == 1){}
+
+    SPI.begin();
+    SPI.beginTransaction(SPISettings(500000, MSBFIRST,SPI_MODE0));
+    
+    SPI.transfer(0b10110000 | tableChanel[channel]);
+    digitalWrite(selectPin, HIGH);
+
+    SPI.end();
+
+    
+    #ifndef ARDUINO
+    delay(5);
+    #endif
+    // recuperation des data
+    digitalWrite(selectPin, LOW);
+    
+    pinMode(pinConv, INPUT);
+    
+    while(digitalRead(pinConv) == 1){}
+
+    SPI.begin();
+    SPI.beginTransaction(SPISettings(500000, MSBFIRST,SPI_MODE0));
+
+    int8_t bitsleft = 19;
+    long result = 0;
+    
+    while(bitsleft > 0) {
+           result <<= 8;
+           result |= SPI.transfer(0);
+           bitsleft -= 8;
+       }
+
+    SPI.end();
+
+    digitalWrite(selectPin,HIGH);
+    result >>= -bitsleft;
+    int pos = (result & 0b10000000000000000)>> 16;
+    unsigned long mask = 0b1111111111111111;
+    result &= mask;
+    
+    if(!pos && result != 0){
+        result = result | (~mask);
+    }
+    return result;
+}
+
+
+#ifdef ARDUINO
+
+//void LTC::startTimer(int frequency)
+//{
+//    cli();//stop interrupts
+//    
+//    TCCR2A = 0;// set entire TCCR2A register to 0
+//    TCCR2B = 0;// same for TCCR2B
+//    TCNT2  = 0;//initialize counter value to 0
+//
+//    OCR2A = (1/frequency)*5*10^5;
+//    // turn on CTC mode
+//    TCCR2A |= (1 << WGM21);
+//    // Set CS21 bit for 8 prescaler
+//    TCCR2B |= (1 << CS21);   
+//    // enable timer compare interrupt
+//    TIMSK2 |= (1 << OCIE2A);
+//
+//    sei();//allow interrupts
+//}
+//
+//ISR(TIMER2_COMPA_vect){
+//    toggle = !toggle;
+//    digitalWrite(pinF0,toggle);
+//
+//}
+
+#endif
+
+
+
+
+
+
+
+

lib/LTC2439/LTC2439.h

@@ -0,0 +1,44 @@
+//
+//  LTC2439.hpp
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#ifndef LTC2439_hpp
+#define LTC2439_hpp
+
+#include <stdint.h>
+#include "SPI.h"
+#include <Arduino.h>
+
+#define DEBUG
+//#define ARDUINO
+
+#ifdef ARDUINO
+
+static bool toggle = 0;
+static int pinF0;
+#endif
+
+class LTC
+{
+public:
+	LTC(int CSpin);
+	LTC(int CSpin, int SDOpin);
+    LTC(int CSpin, int SDOpin, int F0pin);
+    long readValue(int channel); // renvoie la valeur du channel en cours
+
+    #ifdef ARDUINO
+    void startTimer(int frequency);
+    #endif
+
+private:
+    int selectPin,pinConv;
+    int tableChanel[16]{0,8,1,9,2,10,3,11,4,12,5,13,6,14,7,15}; // tableau des Pins
+};
+
+
+
+#endif /* LTC2439_hpp */

lib/LTC2439/exemples/TestADC/TestADC.ino

@@ -0,0 +1,15 @@
+#include "LTC2439.h"
+
+LTC adc(10);
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  for(int i = 0; i < 16; i++){ 
+    Serial.print("Val adc ");
+    Serial.print(i);
+    Serial.print(" : ");
+    Serial.println(adc.readValue(i));
+  }
+}

lib/LTC2439/keywords.txt

@@ -0,0 +1,20 @@
+#######################################
+# Syntax Coloring Map LTC2439
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+LTC2439	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+LTC	KEYWORD2
+readValue	KEYWORD2
+startTimer	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

lib/MesureADC/LTC2439.cpp

@@ -0,0 +1,154 @@
+//
+//  LTC2439.cpp
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#include "LTC2439.h"
+
+
+
+#ifdef DEBUG
+    
+#endif
+
+
+LTC::LTC(int CSpin){
+    SPI.begin();  // démarage et configuration du SPI 
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT); // mise en sortie de la pin de CS
+    pinMode(CSpin, HIGH);
+    
+    pinConv = 12; // pin de SDO en dur
+    selectPin = CSpin;
+    SPI.end();
+}
+
+LTC::LTC(int CSpin, int SDOpin){
+    SPI.begin(); // démarage et configuration du SPI 
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT); // mise en sortie de la pin de CS
+    pinMode(CSpin, HIGH);
+    
+    pinConv = SDOpin; // pin de SDO
+    selectPin = CSpin;
+    SPI.end();
+}
+LTC::LTC(int CSpin, int SDOpin, int F0pin){
+    SPI.begin(); // démarage et configuration du SPI 
+    SPI.setBitOrder(MSBFIRST);
+    SPI.setDataMode(SPI_MODE0);
+    SPI.setClockDivider(SPI_CLOCK_DIV16);
+    
+    pinMode(CSpin, OUTPUT); // mise en sortie de la pin de CS
+    pinMode(CSpin, HIGH);
+
+    pinMode(F0pin, OUTPUT);
+    pinMode(F0pin, LOW);
+    
+    pinConv = SDOpin; // pin de SDO
+    selectPin = CSpin;
+    pinF0 = F0pin; // pin de Clock
+    SPI.end();
+}
+
+long LTC::readValue(int channel){
+
+    //envoie de la commande
+
+    digitalWrite(selectPin, LOW); // on selectionne le LTC
+    
+    pinMode(pinConv, INPUT);
+    
+    while(digitalRead(pinConv) == 1){} // On attend qu'il réponde
+
+    SPI.begin();
+    SPI.beginTransaction(SPISettings(500000, MSBFIRST,SPI_MODE0)); // Parametrage du SPI
+    
+    SPI.transfer(0b10110000 | tableChanel[channel]); // envoie d'une conversion
+    digitalWrite(selectPin, HIGH); // on déselectionne le LTC
+
+    SPI.end();
+
+    
+    #ifndef ARDUINO
+    delay(5);
+    #endif
+    // recuperation des data
+    digitalWrite(selectPin, LOW); // On selectionne le LTC
+    
+    pinMode(pinConv, INPUT); 
+    
+    while(digitalRead(pinConv) == 1){} // On attend qu'il réponde
+
+    SPI.begin();
+    SPI.beginTransaction(SPISettings(500000, MSBFIRST,SPI_MODE0)); // Parametrage du SPI
+
+    int8_t bitsleft = 19;
+    long result = 0;
+    
+    while(bitsleft > 0) { // On récupère les data
+           result <<= 8;
+           result |= SPI.transfer(0);
+           bitsleft -= 8;
+       }
+
+    SPI.end();
+
+    digitalWrite(selectPin,HIGH);
+    result >>= -bitsleft;           // On traite les data
+    int pos = (result & 0b10000000000000000)>> 16;
+    unsigned long mask = 0b1111111111111111;
+    result &= mask;
+    
+    if(!pos && result != 0){ // test des data
+        result = result | (~mask);
+    }
+    return result; // on envoie les data
+}
+
+
+#ifdef ARDUINO // Projet avec la pin FO non fini car remplacé par un NE555
+
+//void LTC::startTimer(int frequency)
+//{
+//    cli();//stop interrupts
+//    
+//    TCCR2A = 0;// set entire TCCR2A register to 0
+//    TCCR2B = 0;// same for TCCR2B
+//    TCNT2  = 0;//initialize counter value to 0
+//
+//    OCR2A = (1/frequency)*5*10^5;
+//    // turn on CTC mode
+//    TCCR2A |= (1 << WGM21);
+//    // Set CS21 bit for 8 prescaler
+//    TCCR2B |= (1 << CS21);   
+//    // enable timer compare interrupt
+//    TIMSK2 |= (1 << OCIE2A);
+//
+//    sei();//allow interrupts
+//}
+//
+//ISR(TIMER2_COMPA_vect){
+//    toggle = !toggle;
+//    digitalWrite(pinF0,toggle);
+//
+//}
+
+#endif
+
+
+
+
+
+
+
+

lib/MesureADC/LTC2439.h

@@ -0,0 +1,44 @@
+//
+//  LTC2439.hpp
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#ifndef LTC2439_hpp
+#define LTC2439_hpp
+
+#include <stdint.h>
+#include "SPI.h"
+#include <Arduino.h>
+
+#define DEBUG
+//#define ARDUINO
+
+#ifdef ARDUINO
+
+static bool toggle = 0;
+static int pinF0;
+#endif
+
+class LTC
+{
+public:
+	LTC(int CSpin);
+	LTC(int CSpin, int SDOpin);
+    LTC(int CSpin, int SDOpin, int F0pin);
+    long readValue(int channel); // renvoie la valeur du channel en cours
+
+    #ifdef ARDUINO
+    void startTimer(int frequency);
+    #endif
+
+private:
+    int selectPin,pinConv;
+    int tableChanel[16]{0,8,1,9,2,10,3,11,4,12,5,13,6,14,7,15}; // tableau des Pins
+};
+
+
+
+#endif /* LTC2439_hpp */

lib/MesureADC/MesureADC.cpp

@@ -0,0 +1,101 @@
+//
+//  LTC2439.cpp
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#include "MesureADC.h"
+
+
+MesureADC::MesureADC(int vref,int maxval,int res_mesure,int v_alim, int beta, int r_therm ){
+    
+    vreference = vref; // tension de référence
+    maximumval = maxval;  // valeur max de l'ADC
+    res_courant = res_mesure; // resistence de mesure de courant
+    tension_alim = v_alim; // tension de l'alimentation
+    beta_therm = beta; // beta des thermitance 
+    res_therm = r_therm; // résistance des termistance
+}
+
+float * MesureADC::ReadTemp(int adcCS){
+    mesureV(adcCS);
+    i1 = mesureI(tableV1); // mesure des courant
+    i2 = mesureI(tableV2);
+    temp(); // mesure de la température
+    for (int i = 0; i < 8; i++) {
+        out[i] = T1[i];
+    }
+    int j = 8;
+    for (int i = 0; i < 8; i++) {
+        out[j] = T2[i];
+        j++;
+    }
+    return out;
+}
+void MesureADC::mesureV(int CS){
+    LTC adc(CS); // création de l'objet
+    long valeur;
+    float val;
+  
+    for(int i = 0; i < 16; i++){ // mesure de chaque channel et convesion en Volt
+        valeur = adc.readValue(i);
+        val = ((valeur * vreference) / maximumval); // conversion en volt
+        val = val + vreference; // ramène la valeur avec la tension de référence ( la tension centre est Vref donc on a des tension négative)
+        if(i < 8 ){
+            tableV1[i] = val;
+        }
+        else{
+            tableV2[i - 8] = val;
+        }
+    }
+}
+
+float MesureADC::mesureI(float *table){ // retourne la valeur du courant en mA
+    return (table[0]/res_courant);
+}
+
+void MesureADC::volt(){ // mesure la tention des thermistances
+    
+    for (int j = 1; j < 7; ++j) // fait la mesure de la résistance 1 à 6
+    {
+        tableVR1[j] = tableV1[j +1] - tableV1[j] ;
+    }
+    tableVR1[0] = tableV1[1] - tableV1[0]; // fait la mesure de la résistance 0
+    tableVR1[7] = tension_alim - tableV1[7] ; // fait la mesure de la résistance 7
+  
+    for (int j = 1; j < 7; ++j) // fait la mesure de la résistance 1 à 6
+    {
+        tableVR2[j] = tableV2[j +1] - tableV2[j] ;
+    }
+    tableVR2[0] = tableV2[1] - tableV2[0]; // fait la mesure de la résistance 0
+    tableVR2[7] = tension_alim - tableV2[7] ; // fait la mesure de la résistance 7
+    
+    
+}
+
+void MesureADC::temp(){  // calcul de la température
+    res();
+    for (int j = 0; j < 8; ++j) // utilise la formule de calcul pour calculer les 8 valeur de températures
+    {
+        T1[j] = ((298.15*beta_therm)/(beta_therm+298.15*log(tableR1[j]/res_therm)))- 273.15;
+    }
+    for (int j = 0; j < 8; ++j) // utilise la formule de calcul pour calculer les 8 valeur de températures
+    {
+
+        T2[j] = ((298.15*beta_therm)/(beta_therm+298.15*log(tableR2[j]/res_therm)))- 273.15;
+    }
+}
+
+void MesureADC::res(){ // calcul la valeur de la resistance
+    volt(); // mesure de la tention des thermistances
+    for (int j = 0; j < 8; ++j) // fait une loi d'Ohm pour calculer les 8 valeur des résistance
+    {
+        tableR1[j] = tableVR1[j] / i1;
+    }
+    for (int j = 0; j < 8; ++j) // fait une loi d'Ohm pour calculer les 8 valeur des résistance
+    {
+        tableR2[j] = tableVR2[j] / i2;
+    }
+}

lib/MesureADC/MesureADC.h

@@ -0,0 +1,63 @@
+//
+//  MesureADC.h
+//  libLTC
+//
+//  Created by Tim THUREL on 04/03/2020.
+//  Copyright © 2020 Tim THUREL. All rights reserved.
+//
+
+#ifndef MesureADC_h
+#define MesureADC_h
+
+#include <stdint.h>
+#include <Arduino.h>
+#include "LTC2439.h"
+
+#define DEBUG
+
+
+
+
+class MesureADC
+{
+public:
+	MesureADC(int vref,int maxval,int res_mesure,int v_alim, int beta, int r_therm );
+    
+	float * ReadTemp(int adcCS); // renvoie l'adresse d'un tableau de température 
+    // !!! Attention !!! bien vider le tableau dans un autre tableau si vous utilisez plusieurs ADC.
+    
+private:
+    float mesureI(float *table);
+    void temp();
+    void res();
+    void volt();
+    void mesureV(int CS);
+    
+    int vreference;
+    int maximumval;
+    int res_courant;
+    int tention_alim;
+    int beta_therm;
+    int res_therm;
+    
+    float i1;
+    float i2;
+    
+    float tableV1[8];
+    float tableV2[8];
+
+    float tableVR1[8];
+    float tableVR2[8];
+
+    float tableR1[8];
+    float tableR2[8];
+
+    float T1[8];
+    float T2[8];
+    
+    float out[16];
+};
+
+
+
+#endif /* MesureADC.h */

lib/MesureADC/example/ReadADC/ReadADC.ino

@@ -0,0 +1,44 @@
+#include "MesureADC.h"
+
+#define vref 1650
+#define maxval 32766
+#define res_mesure 1000 // valeur de la résistance de mesure de courant
+#define v_alim 3300 // Tention d'alim en mV
+#define beta 3380 // Beta de la thermistance
+#define r_therm 10000 // valeur de la thermistance a 25°C
+
+MesureADC LTCMes(vref,maxval,res_mesure,v_alim,beta,r_therm);
+
+void setup() {
+  Serial.begin(115200);
+}
+
+void loop() {
+  float *pointtemp = LTCMes.ReadTemp(10);
+  float temp[16];
+  float temp1[16];
+  for(int i = 0; i < 16;i++){
+    temp[i] = pointtemp[i];
+  }
+  pointtemp = LTCMes.ReadTemp(9);
+  for(int i = 0; i < 16;i++){
+    temp1[i] = pointtemp[i];
+  }
+  for(int j = 0; j < 16; j++){
+    Serial.print("T");
+    Serial.print(j+1);
+    Serial.print(" = ");
+    Serial.print(temp[j]);
+    Serial.print(" C ");
+  }
+  Serial.println("");
+  for(int j = 0; j < 16; j++){
+    Serial.print("T");
+    Serial.print(j+17);
+    Serial.print(" = ");
+    Serial.print(temp1[j]);
+    Serial.print(" C ");
+  }
+  Serial.println("");
+  Serial.println("");
+}

lib/MesureADC/keywords.txt

@@ -0,0 +1,23 @@
+#######################################
+# Syntax Coloring Map LTC2439
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+MesureADC.h	KEYWORD1
+LTC2439	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+LTC	KEYWORD2
+readValue	KEYWORD2
+startTimer	KEYWORD2
+MesureADC	KEYWORD2
+ReadTemp	KEYWORD2
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+