È così che ho finalmente implementato il favoloso approccio delineato da VillageTech.

Hardware

Cablaggio

Il pin predefinito per i dispositivi Onewire sul Pi è GPIO 4 . Quindi ho collegato GND alla manica della spina e ho collegato la punta al pin GPIO menzionato.

Un token

Tutto ciò di cui ho bisogno per un token è il chip DS18B20 e un jack da 3,5 mm. Quindi saldare insieme i pin GND e VCC del chip e collegarlo alla manica. Aggiungi un po 'di guaina termorestringente al perno centrale per evitare cortocircuiti e collegalo alla punta del jack.

Entrambi i jack funzionano quello con due anelli e quello con solo la punta.

Resistenza di pull up

Ho deciso di non utilizzare una resistenza di pull up esterna, poiché il Pi ha resistenze di pull up interne.

Non friggiamo le cuffie

Come flawr correttamente sottolineato è il fatto che se sembra un jack audio da 3,5 mm le persone potrebbero essere tentate di inserire le cuffie.

Finché utilizziamo un'alimentazione parassita, dove solo un filo di terra e un'uscita GPIO ad alta impedenza sono esposti alla presa, dovremmo essere al sicuro, poiché non abbiamo un V _{DD sub > linea che potrebbe creare un cortocircuito a causa della bassa resistenza delle cuffie.}

Configurazione

Aggiungi la seguente riga a /boot/config.txt :

  dtoverlay = w1-gpio
 

Ci sono più opzioni. Puoi trovare altro nel / boot / overlays / README del tuo Pi.

Alcune fonti hanno suggerito di aggiungere i due moduli w1-gpio e w1_therm a / etc / modules , tuttavia ho scoperto che il dispositivo -tree overlay entry nel boot / config.txt era sufficiente per i miei scopi.

Ora riavvia il dispositivo.

Aggiungi un pullup tramite software in python:

  importa RPi.GPIO come GPIO
GPIO_PIN_NUMBER = 14
GPIO.setmode (GPIO.BCM)
GPIO.setup (GPIO_PIN_NUMBER, GPIO.IN, pull_up_down = GPIO.PUD_UP)
 

Non appena ho creato questo pull up, ho potuto rilevare i token in / sys / bus / w1 / devices / con il prefisso 28 in un'altra finestra del terminale:

  $ ls / sys / bus / w1 / devices /
28-00000aabbccd w1_bus_master1
 

Dopo circa 10 secondi le voci in devices scomparirebbero. Ho dovuto creare la seguente configurazione, in modo che i dispositivi scomparissero dopo circa un secondo:

  sudo nano /etc/modprobe.d/w1.conf
 

Ora aggiungi il contenuto al file e riavvia nuovamente il dispositivo:

  opzioni wire timeout = 1 slave_ttl = 1
 

Nella mia configurazione questo file non esisteva in precedenza.

Software

Ho creato una classe python che cercava modifiche nel file system e mi diceva se un nuovo token era connesso o se tutti i token erano scollegati.

  import os
importare thread
tempo di importazione
da datetime import datetime, timedelta


classe W1Service (oggetto):
    __istanza = Nessuno

    def __new __ (cls):
        # Inizializzatore singleton
        se l'istanza W1Service .__ è Nessuno:
            W1Service .__ istanza = oggetto .__ new __ (cls)
        restituire l'istanza W1Service .__

    on_all_token_removed = Nessuno
    on_token_added = Nessuno
    is_scanning = False

    def start_scan (self, delay = 10):
        return thread.start_new_thread (self.scan, (delay,))

    def scan (self, delay = 10):
        W1Service.is_scanning = True
        last_token = Nessuno
        current_token = ''
        current_token_timestamp = datetime.now () - timedelta (giorni = 1)

        mentre W1Service.is_scanning:
            file = open ('/ sys / devices / w1_bus_master1 / w1_master_slaves')
            all_tokens = file.readlines ()
            file.close ()

            no_token_attached = len (all_tokens) == 0 o 'non trovato. \ n' in all_tokens
            if no_token_attached e self.on_all_token_removed e current_token! = last_token:
                self.on_all_token_removed ()
                current_token = Nessuno
                last_token = Nessuno
per la riga in all_tokens:
                current_token = line.split ("\ n") [0]
                time_diff = datetime.now () - current_token_timestamp
                se self.on_token_added e last_token! = current_token e time_diff.seconds > = 3:
                    # Verifica se il token è ancora allegato
                    se os.path.exists ('/ sys / bus / w1 / devices /' + current_token + '/ w1_slave'):
                        self.on_token_added (current_token)
                        last_token = current_token
                    altro:
                        current_token = Nessuno
                altro:
                    current_token = Nessuno

            time.sleep (ritardo)

    def stop_scan (self):
        W1Service.is_scanning = False
 

Ora utilizzare il servizio creato è abbastanza semplice:

  ora di importazione
import w1_service

def token_added (token):
    print (token% "connesso% s")

def all_token_removed ():
    print ("Tutti i token sono stati rimossi")

servizio = w1_service.W1Service ()
service.on_token_added = token_added
service.on_all_token_removed = all_token_removed
service.start_scan (0)

mentre True:
    # La scansione viene eseguita in un thread separato
    time.sleep (1)
 

Questo produrrà il seguente output quando si inseriscono diversi token

  Tutti i token sono stati rimossi
