1. ProgrammeringPython Hvad er I2C? Grundlæggende om Python-programmering til Raspberry Pi

Af Alan Shovic, John Shovic

Den første ting at vide om I2C er, at enhver enhed på I2C-bussen har en adresse. For eksempel har en HDC1080 temperatur- og fugtighedsføler, som du nemt kan oprette, en adresse på 0x40. Hvad betyder “0x” på denne adresse? Det betyder, at antallet, der følger, er i hexadecimal notation, base 16 i stedet for base 10 (vores normale nummereringssystem).

Lad os se på, hvad en I2C-bus er for at forstå denne grænseflade. En I2C-bus bruges ofte til at kommunikere med chips eller sensorer, der er på det samme bord eller placeret fysisk tæt på CPU'en. I2C blev først udviklet af Phillips (nu NXP Semiconductors).

For at komme rundt på licensproblemer (som stort set er forsvundet) kaldes bussen ofte TWI (Two Wire Interface). SMBus, udviklet af Intel, er en undergruppe af I2C, der definerer protokollerne mere strengt. Moderne I2C-systemer tager politikker og regler fra SMBus, som undertiden understøtter begge med minimal behov for omkonfiguration. Både Arduino og Raspberry Pi understøtter I2C-bussen.

I2C giver god support til langsomme, tæt perifere enheder, der kun skal rettes lejlighedsvis. For eksempel vil en temperaturmåleindretning generelt kun ændre sig meget langsomt, og det er også en god kandidat til brugen af ​​I2C, mens et kamera genererer masser af data hurtigt og potentielt ændrer ofte.

