Problemi con libreria "personalizzata"

Salve, sono un ragazzo di terza superiore. Per compito dovevo creare una libreria Arduino per fare una percentuale di un qualsiasi numero. Il compito generale prevedeva di simulare l’indicatore di capacità di un serbatoio sfruttando un potenziometro. Quando il valore è compreso tra un valore “massimo” è pieno, quindi il led verde (mattia) rimane acceso. Quando il valore è compreso tra un valore “minimo” è vuoto, quindi il led rosso (pasqu) lampeggia. Quando il valore è compreso tra massimo e minimo il led giallo (giovanni) si accende. Il discorso dei valori ho pensato di gestirlo in questo modo:

Rilevo un valore Max e uno Minimo

Calcolo una percentuale del valore Max (esempio 30%);

Lo sottraggo al valore Max ottenendo così il minimo di soglia del valore max (da quel valore in su sarà pieno)

Lo aggiungo al valore Min ottenendo così il massimo di soglia del valore min (da quel valore in giù sarà vuoto)

per tutti gli altri valori quindi il giallo rimane acceso.

Tutta questa situazione l’ho gestita con una concatenazione di If else.

Il mio problema consiste che non so come immettere due variabili nel metodo della libreria e come “tirar” fuori la variabile che ne risulta. Allego codici, grazie per l’aiuto

//Percentuale.h

#ifndef Percentuale_h
#define Percentuale_h

#include "Arduino.h"

class Percentuale {
	public:
		Percentuale(int perc);
		Variabile(int varia);
		void calcolo();
	private:
		int_perc;
		int_varia;
};


#endif
//Percentuale.cpp

#include "Arduinio.h"
#include "Percentuale.h"

Percentuale::Percentuale(int perc){
_perc = perc;
}

Variabile::Variabile(int varia){
_varia = varia;
}

void Percentuale::calcolo(){
int formula = _perc/100;

int valore = _varia*formula;
}
#keyword.txt 

#####################
#	Colori	    #
#####################

Percentuale KEYWORD1
calcolo KEYWORD2
//codice sketch arduino


#include <Percentuale.h> //implemento la classe

const int sensorPin = A0; //dichiaro il pin per la lettura del potenziomentro
const int mattia = 9;	//pin led verde
const int giovanni = 8;	//pin led giallo
const int pasqu = 10;	//pin led rosso
Percentuale percentuale(30);	//dichiaro il valore della percentuale, in questo caso calcolerà il 30%


int sensorValue = 0;
int sensorMin = 1023;
int sensorMax = 0;
int intervalloMax = 0;
int intervalloMin = 0;

void finito(){
  analogWrite(mattia, LOW);
  analogWrite(giovanni, LOW);
  analogWrite(pasqu, HIGH);
  delay(250);
  analogWrite(pasqu, LOW);
  delay(250);
}

//definisco il metodo che descrive il comportamento da fare quando il serbatoio è pieno
void pieno(){
  analogWrite(giovanni, LOW);
  analogWrite(pasqu, LOW);
  analogWrite(mattia, HIGH);
}

//definisco il metodo che descrive il comportamento da fare quando il serbatoio è a metà
void meta(){
  analogWrite(mattia,LOW);
  analogWrite(pasqu, LOW);
  analogWrite(giovanni, HIGH);
}


//definisco il metodo che descrive il comportamento da fare quando il serbatoio è vuoto
void setup() {
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(10, OUTPUT);
  
  while (millis() <5000){
    sensorValue = analogRead(sensorPin);
    
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }
    
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
    
  }
  
  digitalWrite(13, LOW);
}


 

void loop(){
  sensorValue = analogRead(sensorPin);
  
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
  
  sensorValue = constrain(sensorValue, 0, 255);
  
  Percentuale variabile(sensorMax);
  
/*qui dovrei immettere le due variabili dentro al metodo*/.calcolo();
  
  intervalloMax = sensorMax- /*qui dovrei immettere le variabile che mi ritorna il metodo*/;
  
  intervalloMin = sensorMin+/*qui dovrei immettere le variabile che mi ritorna il metodo*/;
  
  
  if (sensorValue >= intervalloMax) {
    pieno();
  }
    else if (sensorValue <= intervalloMin) {
    finito();
    }
      else {
        meta();
      }
}

Benvenuto. Essendo il tuo primo post, nel rispetto del regolamento, ti chiediamo cortesemente di presentarti QUI (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con attenzione il su citato REGOLAMENTO... Grazie.
Qui una serie di link utili, non inerenti al tuo problema:

Primo modifica quella bruttura, i ; punti e virgola DOPO /* */

intervalloMax = sensorMax- /*qui dovrei immettere le variabile che mi ritorna il metodo*/;

e anche i nomi dei pin, siano significativi, (e basta byte)

const byte pinVerde = 9;   // era mattia

Poi:
a) O la funzione calcolo() ritorna anche il valore oppure lei fa il calcolo, lo memorizza in una variabile membro privata delle classe e una GetValore() ritorna questo valore.

b) Per il discorso di due variabili (parametri) al metodo, non capisco la domanda, ad una funzione passi quanti parametri vuoi, in C++ anche opzionali.

