Ereditare la funzione map in una classe

International Italiano Generale
1

Salve, vorrei ereditare la funzione map nella mia classe che vi posto:

#include <Arduino.h>
#include "pot.h"


int POT::read(int pin) {
  pinGlobal = pin;
  return analogRead(pinGlobal);
}

int POT::map(int Sensor, int minSensor, int maxSensor, int minValue, int maxValue) {
   return map(Sensor, minSensor, maxSensor, minValue, maxValue);
}

#include "Arduino.h"

#ifndef POT_H
#define POT_H

class POT {
public:
  int read(int pin);
  int map(int Sensor, int minSensor, int maxSensor, int minValue, int maxValue);

private:
  int pinGlobal;
  int delayGlobal;
};

#endif  // POT

#include <Arduino.h>
#include "led.h"
#include "pot.h"

int SensorValue, LedValue;

LED led;
POT pot;
void setup() {
  Serial.begin(9600);
  led.setup(9);
}

void loop() {

  SensorValue = pot.read(14);
  LedValue = pot.map(SensorValue, 0, 1023, 0, 255);
  led.write(LedValue);
  Serial.print("SensorValue = ");
  Serial.print(SensorValue);
  Serial.print(" | ");
  Serial.print("  LedValue = ");
  Serial.print(LedValue);
  Serial.println();
  delay(100);
}

Ma ho notato che non funziona e come non ricevesse nulla..

Avete l'idea perché?

Grazie mille e buona giornata.

2

E a che serve riscrivere una funzione definita nel core Arduino in una libreria?
E' come se tu volessi riscrivere la funzione digitalWrite() o digitalRead() invece di quelle incluse.

Ha senso se ci sono particolari ragioni... che ne so ad esempio map() lavora con tipo dati long e magari ne vuoi fare una analoga per i float o cose di questo genere... (anche se ci sono tecniche migliori).

Comunque la funzione è definita in questo modo, ma se usi il tipo dati int come sembrerebbe tua intenzione, ci saranno molti casi in cui non ti funziona come ti aspetti a causa della dimensione del tipo dati.

Un int nella maggior parte dei core Arduino è a 16 bit, quindi con valori da -32768 a 32767; è molto probabile che una moltiplicazione di int superi questi valori.

long map(long x, long in_min, long in_max, long out_min, long out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
3

Questa è un loop infinito, stai chiamando nuovamente la funzione della classe in modo ricorsivo, non stai chiamando la funzione map() della libreria Arduino ➜ dai un altro nome alla funzione nella tua classe.

(Gli argomenti dovrebbero essere di tipo long, non int.)

4

Grazie mille ho risolto cosi:

int POT::mapped(int Sensor, unsigned long  minSensor, unsigned long  maxSensor, unsigned long  minValue, unsigned long  maxValue) {
   return map(Sensor, minSensor, maxSensor, minValue, maxValue);
}

int mapped(int Sensor, unsigned long  minSensor, unsigned long  maxSensor, unsigned long  minValue, unsigned long  maxValue);

e funziona. Grazie mille e buona giornata a tutti.

5

Ancora mi sfugge perché tu debba voler rimappare la funzione "map()", soprattutto in quel modo, dove non fai altro che richiamare la map standard...
Primo, anche se nella "mapped()" cambi il tipo di dato, non cambia la sostanza e quindi neanche il valore restituito, anzi potenzialmente ci possono essere problemi perché se anche hai "minSensor" definito come "unsigned long" tu poi la passi alla map() che di quel parametro fa il casting implicito a "long" quando chiami la "map()" standard.
Inoltre qui tu restituisci un valore "int", che è comunque in contrasto con i parametri dei valori minimi e massimi "out" che sono tutti "unsigned long" (il che significa che tu vuoi ottenere una mappatura verso unsigned long, non int!!)!

In sostanza, se sono letture da un sensore non penso che tu abbia realmente un "unsigned long" ma se per qualche motivo che mi sfugge hai realmente bisogno di usare "unsigned long" devi semplicemente usare tutti gli unsigned long ed evitare di usare la map() standard, direi una cosa di questo tipo:

unsigned long POT::mapped(int Sensor, unsigned long  minSensor, unsigned long  maxSensor, unsigned long  minValue, unsigned long  maxValue) {
  return (Sensor - minSensor) * (maxValue- minValue) / (maxSensor- minSensor) + minValue;
}
6

Io temo che a @gigetto1982 stia proprio sfuggendo il senso di una classe aggiungendo un inutile overhead per ottenere lo stesso risultato.

SensorValue = pot.read(14);
SensorValue = analogRead(14);

LedValue = pot.map(SensorValue, 0, 1023, 0, 255);
LedValue = map(SensorValue, 0, 1023, 0, 255);

Sono sostanzialmente equivalenti nell'uso solo che nella prima usa una classe che non apporta nessun beneficio in termini di portabilità/usabilità del codice.

Magari qualcosa del genere inizierebbe ad avere un maggior senso:


class POT {
public:
  // Costruttore della classe che inizializza le proprietà private della classe stessa
  POT(const uint8_t pin, uint32_t delay) {
     pinGlobal = pin;
     delayGlobal = delay;
  }
  uint16_t read() {
    return analogRead(pinGlobal);
  }

  long mapped(long x) {
    return map(x, 0, 1023, 0, 255);
  }

private:
  uint8_t pinGlobal;
  uint32_t delayGlobal;
};

.....

// Istanza della classe sul pin 14 e con delay 1000 ms (non usato)
POT pot(14, 1000);
....

// Uso dei metodi della classe
SensorValue = pot.read();
LedValue = pot.mapped(SensorValue);
7

grazie mille ora ho capito. ti ringrazio molto e ora studio con calma tutto il linguaggio.

buona giornata.

8

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.