Autostat: un termostato remoto: 8 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

La domanda che probabilmente ti stai ponendo è "perché stai realizzando un altro termostato remoto?"

La risposta a questa domanda è che dovevo, e i termostati intelligenti del mercato sono troppo costosi.

Avviso equo, questa è una build "prova di concetto" che richiederebbe alcune uscite extra per controllare effettivamente il termostato, ma il nucleo è a posto e può essere modificato a seconda delle circostanze specifiche. Inoltre, questo è ancora un lavoro in corso, quindi aspettati alcuni aggiornamenti e modifiche (soprattutto al codice Matlab)

Per iniziare voglio avvertirti, ciò richiede tre programmi (uno dei quali è piuttosto costoso), alcune librerie e pacchetti di supporto per i programmi e devi farli parlare tra loro. È un mal di testa. Con quell'avvertimento fuori mano, iniziamo con i materiali.

Hardware

• arduino nano
• arduino uno (o un altro nano, ho appena usato uno perché ne avevo uno in giro)
• cavi per ponticelli assortiti, alcuni maschio/maschio e due set di tre ponticelli maschio/femmina uniti
• Ricevitore a radiofrequenza 433MHz (RF), ho usato l'MX-05V
• Trasmettitore RF 433MHz, ho usato l'MX-FS-03V
• Termometro e sensore di umidità ad alta precisione DHT11 (quello che ho usato è installato su un chip a tre poli con le resistenze richieste già installate)
• breadboard (se non vuoi saldare tutto insieme)
• un telefono con GPS (iPhone 8 in questo caso, ma ho usato anche un Galaxy S8)
• Contenitore stampato in 3D (non proprio necessario, qualsiasi contenitore funzionerà o nessuno)

Software