in generale, una classe per un calcolo del genere mi sembra esagerato.
Un funzione che ritorna -1,0,+1 a seconda del <=min, compreso tra min e max e >=max basta e avanza
Gli passi il valore, il min, il max e lei ritorna -1, 0 oppure +1

int GetStato(int valore,int min, int max)
{ if(valore>=max) return(1);
  if(valore<=min) return(-1);
  return(0);
}
....
switch( GetStato(sensorValue,intervalloMin,intervalloMax)
{ case -1: meta();   break;
  case  0: finito(); break;
  case  1: pieno();  break;
}

è vero che una soluzione così complessa può sembrare stupida per un problema così semplice ma questo è il compito...

Fare un metodo Get l'avevo già idealizzato a pranzo, l'ho anche già implementato mentre rimango ignorante sul come immettere due variabili in un solo metodo.

se non sbaglio la sintassi corretta sarebbe variabile.metodo()

ma non so come immettere entrambi le variabili contemporaneamente... come concatenarle

Variabile::Variabile(int varia1, int varia2)
{ _varia = varia1; ... e poi boh, non sò che devi farci con 2 var
}

nel chiamante: Percentuale.Variabile(var1,var2);

aahh, per accendere/spegnere pin.... digitalWrite, NON analogWrite

La analogWrite serve per sui pin digitali ma capaci di PWM e gli devi passare un valore da 0 a 255
digitalWrite per scrivere LOW/HIGH su pin digitali

digitalRead per leggere i pin digitali e
analogRead per leggere i pin analogici

eppur io lavoro con porte analogiche. Difatto ho impostato nel codice una lettura del potenziometro su porta "A0" dandogli il valore da 0 a 255

Grazie per tutto l'aiuto

No, le porta 8,9 e 10 sono digitali. Infatti le devi impostare con pinMode
Le porte analogiche sono le A0-A5 ed in oltre sono solo in lettura.

Poi perchè vorresti usare solo le analogiche ?
Ti serve solo leggere da A0 il sensore, poi puoi usare le porte digitali.

I pin da 0 a 13 sono digitali. Quindi acceso oppure spento. Eccezione alcuni pin che sono PWM e accettano un valore 0-255. Ma sono sempre pin digitali.

Sistemato ciò ed alcuni bug minori al momento della verifica del codice mi da due errori riguardanti il chiamante, inoltre non colora nessunissima KeyWord… cito l’errore e inserisco il codice dei file interessati

Arduino:1.8.2 (Windows 7), Scheda:“Arduino/Genuino Uno”

Z:\Programmi Fatti da me\Arduino\IndicatoreVolumeAttualeSerbatoio_progetttoIVAS_\IndicatoreVolumeAttualeSerbatoio_progetttoIVAS_.ino: In function ‘void loop()’:

IndicatoreVolumeAttualeSerbatoio_progetttoIVAS_:77: error: expected unqualified-id before ‘.’ token

Percentuale.calcolo(percentuale,sensorMax);

^

IndicatoreVolumeAttualeSerbatoio_progetttoIVAS_:79: error: expected primary-expression before ‘.’ token

valore = Percentuale.getValore();

^

exit status 1
expected unqualified-id before ‘.’ token

//sketch per Arduino/Fishino

#include <Percentuale.h>

const int sensorPin = A0;
const byte ledPieno = 10;
const byte ledMeta = 9;
const byte ledVuoto = 8;
int percentuale = 30;


int sensorValue = 0;
int sensorMin = 1023;
int sensorMax = 0;
int intervalloMax = 0;
int intervalloMin = 0;
int valore = 0;

void finito(){
  analogWrite(ledPieno, LOW);
  analogWrite(ledMeta, LOW);
  analogWrite(ledVuoto, HIGH);
  delay(250);
  analogWrite(ledVuoto, LOW);
  delay(250);
}

void pieno(){
  analogWrite(ledMeta, LOW);
  analogWrite(ledVuoto, LOW);
  analogWrite(ledPieno, HIGH);
}

void meta(){
  analogWrite(ledPieno,LOW);
  analogWrite(ledVuoto, LOW);
  analogWrite(ledMeta, HIGH);
}



void setup() {
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(10, OUTPUT);
  
  while (millis() <5000){
    sensorValue = analogRead(sensorPin);
    
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }
    
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
    
  }
  
  digitalWrite(13, LOW);
}

 

void loop(){
  sensorValue = analogRead(sensorPin);
  
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
  
  sensorValue = constrain(sensorValue, 0, 255);
  
  
  Percentuale.calcolo(percentuale,sensorMax);
  
  valore = Percentuale.getValore();
  
  intervalloMax = sensorMax-valore;
  
  intervalloMin = sensorMin+valore;
  
  
  if (sensorValue >= intervalloMax) {
    pieno();
  }
    else if (sensorValue <= intervalloMin) {
    finito();
    }
      else {
        meta();
      }
}
//percentuale.h

#ifndef Percentuale_h
#define Percentuale_h


class Percentuale {
	public:
		Percentuale (int perc,int varia);
		void calcolo();
		void getValore();
	private:
		int _perc;
		int _varia;
};