I2C bruger kun to tovejs åbne drænledninger (open-drain betyder, at enheden kan trække et niveau ned til jorden, men kan ikke trække linjen op til Vdd. Derfor navnet open-drain. Derfor er et krav til I2C-bus at begge linjer trækkes op til Vdd. Dette er et vigtigt område, og ikke at trække linjerne ordentligt er den første og mest almindelige fejl, du foretager, når du først bruger en I2C-bus.

Pi2Grover-tavlen indeholder 10K Ohm pullup-modstande, så du skal ikke behøver at bekymre dig om dette. De to linjer er SDA (seriel datalinje) og SCL (seriel urlinie). Der er to typer enheder, du kan oprette forbindelse til en I2C-bus: Master-enheder og Slave-enheder. Typisk har du en Master-enhed (Raspberry Pi, i vores tilfælde) og flere Slave-enheder, der hver har deres individuelle 7-bit-adresse.

Python-programmering og I2c

Når Raspberry Pi bruges på Raspberry Pi, fungerer den som Master og alle andre enheder er forbundet som slaver.

I2C-protokollen bruger tre typer meddelelser:

  • Digital enkeltmeddelelse, hvor en master skriver data til en slave Digital enkeltmeddelelse, hvor en master læser data fra en slave Digitale kombinerede meddelelser, hvor en master udsender mindst to læser og / eller skriver til en eller flere slaver

Heldig for dig er det meste af kompleksiteten ved at håndtere I2C-bussen skjult af Python-drivere og biblioteker.

Udforskning af I2C på Raspberry Pi

For at bruge I2C-bussen på Raspberry Pi, skal du sørge for, at den er aktiveret i operativsystemet. Se denne tutorial fra Adafrui9t om, hvordan man gør netop det.

Gjorde du det rigtigt? Den nemme måde at kontrollere for dette er at skrive følgende kommando i dit terminalvindue:

I2cdetect -y 1

Hvis det vender tilbage:

-bash: i2cdetect: kommando ikke fundet

Derefter har du ikke aktiveret din I2C-bus. Gentag selvstudiet for at løse dette.

På den anden side, hvis det vender tilbage:

0 1 2 3 4 5 6 7 8 9 a b c d e f
00: - - - - - - - - - - - - -
10: - - - - - - - - - - - - - - - -
20: - - - - - - - - - - - - - - - -
30: - - - - - - - - - - - - - - - -
40: - - - - - - - - - - - - - - - -
50: - - - - - - - - - - - - - - - -
60: - - - - - - - - - - - - - - - -
70: - - - - - - - -

Så har du haft succes! Bemærk, at alle bindestreger betyder, at der ikke er sensorer på I2C-bussen. Derefter vil du tilføje en enkel.

Lad os nu tale om, hvordan man kommunikerer med I2C-enheder i Python.

At tale med I2C-enheder med Python

For at tale med en I2C-enhed, skal du have en i bussen. En god en til at starte med er HDC1080 temperatur- og fugtighedsføler. (Du kan få en af ​​disse billige sensorer på store.switchdoc.com eller på amazon.com.

HDC1080 temperatur- og fugtighedsføler

Bemærk: Hvis du køber et på Amazon, har du brug for et patchkabel til kvinder til Grove. SwitchDoc Labs HDC1080 leveres allerede med et Grove-stik. Du har også brug for Pi2Grover Raspberry Pi-to-Grove-konverter, som også er tilgængelig på store.switchdoc.com eller på amazon.com.

Lad os nu installere HDC1080 I2C-sensoren på vores Raspberry Pi. Følg disse trin:

HDC1080
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: - - - - - - - - - - - - -
10: - - - - - - - - - - - - - - - -
20: - - - - - - - - - - - - - - - -
30: - - - - - - - - - - - - - - - -
40: 40 - - - - - - - - - - - - - - -
50: - - - - - - - - - - - - - - - -
60: - - - - - - - - - - - - - - - -
70: - - - - - - - -

Husker du 0x40-adressen på HDC1080? Der er det i output ovenfor.

Dernæst bruger du Python til at læse temperaturen og fugtigheden fra denne sensor.

Aflæsning af temperatur og fugtighed fra en I2C-enhed ved hjælp af Python

Brugen af ​​Python-biblioteker er nøglen til at være produktiv til at skrive Python-applikationer. Her bruger du SDL_Pi_HDC1080_Python3, tilgængelig på github.com.

Følg disse trin for at læse temperatur og fugtighed:

  1. Opret først et bibliotek i din hovedmappe: cd mkdir I2CT-temperatur cd I2CT-temperatur Nu er du i I2CT-temperaturkataloget. Inden du ser på Python-koden til at læse din temperatur, skal du installere biblioteket på vores Raspberry Pi. Du gør dette ved at "klone" biblioteket, der findes på github.com ved at bruge følgende kommando i dit terminalvindue: git klon https://github.com/switchdoclabs/SDL_Pi_HDC1080_Python3.git Her kloner git-klonen git-depotet, der findes på adressen, og kopierer det til din Raspberry Pi. Hvis du indtaster ls i terminalvinduet, vil du se følgende output: Brug nano (eller din favorit teksteditor) til at åbne en fil kaldet temperaturTest.py og indtast følgende kode:
importer sys
sys.path.append (' ./ SDL_Pi_HDC1080_Python3' )
importtid
import SDL_Pi_HDC1080
# Hovedprogram
Print
Print ("")
print ("Læs temperatur og fugtighed fra HDC1080 ved hjælp af I2C-bus")
Print ("")
hdc1080 = SDL_Pi_HDC1080.SDL_Pi_HDC1080 ()
mens sandt:
Print ("-----------------")
print ("Temperatur =% 3,1f C"% hdc1080.readTemperature ())
print ("Fugtighed =% 3,1f%%"% hdc1080.readHumidity ())
Print ("-----------------")
time.sleep (3,0)

Du læser nu miljødata fra en I2C-enhed. Din Raspberry Pi er forbundet med den virkelige verden.

Prøv dette eksperiment. Blæs på HDC1080-sensorkortet og se, at fugtigheden går op! Du vil se noget lignende:

Læs temperatur og fugtighed fra HDC1080 ved hjælp af I2C-bus
-----------------
Temperatur = 24,2 ° C
Fugtighed = 32,9%
-----------------
-----------------
Temperatur = 24,2 ° C
Fugtighed = 32,9%
-----------------
-----------------
Temperatur = 24,2 ° C
Fugtighed = 32,9%
-----------------

Afbrydelse af Python-programmet

Den første linje importerer Python sys-biblioteket:

importer sys

Den næste linje fortæller Python at søge i SDL_Pi_HDC1080_Python3-biblioteket under vores nuværende bibliotek, så den kan finde vores bibliotek:

sys.path.append (' ./ SDL_Pi_HDC1080_Python3' )

Mere import:

importtid
import SDL_Pi_HDC1080

Denne erklæring instantierer hdc1080-objektet og initialiserer det:

# Hovedprogram
Print
Print ("")
print ("Læs temperatur og fugtighed fra HDC1080 ved hjælp af I2C-bus")
Print ("")
hdc1080 = SDL_Pi_HDC1080.SDL_Pi_HDC1080 ()

Disse udsagn læser temperaturen og fugtigheden og udskriver dem til terminalvinduet. Bemærk: Du ser, at al kompleksiteten ved at bruge en I2C-enhed er skjult ved hjælp af HDC1080-biblioteket:

mens sandt:
Print ("-----------------")
print ("Temperatur =% 3,1f C"% hdc1080.readTemperature ())
print ("Fugtighed =% 3,1f%%"% hdc1080.readHumidity ())

Sov i tre sekunder, og gentag derefter:

Print ("-----------------")
time.sleep (3,0)

Nu når du har dette program, kan du tilføje alle mulige ting til det, såsom at tænde for en rød LED, hvis det bliver for varmt, eller tænde for en blå LED, hvis det bliver koldt.

Du kan endda tweet din temperatur og fugtighed ved hjælp af Twitter Python-biblioteket.