Zo heb ik eindelijk de fantastische aanpak geïmplementeerd die is geschetst door VillageTech.

Hardware

Bedrading

De standaardpin voor Onewire-apparaten op de Pi is GPIO 4 . Dus ik bedraad GND naar de huls van de stekker en verbond de punt met de genoemde GPIO-pin.

Een token

Alles wat ik nodig heb voor een token is de DS18B20-chip en een 3,5 mm jack. Soldeer vervolgens de GND- en VCC-pin van de chip aan elkaar en sluit deze aan op de hoes. Voeg wat krimpkous toe aan de middelste pin om kortsluiting te voorkomen en sluit deze aan op het uiteinde van de aansluiting.

Beide krikken werken met twee ringen en met alleen de punt.

Trek weerstand

Ik heb besloten geen externe pull-up-weerstand te gebruiken, aangezien de Pi interne pull-up-weerstanden heeft.

Laten we geen koptelefoon bakken

Zoals fout terecht werd opgemerkt, is het feit dat mensen in de verleiding kunnen komen om een ​​koptelefoon aan te sluiten als het eruitziet als een 3,5 mm audio-aansluiting.

Zolang we parasitaire stroom gebruiken, waarbij alleen een aardedraad en een GPIO-uitgang met hoge impedantie wordt blootgesteld aan het stopcontact, zouden we veilig moeten zijn, aangezien we geen V _{DD sub hebben > lijn die kortsluiting kan veroorzaken door de lage weerstand van de hoofdtelefoon.}

Configuratie

Voeg de volgende regel toe aan /boot/config.txt :

  dtoverlay = w1-gpio
 

Er zijn meer opties. Je kunt meer vinden in de / boot / overlays / README van je Pi.

Sommige bronnen stelden voor om de twee modules w1-gpio en w1_therm toe te voegen aan / etc / modules , maar ik ontdekte dat het apparaat -tree overlay-invoer in de boot / config.txt was voldoende voor mijn doeleinden.

Start het apparaat nu opnieuw op.

Voeg een pullup toe via software in python:

  importeer RPi.GPIO als GPIO
GPIO_PIN_NUMBER = 14
GPIO.setmodus (GPIO.BCM)
GPIO.setup (GPIO_PIN_NUMBER, GPIO.IN, pull_up_down = GPIO.PUD_UP)
 

Zodra ik deze pull-up had gemaakt, kon ik de tokens detecteren in / sys / bus / w1 / devices / met het voorvoegsel 28 in een ander terminalvenster:

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

Na ongeveer 10 seconden zouden de vermeldingen in devices verdwijnen. Ik moest de volgende configuratie maken, zodat de apparaten na een seconde of zo zouden verdwijnen:

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

Voeg nu de inhoud toe aan het bestand en start het apparaat opnieuw op:

  opties draad timeout = 1 slave_ttl = 1
 

In mijn setup bestond dit bestand niet eerder.

Software

Ik heb een python-klasse gemaakt die naar veranderingen in het bestandssysteem zou zoeken en me zou vertellen of een nieuw token was verbonden of dat alle tokens waren losgekoppeld.

  import os
draad importeren
import tijd
van datetime import datetime, timedelta


klasse W1Service (object):
    __instance = Geen

    def __new __ (cls):
        # Singleton initializer
        als W1Service .__ instantie geen is:
            W1Service .__ instantie = object .__ nieuw __ (cls)
        retourneer W1Service .__ instantie

    on_all_token_removed = Geen
    on_token_added = Geen
    is_scanning = False

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

    def scan (zelf, vertraging = 10):
        W1Service.is_scanning = Waar
        last_token = Geen
        current_token = ''
        current_token_timestamp = datetime.now () - timedelta (dagen = 1)

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

            no_token_attached = len (all_tokens) == 0 of 'niet gevonden. \ n' in all_tokens
            if no_token_attached en self.on_all_token_removed en current_token! = last_token:
                self.on_all_token_removed ()
                current_token = Geen
                last_token = Geen
voor regel in all_tokens:
                current_token = line.split ("\ n") [0]
                time_diff = datetime.now () - current_token_timestamp
                if self.on_token_added en last_token! = current_token en time_diff.seconds > = 3:
                    # Test of het token nog steeds is bevestigd
                    if os.path.exists ('/ sys / bus / w1 / devices /' + current_token + '/ w1_slave'):
                        self.on_token_added (current_token)
                        last_token = huidig_token
                    anders:
                        current_token = Geen
                anders:
                    current_token = Geen

            time.sleep (vertraging)

    def stop_scan (zelf):
        W1Service.is_scanning = False
 

Het gebruik van de gemaakte service is nu vrij eenvoudig:

  importtijd
importeer w1_service

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

def all_token_removed ():
    print ('Alle tokens zijn verwijderd')

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

terwijl waar:
    # De scan loopt in een aparte thread
    time.sleep (1)
 

Dit levert de volgende uitvoer op bij het invoegen van verschillende tokens

  Alle tokens zijn verwijderd
Verbonden 28-00000aabbccd
Alle tokens zijn verwijderd
Verbonden 28-00000ffddeea
Alle tokens zijn verwijderd
Verbonden 28-00000bbddaa1
Verbonden 28-00000ffddeea
Alle tokens zijn verwijderd
Verbonden 28-00000bbddaa1
Alle tokens zijn verwijderd
 