#endif
//Percentuale.cpp

#include "Percentuale.h"

Percentuale::Percentuale(int perc){
_perc = perc;
_varia = varia;
}


void Percentuale::calcolo(int perc, int varia){
int formula = _perc/100;

int valore = _varia*formula;
}

void Percentuale::getValore(){
	valore = valore;
	return valore;
}
##########
#     Colori     #
##########

Percentuale KEYWORD1
calcolo KEYWORD2
getValore KEYWORD2

Del colorare non sò.

Per l'errore, usi void se non ritorni nulla, altrimenti DEVI dire che tipo di dato ritorni:

int Percentuale::getValore()
{ return valore;
}
// aggiusta il .h in modo analogo

Questo cortege il getValore(). Ma per l'errore nel chiamante di calcol()?

RIPETO:
la definizione delle funzioni membro della classe che fai in file .h DEVE essere coerente con quello che fai in .cpp
Da una parte void calcolo() e dall'altra void calcolo(int,int)
Stessa cosa per la getValore ed il costruttore Percentuale.
Dichiari una cosa e ne fai un'altra. Il compilatore non capisce più nulla.

File .cpp void Percentuale::calcolo(int perc, int varia){
quindi nel file .h void calcolo(int,int);

Inoltre, è errata la logica. Linguaggio C. Se nella calcolo() dichiari int formula e int valore, SONO variabili locali alla funzione, fa il calcolo ma alla fine del calcolo quelle variabili vengono distrutte.
DEVI dichiarare anche quelle variabili tra i membri privati della classe e nella cacolo() usarli solo e non dichiararli.

Perdonami, mi sono spiegato male. Quei problemi li avevo già individuati e riparati.

Il problema è che nel richiamare all'interno dello sketch il metodo calcolo in questo modo

Percentuale.calcolo(percentuale,sensorMax)

mi restituisce questo errore:

'Percentuale' was not declared in this scope

Come se fosse una variabile qualsiasi e non la classe

Io posso solo rispondere in base al codice che posti. Nel codice sopra il costruttore Percentuale() è diverso tra .h e .cpp

Poi mi pare che NON hai più nessuna dichiarazione di un oggetto di tipo Percentuale.
La classe si chiama Percentuale ma tu DEVI dichiarare uno o più oggetto/i di tipo Percentuale e su quelli lavorare.

Ovvero dichiari variabili di tipo int, mica lavori direttamente con la parola int.

Percentuale perc(30); // 1 o 2 parametri, da codice precedente non si capisce
...
perc.calcolo();

già testato, ma dice che ‘Percentuale’ non è un tipo

//percentuale.h

#ifndef Percentuale_h
#define Percentuale_h


class Percentuale {
	public:
		chiamante (int perc,int varia);
		int getValore( perc, varia);
	private:
		int _perc;
		int _varia;
};


#endif
//Percentuale.cpp

#include "Percentuale.h"

Percentuale::chiamante(int perc, int varia){
_perc = perc;
_varia = varia;
}

int Percentuale::getValore( perc, varia){

int formula = perc/100;

int valore = varia*formula;

	valore = valore;
	return valore;
}
//sketch per Arduino/Fishino

#include <Percentuale.h>

const int sensorPin = A0;
const byte ledPieno = 10;
const byte ledMeta = 9;
const byte ledVuoto = 8;
int percentuale = 30;

int sensorValue = 0;
int sensorMin = 1023;
int sensorMax = 0;
int intervalloMax = 0;
int intervalloMin = 0;
int valore = 0;

Percentuale chiamante(percentuale,sensorMax);

void finito(){
  analogWrite(ledPieno, LOW);
  analogWrite(ledMeta, LOW);
  analogWrite(ledVuoto, HIGH);
  delay(250);
  analogWrite(ledVuoto, LOW);
  delay(250);
}

void pieno(){
  analogWrite(ledMeta, LOW);
  analogWrite(ledVuoto, LOW);
  analogWrite(ledPieno, HIGH);
}

void meta(){
  analogWrite(ledPieno,LOW);
  analogWrite(ledVuoto, LOW);
  analogWrite(ledMeta, HIGH);
}



void setup() {

  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(10, OUTPUT);
  
  while (millis() <5000){
    sensorValue = analogRead(sensorPin);
    
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }
    
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
    
  }
  
  digitalWrite(13, LOW);
}

 

void loop(){
  sensorValue = analogRead(sensorPin);
  
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
  
  sensorValue = constrain(sensorValue, 0, 255);
  
  valore = chiamante.getValore(percentuale,sensorMax);
  
  intervalloMax = sensorMax-valore;
  
  intervalloMin = sensorMin+valore;
  
  
  if (sensorValue >= intervalloMax) {
    pieno();
  }
    else if (sensorValue <= intervalloMin) {
    finito();
    }
      else {
        meta();
      }
}

class Pippo
{ public:
Pippo(int x);
calcolo();
}
....
nel file .ino
ad inizio dichiaro oggetto di tipo Pippo
Pippo objPippo(30);
...
poi lavoro con l'oggetto objPippo