Collegato 28-00000aabbccd
Tutti i token sono stati rimossi
Collegato 28-00000ffddeea
Tutti i token sono stati rimossi
Collegato 28-00000bbddaa1
Collegato 28-00000ffddeea
Tutti i token sono stati rimossi
Collegato 28-00000bbddaa1
Tutti i token sono stati rimossi
 

Tieni presente che il mio codice tiene conto del fatto che nella mia configurazione è possibile aggiungere un solo token alla volta. Quindi solo il token più recente è interessante per me. Se si devono aggiungere più token, che il protocollo onewire supporta bene, il codice dovrebbe essere aggiornato.

Applicazione

Ora ogni volta che viene inserito un token, viene abbinato a una persona da cui il mio gentile può inviare messaggi e ricevere messaggi

Note e altre considerazioni

I token Onewire potrebbero in teoria essere aggiunti in parallelo, il che offrirebbe nuove funzionalità come chat di gruppo o simili. Quindi potresti collegare dieci token su un singolo GPIO.

Mi piace anche l'approccio con l'approccio R / C passivo, che è molto pragmatico e anche semplice da configurare. Potrei provarlo in un altro progetto. Tuttavia, un amico ne aveva un po '

Ho preso in considerazione l'aggiunta di iBeacons come token, ma poi avrei dovuto tenere conto di diversi RSSI dei token e non sarebbe chiaro al 100% quale token fosse attivo in un dato momento.

Un amico ha suggerito di aggiungere un lettore di schede e utilizzare vecchie schede SD fotografiche da 1 GB che potrebbero avere l'immagine bloccata sul davanti. La scheda potrebbe contenere tutte le informazioni sulla persona più un saluto personalizzato o simili. Lo stesso funzionerebbe con le vecchie chiavette USB come token.

È stato estremamente divertente implementarlo e vedere quanto interesse ha suscitato la mia domanda nelle persone. Vi ringrazio tutti e vi auguro un bel 0x1414 (= 2020) :-)

TL; DR: rilevatore RFID / NFC / "metallo" dei poveri.

Se vuoi essere un po 'sofisticato, potresti usare un circuito (R) CL sintonizzato. L'idea sarebbe quella di caricare un circuito del serbatoio LC elettromagneticamente, quindi osservare le oscillazioni dell'anello / decadimento. Dove ogni token sarebbe identificato da una frequenza univoca. Quindi, non avresti nemmeno bisogno dei contatti!

Questa idea è come una primitiva comunicazione in campo vicino o un primitivo metal detector. Sarebbe costruito qualcosa di simile al seguente ...

^{simula questo circuito - Schema creato utilizzando CircuitLab}

(PI) Il Pi ha una bobina elettromagnetica, alimentata da un semplice driver a transistor sporco. Questo è eccitato con un segnale CA sintetico o CC pulsato. Questo lato si comporta come il lato principale di un trasformatore.

(Token) Il token è una bobina elettromagnetica identica, con almeno un condensatore collegato. Con solo questo, dovrebbe risuonare con la ben nota formula di risonanza LC quando energizzato. Questo lato agisce come il secondario di un trasformatore.

Operazione

Quando avvicini le due bobine l'una all'altra (molto vicine ... come ... praticamente si toccano) la potenza si trasferirà dal lato Pi, al lato token. Questo (rispetto alle ottave compatibili della frequenza fornita!) Ecciterà il token con oscillazioni. Quando rimuovi il segnale di guida del lato primario, il token "continuerà a funzionare per un po '" che, a sua volta, sarà rilevabile dalla bobina del lato primario.

In alternativa, l'aggiunta della seconda bobina ha anche l'effetto di aggiungere fondamentalmente il condensatore del token al condensatore del lato RPi in parallelo. Ciò ridurrà la frequenza di risonanza del serbatoio LC lato RPi della quantità di capacità che il token detiene.

Entrambi i metodi sono potenzialmente utilizzabili per separare i token.

È possibile utilizzare un filtro passa-basso (pin1-resistor-pin2-capacitor-ground), configurare pin1 per l'uscita 1 e monitor / sample pin2 fino a quando non si imposta su 1.

Ora gira pin1 su 0 e monitora pin2 (sample - controlla il tempo quanto tempo impiegherà) finché non si imposta su 0.

Alterando i valori di resistenza e condensatore si ottengono diversi ritardi time che ti consentiranno di distinguish diversi tokens associati a una determinata persona.

Questa soluzione è stata utilizzata molto prima che ADC diventasse parte degli MCU.

Bene, per progetti di questo tipo userei Arduino (o solo Atmega8 / 16 / 32 chip) - costo minimo e facile da lavorare.

Raspbery Pi ha così tanto potere che è molto wasteful da utilizzare per un progetto così semplice.

Puoi tranquillamente scegliere ogni secondo un valore dell'1% e ottenere azioni da Digikey per 15 centesimi ciascuno.

Il resistore a film metallico da 1/4 W può essere inserito all'interno di una vite di plastica su un connettore da 3,5 mm, saldato e quindi sigillato con adesivo sottopavimento (poliuretano) se si desidera nasconderlo.

L'uso di un valore da 10k a 20k ha valori sufficienti.L'utilizzo di un pullup da 100k a Vref consente di utilizzare lo stesso input per rilevare uno "0" logico per riattivare l'unità, con il 10-20% di Vdd che funzionerà.

Un cappuccio in ceramica da 0,1uF può essere deviato sullo stesso pin per shuntare le scariche ESD e impedire ai contatti intermittenti di modificare la tensione più di dV / dt = V / RC