Classi e oggetti: quanti e quali tipi di file sono effettivamente necessari per usarli?

Non ho precedenti esperienze con C ++ o C, ma so programmare C # e sto imparando Arduino. Voglio solo organizzare i miei schizzi e sono abbastanza a mio agio con il linguaggio Arduino anche con i suoi limiti, ma mi piacerebbe davvero avere un approccio orientato agli oggetti per la mia programmazione Arduino.

Quindi ho visto che puoi organizzare i seguenti modi (non elenco esaustivo) per organizzare il codice:

1. Un singolo file .ino;
2. Più file .ino nella stessa cartella (ciò che l'IDE chiama e visualizza come "tab");
3. Un file .ino con un file .h e .cpp incluso nella stessa cartella;
4. Come sopra, ma i file sono una libreria installata nella cartella del programma Arduino.

Ho anche sentito parlare dei seguenti modi, ma non li ho ancora fatti funzionare:

• Dichiarare una classe in stile C ++ nello stesso singolo file .ino (ne hai sentito parlare, ma non l'hai mai visto funzionare - è persino possibile?);
• [approccio preferito] Incluso un file .cpp in cui viene dichiarata una classe, ma senza utilizzare un file .h (piacerebbe questo approccio, dovrebbe funzionare?);

Nota che voglio solo usare le classi in modo che il codice sia più partizionato, le mie applicazioni dovrebbero essere molto semplici, coinvolgendo principalmente solo pulsanti, led e cicalini.

Come l'IDE organizza le cose

Per prima cosa, ecco come l'IDE organizza il tuo "schizzo":

• Il .inofile principale è lo stesso nome della cartella in cui si trova. Quindi, per foobar.inonella foobarcartella - il file principale è foobar.ino.
• Tutti gli altri .inofile in quella cartella vengono concatenati insieme, in ordine alfabetico, alla fine del file principale (indipendentemente da dove si trova il file principale, in ordine alfabetico).
• Questo file concatenato diventa un .cppfile (ad es. foobar.cpp) - viene inserito in una cartella di compilazione temporanea.
• Il preprocessore "utile" genera prototipi di funzioni per le funzioni che trova in quel file.
• Il file principale è sottoposto a scansione per le #include <libraryname>direttive. Questo innesca l'IDE per copiare anche tutti i file rilevanti da ciascuna libreria (menzionata) nella cartella temporanea e generare istruzioni per compilarli.
• Eventuali .c, .cppo .asmfile nella cartella bozza vengono aggiunti al processo di compilazione come unità di compilazione distinte (che è, sono compilati nel modo usuale come file separati)
• Tutti i .hfile vengono anche copiati nella cartella di compilazione temporanea, quindi possono essere indicati dai file .c o .cpp.
• Il compilatore aggiunge ai file standard del processo di compilazione (come main.cpp)
• Il processo di compilazione quindi compila tutti i file sopra in file oggetto.
• Se la fase di compilazione ha esito positivo, vengono collegati tra loro con le librerie standard AVR (ad es. Dandoti strcpyecc.)

Un effetto collaterale di tutto ciò è che puoi considerare lo schizzo principale (i file .ino) come C ++ a tutti gli effetti. La generazione del prototipo di funzione, tuttavia, può portare a oscuri messaggi di errore se non si presta attenzione.

Evitare le stranezze del pre-processore

Il modo più semplice per evitare queste idiosincrasie è lasciare vuoto lo schizzo principale (e non utilizzare altri .inofile). Quindi crea un'altra scheda (un .cppfile) e inserisci le tue cose in questo modo:

#include <Arduino.h>

// put your sketch here ...

void setup ()
  {

  }  // end of setup

void loop ()
  {

  }  // end of loop

Si noti che è necessario includere Arduino.h. L'IDE lo fa automaticamente per lo schizzo principale, ma per altre unità di compilazione, devi farlo. Altrimenti non conoscerà cose come String, i registri hardware, ecc.

Evitare il paradigma di installazione / principale

Non devi correre con il concetto di setup / loop. Ad esempio, il tuo file .cpp può essere:

#include <Arduino.h>

int main ()
  {
  init ();  // initialize timers
  Serial.begin (115200);
  Serial.println ("Hello, world");
  Serial.flush (); // let serial printing finish
  }  // end of main

Forza l'inclusione della libreria

Se si esegue con il concetto di "schizzo vuoto" è comunque necessario includere le librerie utilizzate altrove nel progetto, ad esempio nel .inofile principale :

#include <Wire.h>
#include <SPI.h>
#include <EEPROM.h>

Questo perché l'IDE esegue la scansione del file principale solo per l'utilizzo della libreria. In effetti è possibile considerare il file principale come un file di "progetto" che nomina quali librerie esterne sono in uso.

Problemi di denominazione

• Non nominare il tuo schizzo principale "main.cpp" - l'IDE include il proprio main.cpp, quindi avrai un duplicato se lo fai.

• Non nominare il tuo file .cpp con lo stesso nome del tuo file .ino principale. Poiché il file .ino diventa effettivamente un file .cpp, anche questo ti darebbe uno scontro di nomi.

Dichiarare una classe in stile C ++ nello stesso singolo file .ino (ne hai sentito parlare, ma non l'hai mai visto funzionare - è persino possibile?);

Sì, questo viene compilato OK:

class foo {
  public:
};

foo bar;

void setup () { }
void loop () { }

Tuttavia, probabilmente è meglio seguire la normale pratica: inserire le dichiarazioni in .hfile e le definizioni (implementazioni) in .cpp(o .c) file.

Perché "probabilmente"?

Come mostra il mio esempio, puoi mettere tutto in un unico file. Per progetti più grandi è meglio essere più organizzati. Alla fine si sale sul palco in un progetto di medie e grandi dimensioni in cui si desidera separare le cose in "scatole nere", ovvero una classe che fa una cosa, la fa bene, viene testata ed è indipendente ( per quanto possibile).

Se questa classe viene quindi utilizzata in più altri file nel progetto, è qui .hche .cppentrano in gioco i file separati e i file.

• Il .hfile dichiara la classe, ovvero fornisce dettagli sufficienti per consentire ad altri file di sapere cosa fa, quali funzioni ha e come vengono chiamati.

• Il .cppfile definisce (implementa) la classe, ovvero fornisce effettivamente le funzioni e i membri statici della classe che fanno sì che la classe faccia il suo lavoro. Dal momento che si desidera implementarlo solo una volta, questo è in un file separato.

• Il .hfile è ciò che viene incluso in altri file. Il .cppfile viene compilato una volta dall'IDE per implementare le funzioni di classe.

biblioteche

Se segui questo paradigma, allora sei pronto a spostare l'intera classe (i file .he .cpp) in una libreria molto facilmente. Quindi può essere condiviso tra più progetti. Tutto ciò che serve è creare una cartella (ad es. myLibrary) E inserire i file .he .cpp(ad es. myLibrary.hE myLibrary.cpp) e quindi inserire questa cartella nella librariescartella nella cartella in cui sono conservati gli schizzi (la cartella dello sketchbook).

Riavvia l'IDE e ora conosce questa libreria. Questo è davvero banalmente semplice e ora puoi condividere questa libreria su più progetti. Lo faccio molto.

Un po 'più di dettagli qui .

Il mio consiglio è di attenersi al tipico modo C ++ di fare le cose: interfaccia separata e implementazione in file .h e .cpp per ogni classe.

Ci sono alcune catture:

• hai bisogno di almeno un file .ino - Uso un link simbolico al file .cpp dove istanzio le classi.
• è necessario fornire i callback previsti dall'ambiente Arduino (setu, loop, ecc.)
• in alcuni casi rimarrai sorpreso dalle cose strane non standard che differenziano l'IDE di Arduino da uno normale, come l'inclusione automatica di alcune librerie, ma non di altre.

Oppure, potresti abbandonare l'IDE di Arduino e provare con Eclipse . Come ho già detto, alcune delle cose che dovrebbero aiutare i principianti, tendono a ostacolare gli sviluppatori più esperti.

Sto postando una risposta solo per completezza, dopo aver scoperto e testato un modo per dichiarare e implementare una classe nello stesso file .cpp, senza usare un'intestazione. Quindi, per quanto riguarda l'esatta frase della mia domanda "di quanti tipi di file ho bisogno per usare le classi", la presente risposta usa due file: uno .ino con include, setup e loop e il .cpp che contiene il tutto (piuttosto minimalista ) classe, che rappresentano i segnali di svolta di un veicolo giocattolo.

Blinker.ino

#include <TurnSignals.cpp>

TurnSignals turnSignals(2, 4, 8);

void setup() { }

void loop() {
  turnSignals.run();
}

TurnSignals.cpp

#include "Arduino.h"

class TurnSignals
{
    int 
        _left, 
        _right, 
        _buzzer;

    const int 
        amberPeriod = 300,

        beepInFrequency = 600,
        beepOutFrequency = 500,
        beepDuration = 20;    

    boolean
        lightsOn = false;

    public : TurnSignals(int leftPin, int rightPin, int buzzerPin)
    {
        _left = leftPin;
        _right = rightPin;
        _buzzer = buzzerPin;

        pinMode(_left, OUTPUT);
        pinMode(_right, OUTPUT);
        pinMode(_buzzer, OUTPUT);            
    }

    public : void run() 
    {        
        blinkAll();
    }

    void blinkAll() 
    {
        static long lastMillis = 0;
        long currentMillis = millis();
        long elapsed = currentMillis - lastMillis;
        if (elapsed > amberPeriod) {
            if (lightsOn)
                turnLightsOff();   
            else
                turnLightsOn();
            lastMillis = currentMillis;
        }
    }

    void turnLightsOn()
    {
        tone(_buzzer, beepInFrequency, beepDuration);
        digitalWrite(_left, HIGH);
        digitalWrite(_right, HIGH);
        lightsOn = true;
    }

    void turnLightsOff()
    {
        tone(_buzzer, beepOutFrequency, beepDuration);
        digitalWrite(_left, LOW);
        digitalWrite(_right, LOW);
        lightsOn = false;
    }
};