Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

#include <ELECHOUSECC1101SRCDRV.h> #include <DHT11.h> // Crea un'istanza della classe…

  1. User

    #include <ELECHOUSE_CC1101_SRC_DRV.h> #include <DHT11.h>

    // Crea un'istanza della classe DHT11 DHT11 dht11(4);

    // Pin a cui è collegato lo switch const int switchPin = A0;

    // Define stepper motor connections #define dirPin 2 #define stepPin 3

    void setup() { Serial.begin(1200); // Inizializza la comunicazione seriale a 1200 baud

    // Inizializza il modulo CC1101
    if (ELECHOUSE_cc1101.getCC1101()) {  // Controlla la connessione SPI del CC1101
        Serial.println("Connessione OK");
    } else {
        Serial.println("Errore di connessione");
    }
    
    ELECHOUSE_cc1101.Init();            // Inizializza il CC1101
    ELECHOUSE_cc1101.setCCMode(1);      // Imposta la modalità di trasmissione interna
    ELECHOUSE_cc1101.setModulation(0);  // Imposta la modulazione (0 = 2-FSK)
    ELECHOUSE_cc1101.setMHZ(433.92);    // Imposta la frequenza
    ELECHOUSE_cc1101.setSyncMode(2);    // Imposta la modalità di sincronizzazione
    ELECHOUSE_cc1101.setPA(12);         // Imposta la potenza di trasmissione
    ELECHOUSE_cc1101.setCrc(1);         // Abilita il controllo CRC
    ELECHOUSE_cc1101.setDeviation(5.157);
    ELECHOUSE_cc1101.setDRate(10.0);
    ELECHOUSE_cc1101.setChannel(0);
    ELECHOUSE_cc1101.setPRE(1);
    ELECHOUSE_cc1101.setFEC(0);
    
    pinMode(switchPin, INPUT); // Imposta il pin dello switch come input
    
    // Imposta i pin del motore passo-passo come output
    pinMode(stepPin, OUTPUT);
    pinMode(dirPin, OUTPUT);
    
    // Imposta la direzione di rotazione del motore: HIGH = CW, LOW = CCW
    digitalWrite(dirPin, HIGH);
    
    Serial.println("Modalità Trasmissione");
    

    }

    void loop() { // Tenta di leggere i valori di temperatura e umidità dal sensore DHT11 int temperatura = dht11.readTemperature(); int umidita = dht11.readHumidity();

    // Leggi lo stato dello switch
    int switchState = analogRead(switchPin);  // Legge il valore analogico dello switch
    String switchMessage;
    
    // Determina il messaggio da inviare e controlla il motore in base allo stato dello switch
    if (switchState < 512) { // Supponendo che il valore sia basso quando chiuso
        switchMessage = "TR 1";  // Lo switch è chiuso
        Serial.println("Switch chiuso, avvio del motore...");
    
        // Fa girare il motore passo-passo
        for (int i = 0; i < 200; i++) { // Esegue 200 passi (equivalente a un giro completo per un motore 1.8° per passo)
            digitalWrite(stepPin, HIGH);
            delayMicroseconds(200);  // Delay per regolare la velocità del motore
            digitalWrite(stepPin, LOW);
            delayMicroseconds(200);  // Delay per regolare la velocità del motore
        }
    
    } else {
        switchMessage = "TR 0";  // Lo switch è aperto
        Serial.println("Switch aperto, motore fermo.");
    }
    
    // Controlla il risultato della lettura del sensore DHT11
    if (temperatura != DHT11::ERROR_CHECKSUM && temperatura != DHT11::ERROR_TIMEOUT &&
        umidita != DHT11::ERROR_CHECKSUM && umidita != DHT11::ERROR_TIMEOUT) {
        // Stampa i valori di temperatura e umidità sul monitor seriale
        Serial.print("Temperatura: ");
        Serial.print(temperatura);
        Serial.println(" °C");
    
        Serial.print("Umidità: ");
        Serial.print(umidita);
        Serial.println(" %");
    
        // Stampa lo stato dello switch
        Serial.println("Stato dello switch: " + switchMessage);
    
        // Crea una stringa da inviare via radio
        char datiDaInviare[50];
        snprintf(datiDaInviare, sizeof(datiDaInviare), "Temp: %d C, Umidità: %d %%, %s", temperatura, umidita, switchMessage.c_str());
    
        // Trasmetti i dati via CC1101
        ELECHOUSE_cc1101.SendData(datiDaInviare, sizeof(datiDaInviare));
    
    } else {
        // Se c'è un errore nella lettura del sensore DHT11, stampa il messaggio di errore
        if (temperatura == DHT11::ERROR_CHECKSUM || temperatura == DHT11::ERROR_TIMEOUT) {
            Serial.println(DHT11::getErrorString(temperatura));
        }
        if (umidita == DHT11::ERROR_CHECKSUM || umidita == DHT11::ERROR_TIMEOUT) {
            Serial.println(DHT11::getErrorString(umidita));
        }
    }
    
    // Attendi 3 secondi prima di eseguire nuovamente il ciclo
    delay(3000);
    

    } il motore deve girare una volta avviato finche tr=0

  2. Assistant

    Certo! Se desideri che il motore passo-passo giri continuamente una volta avviato (quando TR=1) e si fermi quando TR=0, è necessario modificare il tuo sketch Arduino per gestire lo stato del motore in modo continuo, piuttosto che eseguire solo un numero fisso di passi ogni ciclo.

    Problema Attuale

    Nel tuo codice attuale, il motore effettua 200 passi ogni volta che lo switch è chiuso (switchState < 512). Tuttavia, questo provoca un movimento intermittente ogni 3 secondi, piuttosto che un funzionamento continuo.

    Soluzione

    Per ottenere un funzionamento continuo del motore mentre lo switch è chiuso e fermarlo quando lo switch è aperto, possiamo implementare i seguenti passaggi:

    1. Utilizzo di Variabili di Stato: Mantenere uno stato del motore (avviato o fermo) basato sullo stato dello switch.
    2. Evitare Blocchi nel Ciclo Principale: Utilizzare millis() per gestire i passi del motore senza bloccare l'esecuzione del resto del codice.
    3. Controllo Continuo dello Switch: Continuare a leggere lo stato dello switch e aggiornare lo stato del motore di conseguenza.

    Codice Modificato

    Ecco una versione modificata del tuo codice che implementa queste funzionalità:

    #include <ELECHOUSE_CC1101_SRC_DRV.h>
    #include <DHT11.h>
    
    // Crea un'istanza della classe DHT11
    DHT11 dht11(4);
    
    // Pin a cui è collegato lo switch
    const int switchPin = A0;
    
    // Define stepper motor connections
    #define dirPin 2
    #define stepPin 3
    
    // Variabili per il controllo del motore
    bool motorRunning = false;      // Stato del motore
    unsigned long previousStepTime = 0; // Tempo dell'ultimo passo
    const unsigned long stepInterval = 200; // Intervallo tra i passi in microsecondi
    
    void setup() {
        Serial.begin(1200);  // Inizializza la comunicazione seriale a 1200 baud
    
        // Inizializza il modulo CC1101
        if (ELECHOUSE_cc1101.getCC1101()) {  // Controlla la connessione SPI del CC1101
            Serial.println("Connessione OK");
        } else {
            Serial.println("Errore di connessione");
        }
    
        ELECHOUSE_cc1101.Init();            // Inizializza il CC1101
        ELECHOUSE_cc1101.setCCMode(1);      // Imposta la modalità di trasmissione interna
        ELECHOUSE_cc1101.setModulation(0);  // Imposta la modulazione (0 = 2-FSK)
        ELECHOUSE_cc1101.setMHZ(433.92);    // Imposta la frequenza
        ELECHOUSE_cc1101.setSyncMode(2);    // Imposta la modalità di sincronizzazione
        ELECHOUSE_cc1101.setPA(12);         // Imposta la potenza di trasmissione
        ELECHOUSE_cc1101.setCrc(1);         // Abilita il controllo CRC
        ELECHOUSE_cc1101.setDeviation(5.157);
        ELECHOUSE_cc1101.setDRate(10.0);
        ELECHOUSE_cc1101.setChannel(0);
        ELECHOUSE_cc1101.setPRE(1);
        ELECHOUSE_cc1101.setFEC(0);
    
        pinMode(switchPin, INPUT); // Imposta il pin dello switch come input
    
        // Imposta i pin del motore passo-passo come output
        pinMode(stepPin, OUTPUT);
        pinMode(dirPin, OUTPUT);
    
        // Imposta la direzione di rotazione del motore: HIGH = CW, LOW = CCW
        digitalWrite(dirPin, HIGH);
    
        Serial.println("Modalità Trasmissione");
    }
    
    void loop() {
        // Tenta di leggere i valori di temperatura e umidità dal sensore DHT11
        int temperatura = dht11.readTemperature();
        int umidita = dht11.readHumidity();
    
        // Leggi lo stato dello switch
        int switchState = analogRead(switchPin);  // Legge il valore analogico dello switch
        String switchMessage;
    
        // Determina lo stato del motore in base allo stato dello switch
        if (switchState < 512) { // Supponendo che il valore sia basso quando chiuso
            if (!motorRunning) {
                motorRunning = true;
                Serial.println("Switch chiuso, avvio del motore...");
            }
            switchMessage = "TR 1";  // Lo switch è chiuso
        } else {
            if (motorRunning) {
                motorRunning = false;
                Serial.println("Switch aperto, motore fermo.");
            }
            switchMessage = "TR 0";  // Lo switch è aperto
        }
    
        // Controlla il risultato della lettura del sensore DHT11
        if (temperatura != DHT11::ERROR_CHECKSUM && temperatura != DHT11::ERROR_TIMEOUT &&
            umidita != DHT11::ERROR_CHECKSUM && umidita != DHT11::ERROR_TIMEOUT) {
            // Stampa i valori di temperatura e umidità sul monitor seriale
            Serial.print("Temperatura: ");
            Serial.print(temperatura);
            Serial.println(" °C");
    
            Serial.print("Umidità: ");
            Serial.print(umidita);
            Serial.println(" %");
    
            // Stampa lo stato dello switch
            Serial.println("Stato dello switch: " + switchMessage);
    
            // Crea una stringa da inviare via radio
            char datiDaInviare[100];
            snprintf(datiDaInviare, sizeof(datiDaInviare), "Temp: %d C, Umidità: %d %%, %s", temperatura, umidita, switchMessage.c_str());
    
            // Trasmetti i dati via CC1101
            ELECHOUSE_cc1101.SendData(datiDaInviare, strlen(datiDaInviare));
    
        } else {
            // Se c'è un errore nella lettura del sensore DHT11, stampa il messaggio di errore
            if (temperatura == DHT11::ERROR_CHECKSUM || temperatura == DHT11::ERROR_TIMEOUT) {
                Serial.println(DHT11::getErrorString(temperatura));
            }
            if (umidita == DHT11::ERROR_CHECKSUM || umidita == DHT11::ERROR_TIMEOUT) {
                Serial.println(DHT11::getErrorString(umidita));
            }
        }
    
        // Controlla e gestisce i passi del motore
        if (motorRunning) {
            unsigned long currentMicros = micros();
            if (currentMicros - previousStepTime >= stepInterval) {
                previousStepTime = currentMicros;
                // Eseguire un passo
                digitalWrite(stepPin, HIGH);
                delayMicroseconds(1); // Pulse width minima
                digitalWrite(stepPin, LOW);
            }
        }
    
        // Attendi un breve periodo prima di eseguire nuovamente il ciclo
        delay(10);
    }
    

    Spiegazione delle Modifiche

    1. Variabili di Stato:

      • motorRunning: Una variabile booleana che tiene traccia se il motore deve girare.
      • previousStepTime e stepInterval: Utilizzate per gestire l'intervallo tra i passi del motore senza bloccare il ciclo principale.
    2. Gestione dello Stato dello Switch:

      if (switchState < 512) { // Switch chiuso
          if (!motorRunning) {
              motorRunning = true;
              Serial.println("Switch chiuso, avvio del motore...");
          }
          switchMessage = "TR 1"; 
      } else { // Switch aperto
          if (motorRunning) {
              motorRunning = false;
              Serial.println("Switch aperto, motore fermo.");
          }
          switchMessage = "TR 0"; 
      }
      
      • Quando il switch è chiuso (switchState < 512), imposta motorRunning a true e avvia il motore.
      • Quando il switch è aperto, imposta motorRunning a false e ferma il motore.
    3. Esecuzione Continua del Motore:

      if (motorRunning) {
          unsigned long currentMicros = micros();
          if (currentMicros - previousStepTime >= stepInterval) {
              previousStepTime = currentMicros;
              // Eseguire un passo
              digitalWrite(stepPin, HIGH);
              delayMicroseconds(1); // Pulse width minima
              digitalWrite(stepPin, LOW);
          }
      }
      
      • Se motorRunning è true, il motore esegue un passo ogni stepInterval microsecondi.
      • Questo permette al motore di girare continuamente senza bloccare l'esecuzione del resto del codice.
    4. Modifiche Minori:

      • Aumento della Dimensione dell'Array datiDaInviare: Aumentato a 100 per evitare sovrapposizioni nel buffer.
      • Utilizzo di strlen(datiDaInviare): Per assicurarsi che solo i caratteri effettivi vengano inviati via CC1101.

    Considerazioni Aggiuntive

    • Controllo della Velocità del Motore: Puoi regolare stepInterval per aumentare o diminuire la velocità di rotazione del motore. Ad esempio, diminuendo stepInterval aumenterai la velocità.

    • Accuratezza del Tempo: Utilizzare micros() aiuta ad avere un controllo più preciso rispetto a millis(), ma assicurati di non chiamare delay() con valori troppo alti poiché bloccherebbero l'esecuzione del codice.

    • Direzione del Motore: Se desideri cambiare la direzione del motore, puoi invertire il segnale su dirPin:

      digitalWrite(dirPin, LOW); // Cambia la direzione del motore
      
    • Ottimizzazione delle Comunicazioni Seriali: La trasmissione a 1200 baud è relativamente lenta. Se il tuo progetto lo permette, considera di aumentare la velocità di trasmissione (Serial.begin(9600); o superiore) per una comunicazione più efficiente.

    Risorse Utili

    • Biblioteca Stepper: Anche se stai controllando manualmente i passi, potresti considerare l'uso della biblioteca Stepper integrata in Arduino per una gestione più semplice dei motori passo-passo.
    • Documentazione CC1101: Assicurati di consultare la documentazione ufficiale del modulo CC1101 per ottimizzare le impostazioni di trasmissione in base alle tue esigenze.

    Spero che queste modifiche ti aiutino a ottenere il comportamento desiderato per il tuo motore passo-passo. Se hai ulteriori domande o necessiti di ulteriori chiarimenti, non esitare a chiedere!