il suffit de faire un copier coller et de compiler puis d'ouvrir le moniteur série à 115200 bauds...
sinon pour votre code il suffit de mettre la classe String, un truc comme cela devrait fonctionner
fichier v.h
#ifndef _PIN_
#define _PIN_
#define ADC_SCALE 1023.0
#define VREF 1.7
#define DEFAULT_FREQUENCY 50
class InOut {
private:
byte pinin;
byte pinout;
bool state;
float u;
const int Mv0 = 20;
int prev; //=0;
int prior; //=0;
bool activ; //=true;
int zero; // = 512;
float sensitivity; // =0.0018;
uint8_t pin;
int lastvalue; //=0;
String name;
public:
InOut(byte pinin, byte pinout);
~InOut();
void init();
void ON();
void OFF();
bool Status();
int GetVolt();
float calibrate();
void setZeroPoint(int _zero);
void setSensitivity(float sens);
void setPrior(int Prior);
void setPrev(int Prev);
void setActiv(bool Activ);
void setName(String _name);
int getPrior();
int getPrev();
bool getActiv();
float getVoltageDC();
float getVoltageAC(uint16_t frequency = 50);
String GetName();
};
#endif
fichier v.cpp
#include <Arduino.h>
#include "v.h"
InOut::InOut(byte in, byte out) : pinin(in), pinout(out) {}
InOut::~InOut() {Serial.print("destructor pour "); Serial.println(name);}
void InOut::init() {
pinMode(pinout, OUTPUT);
pinMode(pinin, INPUT);
OFF();
prev = 0;
prior = 0;
activ = true;
zero = 512;
sensitivity = 0.0018;
lastvalue = 0;
name = "";
}
void InOut::ON() {
digitalWrite(pinout, LOW);
}
void InOut::OFF() {
digitalWrite(pinout, HIGH);
}
bool InOut::Status() { //return false if activated and HIGH or true of not activated
state = digitalRead(pinout);
return (state == HIGH) ? true : false;
}
int InOut::GetVolt() {
u = getVoltageAC();
u = u - 10; //security offset, sensor calibrated accordingly
if (u < Mv0) {
u = 0;
}
if (u < lastvalue - 2 || u > lastvalue + 2) lastvalue = u;
return int(lastvalue);
}
float InOut::calibrate() {
uint16_t acc = 0;
for (int i = 0; i < 10; i++) {
acc += analogRead(pin);
}
zero = acc / 10;
return zero;
}
void InOut::setZeroPoint(int _zero) {
zero = _zero;
}
void InOut::setSensitivity(float sens) {
sensitivity = sens;
}
void InOut::setPrior(int Prior) {
prior = Prior;
}
void InOut::setPrev(int Prev) {
prev = Prev;
}
void InOut::setActiv(bool Activ) {
activ = Activ;
}
void InOut::setName(String _name) {
name = _name;
}
int InOut::getPrior() {
return prior;
}
int InOut::getPrev() {
return prev;
}
bool InOut::getActiv() {
return activ;
}
float InOut::getVoltageDC() {
int16_t acc = 0;
for (int i = 0; i < 10; i++) {
acc += analogRead(pin) - zero;
}
float V = (float)acc / 10.0 / ADC_SCALE * VREF / sensitivity;
return V;
}
float InOut::getVoltageAC(uint16_t frequency) {
uint32_t period = 1000000 / frequency;
uint32_t t_start = micros();
uint32_t Vsum = 0, measurements_count = 0;
int32_t Vnow;
while (micros() - t_start < period) {
Vnow = analogRead(pinin) - zero;
Vsum += Vnow * Vnow;
measurements_count++;
}
float Vrms = sqrt(Vsum / measurements_count) / ADC_SCALE * VREF / sensitivity;
return Vrms;
}
String InOut::GetName() {
return String(name);
}
J'ai rajouté le destructeur pour qu'on puisse voir quand une instance disparait.
fichier .ino principal
#include "v.h"
InOut inoutG(2, 3); // globale
String leNomEst;
void setup() {
InOut inoutL(4, 5); // locale
Serial.begin(115200); Serial.println();
inoutG.init();
inoutL.init();
inoutG.setName(String("Globale"));
inoutL.setName(String("Locale"));
// on va bien chercher le nom
leNomEst = inoutG.GetName();
Serial.print("Le nom obtenu est ["); Serial.print(leNomEst);
Serial.print("] qui est bien le même que -> "); Serial.println(inoutG.GetName());
Serial.println();
// si on modifie la copie de la String ça ne change bien sûr pas dans l'instance
leNomEst = "coucou c'est nous";
Serial.print("Le nom modifié est ["); Serial.print(leNomEst);
Serial.print("] qui est différent de "); Serial.println(inoutG.GetName());
Serial.println();
// et l'autre instance a bien un autre nom
Serial.print("L'instance locale s'appelle bien différement -> "); Serial.println(inoutL.GetName());
Serial.println();
// et quand le setup va se terminer, le destruceur de inoutL va être appelé
Serial.println("L'instance locale va disparaître et son destructeur sera appelé. ");
}
void loop() {
Serial.println();
Serial.print("L'instance globale existe toujours -> "); Serial.println(inoutG.GetName());
while (true) yield();
}
Si vous faites tourner le code et ouvrez la console série à 115200 bauds vous verrez
Le nom obtenu est [Globale] qui est bien le même que -> Globale
Le nom modifié est [coucou c'est nous] qui est différent de Globale
L'instance locale s'appelle bien différement -> Locale
L'instance locale va disparaître et son destructeur sera appelé.
destructor pour Locale
L'instance globale existe toujours -> Globale
ça a l'air de fonctionner, non ?
la fonction membre
String InOut::GetName() {
return String(name);
}
va retourner une instance nouvelle de la classe String, indépendante de la variable d'instance.
(mais pas super d'utiliser la classe String).