• Matlab di MathWorks (ho l'edizione 2018a, ma ho usato anche le edizioni 2017a-b)
• Matlab mobile installato sul tuo telefono
• pacchetto di supporto arduino per Matlab
• Pacchetto sensore iPhone per Matlab
• arduino IDE
• Pacchetti e librerie di supporto per RadioHead dell'IDE di Arduino
• Libreria DHT11 per Arduino IDE
• python 3.7 (assicurati che sia installata la libreria pyserial o la libreria seriale, che dovrebbe essere per la versione 3.4 o successiva)

Passaggio 1: mettere tutto insieme

Prima di tutto ti suggerirei di fare alcuni tutorial su Arduino che trattano i trasmettitori RF solo per assicurarti che le tue parti funzionino e che il cablaggio sia corretto. Ci sono molti esempi disponibili, con il codice incluso (per quelli di noi che sanno poco o nulla di C e C++).

Segui gli schemi elettrici qui sotto per montare l'arduino e i sensori. Una cosa da tenere a mente durante il cablaggio degli arduino è che le porte dati che ho usato non sono necessarie ma consigliate.

SE decidi di cambiare le porte dati che usi, devi solo definire i pin nel tuo codice. Personalmente, penso che sia più facile attenersi alle porte predefinite riconosciute dalle librerie arduino.

E solo per essere chiari, il nano e uno sono intercambiabili, ma ho usato il nano per il lato trasmettitore del progetto per ridurre le dimensioni del monitor della temperatura.

Nota a margine: l'aggeggio verde che tiene il nano è il contenitore stampato in 3D.

Passaggio 2: ricevitore

Passaggio 3: trasmettitore

Passaggio 4: il codice

Una volta terminato il cablaggio, devi far funzionare tutti i programmi e installare le librerie (se non lo hai già fatto), presumo che tu lo abbia, devi avviare Matlab ed eseguire il pacchetto di supporto per iPhone. Sia il tuo telefono che Matlab devono essere sulla stessa rete wifi a questo punto.

Nella finestra di comando di Matlab scrivi:

connettore acceso

Questo ti chiederà di inserire una password di cinque cifre che utilizzerai per connetterti sul tuo iPhone. Assicurati di ricordare la password. Dopo aver inserito la password Matlab visualizzerà alcune informazioni, compreso il tuo indirizzo IP. Usalo nel passaggio successivo, che deriva dalle istruzioni del menu di aiuto "Introduzione ai sensori" in Matlab mobile.

• Segui questi passaggi per inviare i dati del sensore a MathWorks Cloud o a un computer:
• Se stai inviando i dati del sensore a un computer e se non è già installato, scarica e installa il pacchetto di supporto MATLAB per i sensori Apple iOS in MATLAB.
• Connetti MATLAB Mobile a MathWorks Cloud o a un computer utilizzando Impostazioni.
• Crea un oggetto mobiledev in MATLAB (sul tuo computer), ad esempio: >> m = mobiledev
• Seleziona uno o più sensori e tocca Avvia.

Segui questi passaggi per registrare i dati del sensore localmente sul tuo dispositivo:

• Nella schermata Sensori, seleziona i sensori da cui desideri raccogliere i dati.
• Seleziona Registro.
• Tocca il pulsante Avvia.
• Quando hai finito di raccogliere i dati, tocca il pulsante Interrompi.
• Nel pop-up, inserisci il nome del log del sensore.
• Ripetere i passaggi 1-5 se necessario.

Si farà riferimento a questa sezione nella Parte 4, quindi non è ancora necessario iniziare effettivamente a raccogliere dati. Tieni il telefono a portata di mano e Matlab mobile pronto.

Ora devi creare una cartella da qualche parte nel tuo computer per ospitare i file di codice Matlab. Avrai quattro file separati, due per le funzioni in background (file.m) e un file di codice Matlab per la GUI (.mlapp),.

Il primo è il calcolo della massa per l'aria nella tua casa (questo consente a Matlab di sapere quanto tempo ci vuole per riscaldare/raffreddare la tua casa)

funzione [Mass]= CalcMass(T_ins, P_out, Chng_dir)

runCalc=0; Tmp_start=T_ins; time_start=orologio; time_end = 0 mentre runCalc <= 1 if T_ins==(Tmp_start+(7*Chng_dir)) time_end=clock; PwrCntr = 0; runCalc=0; else PwrCntr = P_out; runCalc=runCalc+0.1 end end time_diag= time_end-time_start Mass=(P_out*time_diag)/7.035

E il secondo:

function [timestamps, pwr_usage]= dist_cntrl(Lat_in, Lon_in, P_out, r_pref, speed, T_pref, mass)

AutoStat = 1; io = 1; mentre AutoStat == 1 time_start=clock; m = mobiledev; t = csvread('values.csv', 0, 1); t= t(i); timestamp= [0, 0, 0, 0, 0, 0]; pwr_usage = 0; io = io+1; formato lungo g; Formula %haversine per calcolare la distanza in base a latitudine e %longintudine a_hav=(sind((m. Latitude-Lat_in)./2)).^2+cosd(Lat_in).*cosd(m.latitude).*(sind((m. Longitudine-Lon_in)./2)).^2; c_hav= 2.*atan2d(sqrt(a_hav), sqrt(1-a_hav)); d_hav= 6371.*c_hav; Dist=d_hav.*1000; % stima il tuo tempo per restituire time_rtn=(Dist-r_pref)./speed; %calcola l'impostazione del termostato necessaria in base alla potenza in uscita del %condizionatore d'aria e alla massa d'aria della casa. calcTmp_set=((-1.*P_out.*time_rtn)./(mass.*(1.005)))+T_pref; % determina se l'impostazione corrente del termostato deve essere modificata se round(calcTmp_set) ~= round(t) timeACon = clock; PwrCntr = P_out; timeACon= timeACon + clock-time_start; costo=P_out*timeACon*tasso; else PwrCntr = 0 end timestamps(end+1, [1:6]) = clock; pwr_usage(end+1, 1)= PwrCntr; pausa(5) fine fine

Entrambi questi file sono funzioni Matlab. Non avrai bisogno di accedervi a meno che tu non abbia intenzione di modificarli per esigenze specifiche, dal momento che li chiamerai dalla GUI. Salva entrambi i file separatamente, il primo come CalcMass.m e il secondo come dist_cntrl.m, questi saranno i nomi che il codice della GUI usa per chiamare le funzioni, quindi a meno che tu non voglia modificare il resto del codice qui sotto, mantieni la convenzione di denominazione.

Prima di entrare nel codice della GUI, devi aprire il designer di app per Matlab, che puoi aprire navigando nella barra dei menu di Matlab, o con il mio metodo preferito che sta inserendo il seguente comando nella finestra di comando di Matlab:

appdesigner

Una volta aperto il designer dell'app, apri un nuovo file dell'app (.mlapp) ed elimina tutto il codice predefinito dalla finestra del codice. Quindi sostituiscilo tutto con quanto segue e premi il pulsante Esegui.

classdef Control_1 < matlab.apps. AppBase % Proprietà che corrispondono alle proprietà dei componenti dell'app (Access = public) UIFigure matlab.ui. Figure TabGroup matlab.ui.container. TabGroup SetupTab matlab.ui.container. Tab RunDiagnosticButton matlab.ui.control. Pulsante EnergyEfficiencyRatingEditFieldLabel matlab.ui.control. Label EnergyEfficiencyRatingEditField matlab.ui.control. NumericEditField PowerOutputRatingEditFieldLabel matlab.ui.control. Label PowerOutputRatingEditField matlab.ui.control. NumericEditMatlab.ui.control. NumericEditControlField AvgLocalSpeedcontrolField AvgLocalSpeedlabui. matlab.ui.control. Label DDFH matlab.ui.control. NumericEditField TemperatureDirectionSwitchLabel matlab.ui.control. Label TemperatureDirectionSwitch matlab.ui.control. Switch TempSettingsTab matlab.ui.container. Tab Temperature1SpinnerLabel matlab.ui.control. Label temperatura.1Spinner ui.control. Spinner Temperature2SpinnerLabel matlab.ui.cont rol. Label Temperature2Spinner matlab.ui.control. Spinner Switch matlab.ui.control. Switch EditFieldLabel matlab.ui.control. Label tempnow matlab.ui.control. NumericEditField GaugeLabel matlab.ui.control. Label Gauge matlab.ui.control. Gauge SavingsTab matlab.ui.container. Tab UIAxes matlab.ui.control. UIAxes ThisMonthCostEditFieldLabel matlab.ui.control. Label ThisMonthCostEditField matlab.ui.control. NumericEditField TotalSavingsEditFieldLabel matlab.ui.control. EditFielEditField TotalSaving.

metodi (Accesso = privato)

% Valore modificato funzione: tempnow

function tempnowValueChanged(app, event) temp = app.tempnow. Value; temp=randi([60, 90], 1, 50) app. Gauge. Value = 0 for i = length(temp) app. Gauge. Value= temp(i) pause(1) end end

% Valore modificato funzione: TemperatureDirectionSwitch

function TemperatureDirectionSwitchValueChanged(app, event) way = app. TemperatureDirectionSwitch. Value; way= uint8(way) way = length(way) if way == 4 Chng_dir = -1; altrimenti Chng_dir = 1; fine Chng_dir; fine

% Valore funzione modificata: DDFH

function DDFHValueChanged(app, event) r_pref = app. DDFH. Value; fine

% Valore modificato funzione: AvgLocalSpeedEditField

function AvgLocalSpeedEditFieldValueChanged(app, event) speed = app. AvgLocalSpeedEditField. Value; fine

% Valore modificato funzione: PowerOutputRatingEditField

function PowerOutputRatingEditFieldValueChanged(app, event) value = app. PowerOutputRatingEditField. Value; fine

% Valore funzione modificata: EnergyEfficiencyRatingEditField

function EnergyEfficiencyRatingEditFieldValueChanged(app, event) value = app. EnergyEfficiencyRatingEditField. Value; fine

% funzione pulsante premuto: RunDiagnosticButton

function RunDiagnosticButtonPushed(app, event) way = app. TemperatureDirectionSwitch. Value; way= uint8(way) way = length(way) if way == 4 Chng_dir = -1; altrimenti Chng_dir = 1; end T_ins = app.tempnow. Value P_out = app. PowerOutputRatingEditField. Value CalcMass1(T_ins, P_out, Chng_dir)

fine

% Valore funzione modificata: Temperature1Spinner

function Temperature1SpinnerValueChanged(app, event) value = app. Temperature1Spinner. Value; fine

% Valore funzione modificata: Temperature2Spinner

function Temperature2SpinnerValueChanged(app, event) value = app. Temperature2Spinner. Value; fine

% Valore modificato funzione: Switch

function SwitchValueChanged(app, event) m = mobiledev; Lat_in = m. Latitudine Lon_in = m. Longitudine P_out = 0; r_pref = app. DDFH. Value; T_pref = app. Temperature1Spinner. Value; velocità = m. Velocità; massa = 200; velocità = app. AvgLocalSpeedEditField. Value; Auto_Stat = app. Switch. Value; dist_cntrl(Lat_in, Lon_in, P_out, r_pref, T_pref, velocità, massa) end end

% Inizializzazione e costruzione dell'app

metodi (Accesso = privato)

% Crea UIFigura e componenti

funzione createComponents (app)

% Crea Figura UI

app. UIFigure = uifigure; app. UIFigure. Position = [100 100 640 480]; app. UIFigure. Name = 'Figura dell'interfaccia utente';

% Crea gruppo di schede

app. TabGroup = uitabgroup(app. UIFigure); app. TabGroup. Position = [1 1 640 480];

% Crea scheda di configurazione

app. SetupTab = uitab(app. TabGroup); app. SetupTab. Title = 'Imposta';

% Crea RunDiagnosticButton

app. RunDiagnosticButton = uibutton(app. SetupTab, 'push'); app. RunDiagnosticButton. ButtonPushedFcn = createCallbackFcn(app, @RunDiagnosticButtonPushed, true); app. RunDiagnosticButton. FontWeight = 'grassetto'; app. RunDiagnosticButton. Position = [465 78 103 23]; app. RunDiagnosticButton. Text = 'Esegui diagnostica';

% Crea valutazione di efficienza energeticaModifica etichetta campo

app. EnergyEfficiencyRatingEditFieldLabel = uilabel(app. SetupTab); app. EnergyEfficiencyRatingEditFieldLabel. HorizontalAlignment = 'giusto'; app. EnergyEfficiencyRatingEditFieldLabel. Position = [8 425 135 22]; app. EnergyEfficiencyRatingEditFieldLabel. Text = 'Classificazione di efficienza energetica';

% Crea valutazione di efficienza energeticaModifica campo

app. EnergyEfficiencyRatingEditField = uieditfield(app. SetupTab, 'numeric'); app. EnergyEfficiencyRatingEditField. Limits = [0 100]; app. EnergyEfficiencyRatingEditField. ValueChangedFcn = createCallbackFcn(app, @EnergyEfficiencyRatingEditFieldValueChanged, true); app. EnergyEfficiencyRatingEditField. HorizontalAlignment = 'centro'; app. EnergyEfficiencyRatingEditField. Position = [158 425 100 22];

% Crea PowerOutputRatingEditFieldLabel

app. PowerOutputRatingEditFieldLabel = uilabel(app. SetupTab); app. PowerOutputRatingEditFieldLabel. HorizontalAlignment = 'giusto'; app. PowerOutputRatingEditFieldLabel. Position = [18 328 118 22]; app. PowerOutputRatingEditFieldLabel. Text = 'Potenza nominale in uscita';

% Crea PowerOutputRatingEditField

app. PowerOutputRatingEditField = uieditfield(app. SetupTab, 'numeric'); app. PowerOutputRatingEditField. Limits = [0 Inf]; app. PowerOutputRatingEditField. ValueChangedFcn = createCallbackFcn(app, @PowerOutputRatingEditFieldValueChanged, true); app. PowerOutputRatingEditField. HorizontalAlignment = 'centro'; app. PowerOutputRatingEditField. Position = [151 328 100 22];

% Crea AvgLocalSpeedEditFieldLabel

app. AvgLocalSpeedEditFieldLabel = uilabel(app. SetupTab); app. AvgLocalSpeedEditFieldLabel. HorizontalAlignment = 'destro'; app. AvgLocalSpeedEditFieldLabel. Position = [27 231 100 22]; app. AvgLocalSpeedEditFieldLabel. Text = 'Avg. Velocità locale';

% Crea AvgLocalSpeedEditField

app. AvgLocalSpeedEditField = uieditfield(app. SetupTab, 'numeric'); app. AvgLocalSpeedEditField. Limits = [0 70]; app. AvgLocalSpeedEditField. ValueChangedFcn = createCallbackFcn(app, @AvgLocalSpeedEditFieldValueChanged, true); app. AvgLocalSpeedEditField. HorizontalAlignment = 'centro'; app. AvgLocalSpeedEditField. Position = [142 231 100 22];

% Crea la distanza desiderata da HouseEditFieldLabel

app. DesiredDistancefromHouseEditFieldLabel = uilabel(app. SetupTab); app. DesiredDistancefromHouseEditFieldLabel. HorizontalAlignment = 'right'; app. DesiredDistancefromHouseEditFieldLabel. Position = [24 129 100 28]; app. DesiredDistancefromHouseEditFieldLabel. Text = {'Distanza desiderata '; 'da casa'};

% Crea DDFH

app. DDFH = uieditfield(app. SetupTab, 'numerico'); app. DDFH. Limits = [0 50]; app. DDFH. ValueChangedFcn = createCallbackFcn(app, @DDFHValueChanged, true); app. DDFH. HorizontalAlignment = 'centro'; app. DDFH. Position = [139 135 100 22];

% Crea TemperatureDirectionSwitchLabel

app. TemperatureDirectionSwitchLabel = uilabel(app. SetupTab); app. TemperatureDirectionSwitchLabel. HorizontalAlignment = 'centro'; app. TemperatureDirectionSwitchLabel. Position = [410 343 124 22]; app. TemperatureDirectionSwitchLabel. Text = 'Direzione temperatura';

% Crea interruttore direzione temperatura

app. TemperatureDirectionSwitch = uiswitch(app. SetupTab, 'slider'); app. TemperatureDirectionSwitch. Items = {'Su', 'Giù'}; app. TemperatureDirectionSwitch. ValueChangedFcn = createCallbackFcn(app, @TemperatureDirectionSwitchValueChanged, true); app. TemperatureDirectionSwitch. Position = [449 380 45 20]; app. TemperatureDirectionSwitch. Value = 'Su';

% Crea scheda TempSettings

app. TempSettingsTab = uitab(app. TabGroup); app. TempSettingsTab. Title = 'Temp. Impostazioni';

% Crea temperatura1SpinnerLabel

app. Temperature1SpinnerLabel = uilabel(app. TempSettingsTab); app. Temperature1SpinnerLabel. HorizontalAlignment = 'centro'; app. Temperature1SpinnerLabel. Position = [66 363 76 28]; app. Temperature1SpinnerLabel. Text = {'Temperatura '; '#1'};

% Crea temperatura1 Filatore

app. Temperature1Spinner = uispinner(app. TempSettingsTab); app. Temperature1Spinner. Limits = [60 90]; app. Temperature1Spinner. ValueChangedFcn = createCallbackFcn(app, @Temperature1SpinnerValueChanged, true); app. Temperature1Spinner. Position = [157 346 100 68]; app. Temperature1Spinner. Value = 60;

% Crea temperatura2SpinnerLabel

app. Temperature2SpinnerLabel = uilabel(app. TempSettingsTab); app. Temperature2SpinnerLabel. HorizontalAlignment = 'centro'; app. Temperature2SpinnerLabel. Position = [66 248 76 28]; app. Temperature2SpinnerLabel. Text = {'Temperatura '; '#2'};

% Crea temperatura2 Spinner

app. Temperature2Spinner = uispinner(app. TempSettingsTab); app. Temperature2Spinner. Limits = [60 90]; app. Temperature2Spinner. ValueChangedFcn = createCallbackFcn(app, @Temperature2SpinnerValueChanged, true); app. Temperature2Spinner. Position = [157 230 100 70]; app. Temperature2Spinner. Value = 60;

% Crea interruttore

app. Switch = uiswitch(app. TempSettingsTab, 'slider'); app. Switch. Items = {'1', '0'}; app. Switch. ValueChangedFcn = createCallbackFcn(app, @SwitchValueChanged, true); app. Switch. FontName = 'Nyala'; app. Switch. FontSize = 28; app. Switch. Position = [522 21 74 32]; app. Switch. Value = '0';

% Crea EditFieldLabel

app. EditFieldLabel = uilabel(app. TempSettingsTab); app. EditFieldLabel. HorizontalAlignment = 'destro'; app. EditFieldLabel. Position = [374 291 25 22]; app. EditFieldLabel. Text = '';

% Crea tempnow

app.tempnow = uieditfield(app. TempSettingsTab, 'numeric'); app.tempnow. Limits = [60 89]; app.tempnow. ValueChangedFcn = createCallbackFcn(app, @tempnowValueChanged, true); app.tempnow. HorizontalAlignment = 'centro'; app.tempnow. FontSize = 26; app.tempnow. Position = [409 230 133 117]; app.tempnow. Value = 60;

% Crea etichetta indicatore

app. GaugeLabel = uilabel(app. TempSettingsTab); app. GaugeLabel. HorizontalAlignment = 'centro'; app. GaugeLabel. Position = [225 32 42 22]; app. GaugeLabel. Text = 'Indicatore';

% Crea indicatore

app. Gauge = uigauge(app. TempSettingsTab, 'circolare'); app. Gauge. Limits = [60 90]; app. Gauge. MajorTicks = [60 65 70 75 80 85 90]; app. Gauge. Position = [185 69 120 120]; app. Gauge. Value = 60;

% Crea scheda Risparmio

app. SavingsTab = uitab(app. TabGroup); app. SavingsTab. Title = 'Risparmio';

% Crea assi UIA

app. UIAxes = uiaxes(app. SavingsTab); title(app. UIAxes, 'Risparmio') xlabel(app. UIAxes, 'Mese e anno') ylabel(app. UIAxes, 'Money') app. UIAxes. PlotBoxAspectRatio = [1 0.606666666666667 0.606666666666667]; app. UIAxes. Color = [0.9412 0.9412 0.9412]; app. UIAxes. Position = [146 219 348 237];

% Crea questoMeseCostEditFieldLabel

app. ThisMonthCostEditFieldLabel = uilabel(app. SavingsTab); app. ThisMonthCostEditFieldLabel. HorizontalAlignment = 'centro'; app. ThisMonthCostEditFieldLabel. Position = [439 96 94 22]; app. ThisMonthCostEditFieldLabel. Text = 'Costo del mese';

% Crea questoCampoModificaCostoMese

app. ThisMonthCostEditField = uieditfield(app. SavingsTab, 'numeric'); app. ThisMonthCostEditField. Limits = [0 Inf]; app. ThisMonthCostEditField. ValueDisplayFormat = '$%7.2f'; app. ThisMonthCostEditField. HorizontalAlignment = 'centro'; app. ThisMonthCostEditField. Position = [417 39 137 58];

% Crea risparmi totaliEditFieldLabel

app. TotalSavingsEditFieldLabel = uilabel(app. SavingsTab); app. TotalSavingsEditFieldLabel. HorizontalAlignment = 'giusto'; app. TotalSavingsEditFieldLabel. Position = [111 96 77 22]; app. TotalSavingsEditFieldLabel. Text = 'Risparmio totale';

% Crea Risparmio TotaleModificaCampo

app. TotalSavingsEditField = uieditfield(app. SavingsTab, 'numeric'); app. TotalSavingsEditField. Limits = [0 Inf]; app. TotalSavingsEditField. ValueDisplayFormat = '$%9.2f'; app. TotalSavingsEditField. HorizontalAlignment = 'centra'; app. TotalSavingsEditField. Position = [88 39 137 58]; fine fine

metodi (Accesso = pubblico)

% Costruisci app

app per le funzioni = Control_1

% Creare e configurare componenti

createComponents (app)

% Registra l'app con App Designer

registerApp(app, app. UIFigure)

se narcotico == 0

cancella la fine dell'app

% Codice che viene eseguito prima dell'eliminazione dell'app

funzione elimina (app)

% Elimina UIFigura quando l'app viene eliminata

delete(app. UIFigure) end end end

Probabilmente riceverai un errore, il che non è un problema. Chiudi la GUI che è stata generata dopo aver premuto Esegui, raccoglieremo il resto dei programmi e dei dati necessari in un attimo.

Poiché Matlab è configurato, possiamo passare a Python. Innanzitutto, esegui il programma python dal prompt dei comandi (su Windows) o utilizzando il file.exe nella cartella python. Assicurati che tutte le librerie appropriate siano installate utilizzando il comando import.

importazione seriale

importa ora importa csv

Queste sono le tre librerie di cui avrai bisogno per iniziare, anche se presto creeremo la nostra libreria. Se si è verificato un errore con questi comandi, torna indietro e assicurati che le librerie siano installate e si trovino nella cartella Lib nella cartella python. Successivamente genereremo quella che ho chiamato libreria pythonlogger. Questo nome non è necessario, puoi chiamarlo come vuoi, è solo il nome del file python (.py) che crei.

Apri un editor di testo, io uso Sublime3 ma il blocco note funziona perfettamente e inserisci questo codice.

def pythonprint():

import pythonlogger import serial import time import csv ser = serial. Serial('COM8') # COM8 è la porta seriale di arduino, probabilmente sarà diversa per ogni utente, ad esempio controlla la tua porta seriale nell'IDE di arduino ser.flushInput() mentre Vero: try: ser_bytes = ser.readline() print(ser_bytes) with open("test_data.csv", "a") as f: writer = csv.writer(f, delimiter=", ") # imposta i dati su essere immesso come writer.writerow separato da virgole([time.time(), ser_bytes]) #writes data to test_data.csv tranne: print("Error Occured") break

Salva il testo come "inserisci il nome della libreria che desideri".py nella cartella Lib. Nota anche che la riga def pythonprint() definisce il nome della funzione che stai per chiamare, quindi puoi cambiarlo in def "inserisci il nome che vuoi per la tua funzione"(). Quando la libreria viene salvata possiamo passare al codice arduino.

Apri l'IDE di Arduino e apri due nuove finestre di schizzo. Salva quei due file di schizzo in un posto conveniente, il nome di questi file non ha importanza. Quindi elimina tutto il codice predefinito e sostituiscilo con il seguente.

Per l'arduino ricevente:

#includere

#include #include #include // non è usato ma è necessario per compilare il driver RH_ASK; struct dataStruct{ float temp; }i miei dati; void setup() { Serial.begin(9600); // Debug solo if (!driver.init()) Serial.println("init failed"); } void loop() { uint8_t buf[RH_ASK_MAX_MESSAGE_LEN]; uint8_t buflen = sizeof(buf); if (driver.recv(buf, &buflen)) // Non bloccante { int i; // Messaggio con un buon checksum ricevuto, scaricalo. //driver.printBuffer("Got:", buf, buflen); memcpy(&myData, buf, sizeof(myData)); Serial.println(""); Serial.print(myData.temp); } }

P. S. il //driver.printBuffer…. ecc la riga è il codice di prova. Non c'è bisogno di preoccuparsene a meno che non si stia facendo diagnosi e si desideri capire se si stanno effettivamente ricevendo dati.

Per il trasmettitore arduino

#includere

#include #include #include // questo non è usato ma necessario per compilare#include #include int pin=4; DHT11 dht11 (pin); driver RH_ASK; struct dataStruct{ float temp; }i miei dati; byte tx_buf[sizeof(myData)] = {0}; //Quindi gli argomenti sono bitrate, pin di trasmissione (tx), //pin di ricezione (rx), pin ppt, isInverse. Gli ultimi 2 non vengono utilizzati.void setup() { Serial.begin(9600); // Debug solo if (!driver.init()) Serial.println("init failed"); } loop vuoto() { int err; temperatura di galleggiamento, humi; uint8_t msg; if((err=dht11.read(humi, temp))==0) myData.temp = temp; memcpy(tx_buf, &myData, sizeof(myData)); byte zize=sizeof(myData); { Serial.println(myData.temp); driver.send((uint8_t *)tx_buf, zize); driver.waitPacketSent(); //interrompe l'esecuzione fino a quando tutti i dati non sono stati inviati delay(2000); //aspetta 2 secondi } }

I comandi di inclusione dovrebbero essere sufficienti, ma se in seguito dovessi riscontrare problemi con il trasferimento dei dati, potresti voler cercare nella cartella della libreria RadioHead e includere il resto dei nomi dei file, nello stesso formato.

Passaggio 5: farlo funzionare

Ora che abbiamo tutto il codice insieme e l'arduino è assemblato, possiamo collegare l'arduino al tuo computer e caricare il codice. Assicurati di inviare il codice corretto ai microcontrollori riceventi e trasmittenti. Puoi avere entrambi gli arduino collegati al tuo computer mentre questo è in esecuzione, ma dovrai assicurarti di avere la porta corretta selezionata andando avanti, oppure puoi scollegare l'arduino trasmittente e alimentarlo da qualche altra fonte una volta che il codice è caricato.

A proposito, dovresti selezionare la porta che è collegata al tuo arduino ricevente dal menu degli strumenti IDE ora ed eseguire python.

Non aprire il monitor seriale mentre lo fai, python non può leggere il seriale mentre il monitor è aperto. Una volta che python è aperto, chiama la funzione pythonprint come segue.

pythonlogger.pythonprint()

Questo avvierà la raccolta dei dati dalla porta seriale di arduino. Se apri la tua cartella Python ora, vedrai che è stato creato un nuovo file.csv chiamato "test_data.csv", che contiene tutte le informazioni su tempo e temperatura. Questo sarà il file a cui Matlab accede per eseguire tutti i suoi calcoli e controlli.

Un altro avvertimento: non aprire test_data.csv durante l'accesso o la scrittura dei dati. Se lo fai, il codice Python e/o Matlab si bloccherà e restituirà un errore

Se decidi di aprire il file.csv in un secondo momento, noterai che la colonna dell'ora è solo una stringa di numeri molto grande. Questo perché il comando time.time() scrive il numero di secondi dal 1 gennaio 1970.

A questo punto Python dovrebbe stampare i dati di temperatura che sta leggendo dalla porta seriale. Dovrebbe assomigliare a qualcosa del genere:

b'25.03'/r/n

Non preoccuparti dei caratteri extra, il codice Matlab indicizza i cinque valori centrali nella seconda colonna del file.csv.

Ora che tutti i programmi di supporto funzionano e i dati vengono raccolti, possiamo iniziare a raccogliere i dati GPS dal programma mobile Matlab configurato in precedenza ed eseguire il codice della GUI Matlab. Una volta che sei nella scheda del sensore di Matlab mobile, seleziona GPS e premi il pulsante di avvio.

Se non conosci Matlab mobile, torna al passaggio 4 e guarda le schermate sopra. Se i problemi persistono, assicurati di essere connesso al computer che hai selezionato in precedenza (nella scheda impostazioni) e utilizza il collegamento dal comando "connector on" per verificare che Matlab sia online.

Passaggio 6: utilizzo del programma

Ci sono molte cose che accadono in background in questo sistema. I dati sulla temperatura vengono raccolti e registrati da arduino e pyton, Matlab sta raccogliendo dati GPS dal tuo telefono ed eseguendo calcoli per vedere quanto sei lontano da casa tua e impostando il termostato in base a tutte queste informazioni. Il punto in cui entri è fornire le tue preferenze.

Esegui il codice della GUI di Matlab. Apri il file.mlapp e guarda la prima scheda. Dovrai raccogliere le informazioni per questo da solo, l'efficienza e la potenza nominale della tua unità di riscaldamento/raffreddamento di solito si trovano sull'unità stessa e la tua velocità media è solo una buona stima della velocità con cui guidi. Una volta inseriti i valori, premi il pulsante "Esegui diagnostica" e il programma controlla il termostato per raccogliere informazioni sulla tua casa.

Passa al menu successivo.

Passaggio 7: controllo della temperatura

Questo menu ti consente di selezionare la tua temperatura preferita mentre sei a casa e fuori. Imposta la temperatura n. 1 sulla tua temperatura confortevole e la temperatura n. 2 su un valore alto o basso che sia sicuro per la tua casa (assicurati di non impostarlo a 100 gradi mentre hai cani a casa, ecc.).

Passaggio 8: dati storici

Finalmente puoi vedere quanti soldi stai risparmiando usando il controllo automatico. Questo essenzialmente stima quanta energia verrebbe utilizzata se il termostato fosse impostato sulla temperatura preferita 24 ore su 24, 7 giorni su 7, quindi sottrae l'energia effettivamente utilizzata.

Buona fortuna a costruire.