π Weather és una estació meteorològica amb Raspberry Pi Zero W que recull dades ambientals amb un sensor DHT11 i un anemòmetre casolà. El projecte permet consultar la temperatura, la humitat relativa, la sensació tèrmica calculada i la velocitat del vent des d'una pàgina web publicada amb GitHub Pages.
La Raspberry Pi fa les mesures, les desa en fitxers locals i les publica automàticament al repositori de GitHub. El DHT11 proporciona temperatura i humitat; l'anemòmetre utilitza un interruptor magnètic (reed switch) i imants per detectar el gir de les cassoletes i estimar la velocitat del vent. La velocitat calculada depèn del muntatge i del factor de calibratge, per tant s'ha de considerar una estimació fins que es contrasti amb un instrument de referència.
El sistema està dividit en dues parts: la Raspberry Pi, que s'encarrega de mesurar i publicar les dades, i la pàgina web, que s'encarrega de mostrar-les.
DHT11 ------------------+
|
Anemòmetre -> reed switch +--> Raspberry Pi Zero W
|
+--> temperatura.py
|
+--> pi.txt
|
+--> historial.csv
|
+--> Git commit
|
+--> Git push
|
v
GitHub
|
v
GitHub Pages
|
v
index.html + script.js
El funcionament és:
- La Raspberry Pi llegeix el DHT11 durant 60 segons.
- Es fa una lectura aproximadament cada 2 segons.
- Es calcula la mitjana de totes les lectures.
- Es calcula la sensació tèrmica a partir de temperatura i humitat.
- Es compten els impulsos del reed switch de l'anemòmetre durant el període de mesura i se n'estima la velocitat del vent.
- Les dades actuals, inclosa la velocitat del vent, es guarden a
pi.txt. - La nova mesura s'afegeix a
historial.csv. - Cada 5 minuts aproximadament es fa un commit i un push a GitHub.
- La pàgina web comprova les dades cada 10 segons.
- Les gràfiques s'actualitzen automàticament quan apareixen noves dades.
No cal tenir la pàgina web oberta a la Raspberry Pi.
- Raspberry Pi Zero W
- Sensor DHT11
- Anemòmetre de tres cassoletes amb coixinet 608, imants i interruptor magnètic (reed switch)
- Connexió a Internet
- Cables per connectar els sensors
- Python 3
- Git
- GitHub
- GitHub Pages
- Un repositori GitHub
En aquest projecte el repositori és:
fustcoma/pi-weather
El DHT11 està connectat de la següent manera:
DHT11 DATA -> GPIO 2
DHT11 VCC -> 3.3 V
DHT11 GND -> GND
El GPIO 2 correspon al pin físic 3 de la Raspberry Pi.
El programa utilitza:
board.D2Si el mòdul DHT11 no incorpora una resistència pull-up, es pot utilitzar una resistència d'entre 4.7 kΩ i 10 kΩ entre DATA i 3.3 V.
El repositori conté:
pi-weather/
|
+-- index.html
+-- script.js
+-- temperatura.py
+-- prova.py # programa de prova independent de l'anemòmetre
+-- pi.txt
+-- historial.csv
És el programa principal que s'executa a la Raspberry Pi.
S'encarrega de:
- Llegir el DHT11.
- Fer lectures durant 60 segons.
- Fer una lectura cada 2 segons.
- Calcular les mitjanes.
- Calcular la sensació tèrmica.
- Actualitzar
pi.txt. - Actualitzar
historial.csv. - Fer commits a Git.
- Fer push a GitHub.
- Continuar funcionant encara que un
git pushfalli.
Conté les dades més recents. Amb la integració de l'anemòmetre, el format actual afegeix la velocitat del vent com a quarta línia i deixa la data i l'hora a la cinquena.
Format:
temperatura
humitat
sensacio
vent_kmh
data i hora
Exemple:
26.60
53.36
29.00
2.43
06/09/2026 22:50:29
Aquest fitxer s'utilitza per mostrar les dades actuals a la web.
Conté totes les mesures.
Format:
data,hora,temperatura,humitat,sensacio,vent_kmh
Exemple:
data,hora,temperatura,humitat,sensacio,vent_kmh
06/09/2026,22:50:29,26.60,53.36,29.00,2.43
06/09/2026,22:51:32,26.70,53.10,29.10,2.10
Si el fitxer no existeix, temperatura.py el crea automàticament amb la capçalera corresponent.
És la interfície de la pàgina web.
Mostra:
- Temperatura actual.
- Humitat actual.
- Sensació tèrmica actual.
- Velocitat actual del vent.
- Data i hora de l'última actualització.
- Gràfica de temperatura.
- Gràfica d'humitat.
- Gràfica de sensació tèrmica.
- Gràfica de velocitat del vent, si aquesta sèrie està inclosa a la versió desplegada.
La pàgina utilitza un disseny fosc.
Els períodes disponibles són:
1 hora
6 hores
24 hores
7 dies
Tot
S'encarrega de:
- Carregar
pi.txt. - Carregar
historial.csv. - Actualitzar les dades actuals.
- Crear les gràfiques.
- Canviar el període de les gràfiques.
- Actualitzar automàticament les dades cada 10 segons.
- Detectar períodes sense dades.
Utilitza Chart.js per generar les gràfiques.
Des de la Raspberry Pi:
cd ~
git clone https://github.com/fustcoma/pi-weather.gitEntrar al projecte:
cd ~/pi-weatherCrear l'entorn virtual:
python3 -m venv ~/dht-envActivar-lo:
source ~/dht-env/bin/activateQuan estigui activat, normalment apareixerà (dht-env) al principi de la terminal.
Per sortir de l'entorn virtual:
deactivateAmb l'entorn virtual activat:
pip install adafruit-blinka
pip install adafruit-circuitpython-dhtEl programa actual no necessita NumPy.
Git necessita saber quin usuari farà els commits.
Configurar el nom:
git config --global user.name "EL_TEU_USERNAME"Configurar el correu:
git config --global user.email "EL_TEU_EMAIL"Comprovar-ho:
git config --global --listPer poder fer git push des de la Raspberry Pi mitjançant HTTPS, GitHub necessita una credencial.
La contrasenya normal del compte de GitHub no s'utilitza per a aquest procés.
Cal crear un Personal Access Token.
A GitHub:
- Obre
Settings. - Entra a
Developer settings. - Entra a
Personal access tokens. - Selecciona
Fine-grained tokens. - Selecciona
Generate new token.
Posa un nom identificatiu, per exemple:
Raspberry Pi Estació Meteorològica
Selecciona una data d'expiració.
A Repository access, selecciona:
Only select repositories
I selecciona:
usuari/nom-del-repositori
A Repository permissions, busca:
Contents
I posa:
Read and write
Finalment, crea el token.
GitHub només mostra el token complet una vegada.
Cal copiar-lo quan aparegui.
El token no s'ha d'introduir mai dins de:
temperatura.py
index.html
script.js
Tampoc s'ha de pujar a GitHub.
Perquè Git no demani el token en cada git push, configurar:
git config --global credential.helper storeDesprés fer un primer push:
cd ~/pi-weather
git pushGit demanarà:
Username:
Password:
A Username, utilitza el teu nom d'usuari de GitHub:
A Password, enganxa el Personal Access Token.
No utilitzis la contrasenya normal del compte de GitHub.
Després d'això, Git guardarà la credencial localment i els futurs git push no haurien de tornar a demanar el token.
La credencial quedarà guardada a:
~/.git-credentials
Aquest fitxer conté informació sensible.
No s'ha de compartir ni pujar al repositori.
Abans de configurar l'automatització, és recomanable comprovar que la Raspberry pot fer push.
Executar:
cd ~/pi-weather
git statusDesprés:
git pushSi el push funciona sense errors i no torna a demanar el token en les següents ocasions, Git està configurat correctament.
L'anemòmetre mesura la velocitat aproximada del vent. El muntatge és un anemòmetre de tres cassoletes: quan el vent les empeny, el rotor gira. Els imants instal·lats a la part giratòria passen a prop d'un interruptor magnètic (reed switch), que obre o tanca el contacte. La Raspberry Pi detecta aquests canvis com a impulsos elèctrics.
El programa compta els impulsos durant un interval conegut i, a partir del nombre d'impulsos i del factor de conversió/calibratge utilitzat pel muntatge, calcula una velocitat en km/h. La lectura no és una mesura meteorològica certificada: la forma de les cassoletes, la distància dels imants al reed switch, la fricció del coixinet i el calibratge influeixen en el resultat.
El muntatge s'ha basat en el disseny d'alf45tar/Anemometer, adaptat per connectar-lo directament a una Raspberry Pi Zero W:
- Coixinet 608 de 8 × 22 × 7 mm.
- Tres insercions roscades M3 i tres cargols M3 × 10.
- Interruptor magnètic (reed switch).
- Dos imants de 6 × 3 mm.
- Junta tòrica de 8 × 2 mm.
- Cassoletes i peces impreses en 3D del disseny original.
El crèdit del disseny original correspon a alf45tar. La lectura amb Raspberry Pi i la integració amb π Weather són l'adaptació d'aquest projecte.
La connexió final utilitzada és:
Raspberry Pi Zero W Reed switch
-----------------------------------------------
GPIO 8 (BCM) / pin físic 24 ------ un terminal
GND / pin físic 20 ------ l'altre terminal
El programa identifica el pin pel número BCM 8, no pel número físic. Això és important: REED_PIN = 8 vol dir GPIO 8, que físicament és el pin 24 de la capçalera de 40 pins. El pin físic 20 és GND.
El circuit utilitza la resistència pull-up interna del GPIO. Per això, el reed switch es connecta entre GPIO 8 i GND: no s'ha de connectar a 5 V. Quan el contacte està obert, l'entrada normalment es llegeix com a HIGH; quan el contacte es tanca, es llegeix com a LOW. El programa de prova o la llibreria poden expressar aquest estat com is_pressed o com un canvi d'estat.
Abans d'alimentar el muntatge, comprova el número dels pins amb un esquema de la capçalera de la Raspberry Pi. No confonguis GPIO 8 amb el pin físic 8: són numeracions diferents.
prova.py és un programa de diagnòstic independent per comprovar l'anemòmetre sense haver d'arrencar tot el sistema meteorològic ni publicar dades a GitHub. Serveix per aïllar els problemes del sensor:
- Llegeix l'entrada GPIO connectada al reed switch.
- Detecta els impulsos generats quan els imants passen pel contacte.
- Comprova que el senyal arriba realment a la Raspberry Pi.
- Permet observar si el rotor i el contacte magnètic funcionen abans d'integrar la lectura a
temperatura.py.
Durant les proves es va arribar a obtenir una sortida semblant a:
Velocitat: 2.43 km/h
Aquesta línia és un exemple d'una lectura de prova, no una velocitat fixa ni una garantia de calibratge. Si prova.py detecta els impulsos però temperatura.py no, cal revisar la integració del codi principal. Si no detecta cap impuls, primer s'han de comprovar el cablejat, el contacte i els imants.
Executa'l des del directori del projecte i amb el mateix entorn de Python que s'utilitza per a l'estació:
cd ~/pi-weather
source ~/dht-env/bin/activate
python prova.pyAtura la prova amb Ctrl + C si el programa continua llegint el sensor. prova.py no substitueix temperatura.py: és una eina de diagnòstic per provar l'anemòmetre de manera separada.
La configuració de mesura treballada per al projecte utilitza aquests intervals:
REED_PIN = 8
DURADA_MESURA = 60
INTERVAL_LECTURA = 2
INTERVAL_PUSH = 300REED_PIN = 8: GPIO BCM on està connectat el reed switch.DURADA_MESURA = 60: durada del període de mesura, en segons.INTERVAL_LECTURA = 2: interval de lectura/mostreig, en segons.INTERVAL_PUSH = 300: interval aproximat entre publicacions a GitHub, és a dir, 300 segons o 5 minuts.
El càlcul de la velocitat depèn del recompte d'impulsos i dels paràmetres de conversió del disseny. Per obtenir valors fiables, compara l'anemòmetre amb un anemòmetre de referència en diverses velocitats de vent i ajusta el factor de calibratge si cal.
temperatura.py continua sent el programa principal. A més de llegir el DHT11, ara també recull la informació de l'anemòmetre i desa la velocitat del vent als fitxers de dades:
pi.txt: velocitat del vent a la quarta línia; la data i l'hora passen a la cinquena.historial.csv: velocitat del vent al campvent_kmh, després de les dades de temperatura, humitat i sensació tèrmica.
La pàgina web només pot mostrar les dades de vent si el seu script.js llegeix el nou camp i index.html conté l'element visual corresponent. Si la Raspberry Pi ja calcula el vent però la web no el mostra, comprova primer el contingut dels fitxers i després que la versió de la web publicada inclogui aquests canvis.
Activar l'entorn virtual:
source ~/dht-env/bin/activateEntrar al projecte:
cd ~/pi-weatherExecutar:
python temperatura.pyEl programa començarà a fer lectures.
Es poden veure dades semblants a:
Lectura: 26.00 C, 53.00 %
Lectura: 26.00 C, 54.00 %
Lectura: 26.00 C, 53.00 %
Després de completar els 60 segons de mesura, calcularà:
Temperatura mitjana
Humitat mitjana
Sensació tèrmica
I actualitzarà:
pi.txt
historial.csv
Per aturar-lo manualment:
Ctrl + C
Perquè el programa no s'hagi d'executar manualment cada vegada que s'encén la Raspberry Pi, s'utilitza systemd.
Es crea un servei anomenat:
estacio.service
Crear-lo:
sudo nano /etc/systemd/system/estacio.servicePosar-hi:
[Unit]
Description=Estacio meteorologica DHT11
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/pi-weather
ExecStart=/home/pi/dht-env/bin/python /home/pi/pi-weather/temperatura.py
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.targetGuardar i sortir.
Aquest fitxer indica a systemd:
- Quin programa executar.
- Quin usuari utilitzar.
- En quina carpeta executar-lo.
- Quin Python utilitzar.
- Que s'ha de reiniciar si el programa falla.
- Que s'ha d'iniciar durant l'arrencada de la Raspberry Pi.
Els camins han de coincidir amb la ubicació real del projecte i de l'entorn virtual.
Després de crear el fitxer:
sudo systemctl daemon-reloadIniciar el servei:
sudo systemctl start estacio.serviceComprovar l'estat:
sudo systemctl status estacio.serviceHauria d'aparèixer:
Active: active (running)
Perquè el programa s'executi automàticament cada vegada que la Raspberry Pi s'encén:
sudo systemctl enable estacio.serviceA partir d'aquest moment no cal executar manualment:
python temperatura.pyni:
source ~/dht-env/bin/activatedurant l'arrencada.
Systemd utilitza directament:
/home/pi/dht-env/bin/python
Es pot comprovar reiniciant la Raspberry:
sudo rebootQuan torni a estar disponible:
sudo systemctl status estacio.serviceSi apareix:
Active: active (running)
el programa s'ha iniciat automàticament.
També es poden veure els logs:
journalctl -u estacio.service -fsudo systemctl start estacio.servicesudo systemctl stop estacio.servicesudo systemctl restart estacio.servicesudo systemctl status estacio.servicejournalctl -u estacio.service -fjournalctl -u estacio.service -n 100sudo systemctl disable estacio.serviceAixò no elimina el servei.
Només evita que s'iniciï automàticament.
Per tornar-lo a activar:
sudo systemctl enable estacio.serviceCada cicle de temperatura.py dura aproximadament:
60 segons de mesura
+
10 segons d'espera
Durant els 60 segons es fa una lectura cada 2 segons.
Les lectures obtingudes es fan servir per calcular una mitjana.
Després es guarden les dades a:
pi.txt
historial.csv
El programa no fa un git push després de cada mesura.
El push es fa aproximadament cada 5 minuts.
El procés és:
Dada nova
|
v
pi.txt
|
v
historial.csv
|
v
git add
|
v
git commit
|
v
git push
|
v
GitHub
Si un git push falla, el programa no s'atura. Continuarà fent mesures i tornarà a intentar publicar-les en el següent interval.
La pàgina web comprova pi.txt i historial.csv cada 10 segons.
Això significa que no cal recarregar manualment la pàgina perquè apareguin noves dades.
El flux és:
Raspberry Pi
|
| nova dada
v
Fitxers locals
|
| cada 5 minuts
v
GitHub
|
| comprovació cada 10 segons
v
Web
Per tant, el temps màxim aproximat entre un git push i la detecció de la nova dada per la web és d'uns 10 segons.
Si el navegador està mostrant dades antigues després de modificar el codi de la web, es pot fer una recàrrega completa amb:
Ctrl + Shift + R
Les gràfiques utilitzen les dades de:
historial.csv
Hi ha tres gràfiques:
Temperatura
Humitat
Sensació tèrmica
Els períodes disponibles són:
1 hora
6 hores
24 hores
7 dies
Tot
La web detecta automàticament quan hi ha un període llarg sense dades.
Actualment el límit és de:
5 minuts
Per exemple:
10:01 30 C
10:02 30 C
10:03 30 C
10:04 30 C
13:04 34 C
Entre 10:04 i 13:04 han passat més de 5 minuts.
La gràfica no connectarà aquests dos punts.
Es mostrarà aproximadament:
30 ────────── ───── 34
en lloc de:
30 ─────────────────────── 34
Això evita crear línies incorrectes quan la Raspberry està apagada, perd connexió, el sensor deixa de funcionar o simplement no hi ha dades durant un període.
La sensació tèrmica es calcula utilitzant temperatura i humitat relativa.
La fórmula utilitzada pel programa és:
e = (humitat / 100) * 6.105 * math.exp(
17.72 * temperatura / (237.7 + temperatura)
)
sensacio = temperatura + 0.33 * e - 4El resultat es guarda amb dues xifres decimals.
La pàgina web està pensada per funcionar amb GitHub Pages.
El repositori és:
https://github.com/fustcoma/pi-weather
GitHub Pages utilitza:
index.html
script.js
pi.txt
historial.csv
La pàgina web no necessita Python ni cap servidor propi.
Només necessita poder llegir els fitxers del repositori.
Si es modifica temperatura.py, script.js o index.html, cal pujar els canvis a GitHub.
Des de l'ordinador:
git add .
git commit -m "Actualització del projecte"
git pushDesprés, si s'ha modificat temperatura.py, cal actualitzar també la còpia de la Raspberry Pi.
A la Raspberry:
cd ~/pi-weather
git pullDesprés reiniciar el servei:
sudo systemctl restart estacio.serviceAixò és important perquè el servei que ja està funcionant continuarà utilitzant el programa anterior fins que es reiniciï.
Si només s'ha modificat temperatura.py:
cd ~/tpi-weather
git pull
sudo systemctl restart estacio.serviceComprovar:
sudo systemctl status estacio.serviceSi es modifica:
/etc/systemd/system/estacio.service
cal executar:
sudo systemctl daemon-reloadI després:
sudo systemctl restart estacio.serviceSi també es vol assegurar que continua iniciant-se automàticament:
sudo systemctl enable estacio.servicehistorial.csv no s'ha de crear manualment.
Si no existeix, temperatura.py el crea automàticament.
A partir d'aquí, cada mesura s'afegeix al final del fitxer.
Per consultar-lo des de la Raspberry:
cat historial.csvPer consultar només les últimes línies:
tail historial.csvPer exemple:
tail -20 historial.csvPer veure el contingut de pi.txt:
cat pi.txtExemple:
26.60
53.36
29.00
2.43
06/09/2026 22:50:29
El servei utilitza el sistema de logs de systemd.
Per veure els logs:
journalctl -u estacio.servicePer veure'ls en temps real:
journalctl -u estacio.service -fPer veure les últimes 100 línies:
journalctl -u estacio.service -n 100Per veure els logs des de l'últim arrencament:
journalctl -u estacio.service -bPer poder investigar errors encara que la Raspberry Pi es reiniciï, es pot activar l'emmagatzematge persistent dels logs de systemd.
Crear la carpeta:
sudo mkdir -p /var/log/journalEditar:
sudo nano /etc/systemd/journald.confBuscar:
#Storage=auto
I canviar-ho per:
Storage=persistent
Després reiniciar el servei de journald:
sudo systemctl restart systemd-journaldA partir d'aquest moment, els logs es conservaran entre reinicis.
Si la Raspberry Pi es reinicia inesperadament, primer es pot consultar l'arrencada anterior.
Veure els últims missatges de l'arrencada anterior:
journalctl -b -1 -eVeure només avisos:
journalctl -b -1 -p warningBuscar problemes d'alimentació o voltatge:
journalctl -b -1 | grep -i -E "under-voltage|voltage|throttl|power"Buscar problemes de temperatura:
journalctl -b -1 | grep -i -E "thermal|temperature|overheat"Veure avisos del kernel:
journalctl -b -1 -k -p warningVeure les últimes 100 línies del kernel:
journalctl -b -1 -k | tail -100També es pot comprovar l'estat de throttling:
vcgencmd get_throttledI la temperatura actual:
vcgencmd measure_tempLa informació de l'arrencada anterior només estarà disponible si els logs persistents estaven activats abans del reinici.
Si s'està connectat per SSH, la Raspberry Pi es pot apagar de manera segura amb:
sudo poweroffTambé es pot utilitzar:
sudo shutdown -h nowÉs preferible apagar-la així abans de desconnectar l'alimentació físicament.
Comprovar:
- DATA està connectat al GPIO 2.
- GPIO 2 correspon al pin físic 3.
- VCC està connectat a 3.3 V.
- GND està connectat correctament.
- Hi ha una resistència pull-up si el mòdul no la incorpora.
També comprovar que les llibreries estiguin instal·lades:
source ~/dht-env/bin/activate
pip listExecutar:
sudo systemctl status estacio.serviceDesprés:
journalctl -u estacio.service -n 100Això normalment mostrarà l'error que impedeix iniciar temperatura.py.
Comprovar els camins del servei:
User=pi
WorkingDirectory=/home/pi/pi-weather
ExecStart=/home/pi/dht-env/bin/python /home/pi/pi-weather/temperatura.pyTambé comprovar que el fitxer existeixi:
ls ~/pi-weather/temperatura.pyI que existeixi el Python de l'entorn virtual:
ls ~/dht-env/bin/pythonComprovar:
cd ~/pi-weather
git statusProvar:
git pushComprovar que Git recorda les credencials:
git config --global --get credential.helperHauria de mostrar:
store
Si torna a demanar el token, cal tornar a autenticar Git amb el Personal Access Token.
Comprovar des de la Raspberry:
cat pi.txtI:
cat historial.csvComprovar també que els canvis hagin arribat a GitHub:
git statusSi s'han fet canvis però encara no s'han publicat:
git add .
git commit -m "Actualització de dades"
git pushSi el problema és només la memòria cau del navegador:
Ctrl + Shift + R
La Raspberry actualitza les dades aproximadament cada minut, però només les publica a GitHub cada 5 minuts.
Per tant, una dada nova pot tardar fins a uns 5 minuts a arribar a GitHub.
Una vegada publicada, script.js la comprova cada 10 segons.
Comprovar també que historial.csv contingui una nova línia:
tail historial.csvDurant el muntatge es van provar connexions i programes de diagnòstic separats. Si no apareix cap impuls:
- Comprova que el reed switch estigui connectat entre GPIO 8 (pin físic 24) i GND (per exemple, pin físic 20).
- Assegura't que el programa utilitzi numeració BCM (
REED_PIN = 8) i no el número físic del connector. - Apropa els imants al reed switch i gira el rotor a poc a poc. Els imants han de passar prou a prop del contacte i amb l'orientació adequada.
- Comprova que els terminals del reed switch i els cables no estiguin trencats. Si tens un multímetre, utilitza el mode de continuïtat per veure si el contacte es tanca quan hi apropes un imant.
- Prova primer el cable entre GPIO i GND. Si el programa detecta el canvi en tancar el circuit manualment però no quan gira l'anemòmetre, el problema probablement és mecànic o magnètic: posició dels imants, distància, orientació o contacte.
- Executa
prova.pyabans de depurar el programa principal.
En les proves es va observar que tancar el circuit entre el GPIO i GND podia activar l'entrada, mentre que el conjunt d'imants i reed switch no sempre generava impulsos. Això ajuda a separar un problema de programari o de pin d'un problema de posicionament del sensor.
Durant les proves va aparèixer un error del tipus ModuleNotFoundError per a gpiozero, tot i que s'havia intentat instal·lar la llibreria. En aquests casos, el més important és assegurar-se que la instal·lació i l'execució utilitzen el mateix Python: activar ~/dht-env abans d'instal·lar o executar res.
source ~/dht-env/bin/activate
python -m pip show gpiozero
python -c "import sys; print(sys.executable)"Si pip show no troba el paquet, instal·la'l en aquest mateix entorn:
python -m pip install gpiozeroDesprés torna a executar prova.py des de l'entorn activat. Si l'error continua, comprova la ruta de Python mostrada per sys.executable i no barregis pip d'un Python amb l'executable d'un altre. Aquest problema és diferent d'un error de cablejat: un mòdul que no s'importa impedeix que el programa comenci, mentre que un sensor que no detecta impulsos requereix revisar el circuit i el muntatge.
- Comprova que els imants passin pel reed switch una vegada per cada posició prevista pel disseny.
- Gira el rotor manualment i observa si el recompte d'impulsos canvia.
- Comprova que no hi hagi fregament excessiu al coixinet 608.
- Revisa el factor de conversió/calibratge emprat pel codi. Un valor de prova com
2.43 km/hnomés confirma que el programa ha produït una lectura; no demostra per si sol que la velocitat sigui exacta. - Evita interpretar zero com a prova definitiva que no hi ha vent: també pot indicar que el rotor no gira lliurement o que el reed switch no detecta els imants.
No s'han de pujar mai al repositori:
- Personal Access Tokens.
- Contrasenyes.
- Claus privades.
- Credencials SSH.
- Altres secrets.
El token de GitHub està guardat localment a:
~/.git-credentials
No s'ha de compartir aquest fitxer.
El token tampoc s'ha d'escriure dins de:
temperatura.py
En una instal·lació nova, els passos principals són:
cd ~
git clone https://github.com/fustcoma/pi-weather.git
cd ~/pi-weather
python3 -m venv ~/dht-env
source ~/dht-env/bin/activate
pip install adafruit-blinka
pip install adafruit-circuitpython-dht
git config --global user.name "EL_TEU_USUARI"
git config --global user.email "EL_TEU_EMAIL"
git config --global credential.helper store
git pushDesprés crear:
/etc/systemd/system/estacio.service
Amb:
[Unit]
Description=Estacio meteorologica DHT11
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/pi-weather
ExecStart=/home/pi/dht-env/bin/python /home/pi/pi-weather/temperatura.py
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.targetI activar-lo:
sudo systemctl daemon-reload
sudo systemctl start estacio.service
sudo systemctl enable estacio.serviceComprovar:
sudo systemctl status estacio.serviceA partir d'aquí, la Raspberry Pi pot funcionar de manera autònoma.
DHT11
|
v
Raspberry Pi Zero W
|
v
temperatura.py
|
+--------+--------+
| |
v v
pi.txt historial.csv
| |
+--------+--------+
|
v
Git
|
cada 5 minuts
|
v
GitHub
|
v
GitHub Pages
|
+--------+--------+
| |
v v
index.html script.js
|
v
Chart.js
|
+----------+----------+
| | |
v v v
Temperatura Humitat Sensació
El servei estacio.service fa que tot el sistema de mesura s'iniciï automàticament quan la Raspberry Pi s'encén, mentre que GitHub Pages permet consultar les dades des de qualsevol dispositiu amb accés a Internet.
Aquest projecte està publicat sota la llicència MIT.
Creat per fustcoma.
Anemòmetre creat per alf45tar