Houd er rekening mee dat mijn code rekening houdt met het feit dat in mijn setup slechts één token tegelijk kan worden toegevoegd. Dus alleen het nieuwste token is interessant voor mij. Als er meerdere tokens zouden moeten worden toegevoegd, wat het onewire-protocol goed ondersteunt, zou de code moeten worden bijgewerkt.

Applicatie

Telkens wanneer een token wordt ingevoegd, wordt deze gekoppeld aan een persoon van wie mijn aardige berichten kunnen verzenden en ontvangen van

Opmerkingen en andere overwegingen

De Onewire-tokens zouden in theorie parallel kunnen worden toegevoegd, wat nieuwe mogelijkheden zou bieden, zoals groepschat en dergelijke. U kunt dus tien tokens op één GPIO aansluiten.

Ik hou ook van de aanpak met de passieve R / C-benadering, die erg pragmatisch is en ook eenvoudig op te zetten. Ik zou dit in een ander project kunnen proberen. Een vriend had er echter een paar

Ik heb overwogen om iBeacons toe te voegen als tokens, maar dan zou ik rekening moeten houden met verschillende RSSI van de tokens en het zou niet 100% duidelijk zijn welk token op een bepaald moment actief was.

Een vriend stelde voor om een ​​kaartlezer toe te voegen en oude foto-SD-kaarten van 1 GB te gebruiken waarvan de foto op de voorkant zou kunnen blijven plakken. De kaart kan alle informatie over de persoon bevatten plus een persoonlijke begroeting of iets dergelijks. Hetzelfde zou werken met oude USB-sticks als tokens.

Het was ontzettend leuk om dit te implementeren en om te zien hoeveel interesse mijn vraag bij mensen opriep. Ik dank jullie allemaal en wens jullie een fijne 0x1414 (= 2020) :-)

TL; DR: arme man RFID / NFC / "metaaldetector".

Als je een beetje verfijnd wilt zijn, kun je een afgestemd (R) CL-circuit gebruiken. Het idee zou zijn om een ​​LC-tankcircuit elektromagnetisch op te laden en vervolgens de oscillaties van ring / verval te bekijken. Waar elk token zou worden geïdentificeerd door een unieke frequentie. Dan heb je niet eens contacten nodig!

Dit idee is als primitieve near field-communicatie, of een primitieve metaaldetector. Het zou zoiets als het volgende zijn opgebouwd ...

^{simuleer dit circuit - Schema gemaakt met CircuitLab}

(PI) De Pi heeft een elektromagnetische spoel, aangedreven door een simpele transistordriver. Dit wordt bekrachtigd met een synthetisch AC- of gepulseerd DC-signaal. Deze kant werkt als de primaire kant van een transformator.

(Token) Het token is een identieke elektromagnetische spoel, met ten minste een condensator eraan bevestigd. Hiermee zou het moeten resoneren met de bekende LC-resonantieformule wanneer het wordt geactiveerd. Deze zijde werkt als de secundaire zijde van een transformator.

Operatie

Als je de twee spoelen dicht bij elkaar brengt (echt heel dichtbij ... zoals .. eigenlijk aanraken), wordt de kracht overgedragen van de Pi-kant naar de token-kant. Dit zal (met betrekking tot compatibele octaven van de geleverde frequentie!) Het token met oscillaties van energie voorzien. Wanneer u het primaire zijaandrijfsignaal verwijdert, blijft het token "een tijdje doorgaan", wat op zijn beurt detecteerbaar is door uw primaire zijspoel.

Als alternatief heeft het toevoegen van de tweede spoel ook het effect dat het in feite gewoon de condensator van de token parallel aan de RPi-zijcondensator toevoegt. Dit verlaagt de resonantiefrequentie van de LC-tank aan de RPi-zijde met de hoeveelheid capaciteit die het token vasthoudt.

Beide methoden zijn mogelijk geschikt voor het scheiden van tokens.

U kunt een laagdoorlaatfilter gebruiken (pin1-resistor-pin2-capacitor-ground), pin1 configureren om 1 en monitor / sample pin2 uit te voeren totdat deze wordt ingesteld op 1.

Draai nu pin1 naar 0 en monitor pin2 (sample - houd in de gaten hoe lang het duurt) totdat het wordt ingesteld op 0.

Door de waarden van weerstand en condensator te veranderen, krijg je verschillende time vertragingen waarmee je distinguish verschillende tokens geassocieerd met een bepaalde persoon.

Deze oplossing werd gebruikt lang voordat ADC een onderdeel werd van MCU's.

Nou, voor dit soort projecten zou ik Arduino gebruiken (of gewoon Atmega8 / 16 / 32-chip) - minimale kosten en gemakkelijk om mee te werken.

Raspbery Pi heeft zoveel kracht dat het zeer wasteful kan gebruiken voor zo'n eenvoudig project.

U kunt veilig elke seconde 1% waarde kiezen en voor 15 cent per stuk aandelen krijgen van Digikey.

De 1 / 4W metaalfilmweerstand kan in een plastic schroef worden geschroefd tot een 3,5 mm-plug, gesoldeerd en vervolgens ingegoten met ondervloerlijm (polyurethaan) als je deze wilt verbergen.

Het gebruik van 10k tot 20k heeft voldoende waarden.Door een 100k Pullup naar Vref te gebruiken, kan dezelfde input worden gebruikt om een logische "0" te detecteren om de unit wakker te maken, met 10 tot 20% Vdd die zal werken.

Een keramische kap van 0.1uF kan tegen dezelfde pin worden geshunt om ESD-ontladingen te shunten en te voorkomen dat onderbroken contacten de spanning meer veranderen dan dV / dt = V / RC