Komma igång med I2C -sensorgränssnitt ?? - Gränssnitt till din MMA8451 med ESP32: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

I den här självstudien lär du dig allt om hur du startar, ansluter och får I2C -enhet (Accelerometer) att arbeta med styrenhet (Arduino, ESP32, ESP8266, ESP12 NodeMCU)

Steg 1: Hur man kommer igång med I2C - Magnificent World of Inter IC Communication

Arduino, ESP -serien, PIC, Rasberry PI, etc. är alla otroliga. Men vad gör du med det när du har en?

Det bästa är att lägga till sensorer och sådant. Idag använder mycket av den heta nya tekniken I2C -protokollet för att låta datorn, telefonerna, surfplattorna eller mikrokontrollerna tala sensorerna. Smarta telefoner skulle vara mindre smarta om de inte kunde prata med accelerometersensorn för att veta åt vilket håll telefonen vetter.

Steg 2: Översikt över I2C

I2C är ett seriellt, synkront, halv duplex kommunikationsprotokoll som tillåter samexistens av flera mästare och slavar på samma buss. I2C -bussen består av två linjer: seriell datalinje (SDA) och seriell klocka (SCL). Båda linjerna kräver uppdragningsmotstånd.

SDA (Serial Data) - Linjen för master och slav att skicka och ta emot data. SCL (Serial Clock) - Linjen som bär klocksignalen. Med fördelar som enkelhet och låga tillverkningskostnader används I2C mestadels för kommunikation av kringutrustning med låg hastighet över korta avstånd (inom en fot).

Vill du lära dig mer om I2C? ……

Steg 3: Hur man konfigurerar I²C -sensorer

Innan du går in i projektet måste du förstå några grunderna i din sensor. Så häll på dig en kopp kaffe innan du dyker in:)? …

Den stora styrkan med I2C är att du kan sätta så många sensorer på samma fyra ledningar. Men för enheter med flera färdiga moduler anslutna kan du behöva ta bort några SMD-motstånd från utbrotten, annars kan pull-up på bussen bli för aggressiv.

Vilken information vill vi ha från databladet ??

1. Sensorfunktion
2. Pinouts och pins funktioner
3. Gränssnittsbeskrivning (Missa inte att titta på "I2c -adressvalsbord")
4. Registrerar !!

Allt är bra du hittar det enkelt men registrerar ?? REGISTER är helt enkelt minnesplatser inuti en I²C -enhet. Sammanfattningen av hur många register som finns i en given sensor och vad de styr eller innehåller kallas en registerkarta. Merparten av informationen i sensorns datablad handlar om att förklara hur varje register fungerar, och de kan vara ganska tröga att läsa igenom eftersom informationen sällan presenteras på ett direkt sätt.

För att ge dig en uppfattning om vad jag menar med det: Det finns många typer av register men för den här introduktionen kommer jag att gruppera dem i två allmänna typer: Kontroll- och dataregister.

1) Kontrollregister

De flesta sensorer ändrar hur de fungerar baserat på de värden som lagras i kontrollregistren. Tänk på kontrollregistren som banker för på/av-switchar, som du slår på genom att sätta lite till 1 och stänga av genom att ställa in den till 0. I²C-chipbaserade sensorer har ofta ett dussin eller fler driftinställningar för saker som bit- Lägen, avbrott, läs-skriv-kontroll, djup, samplingshastighet, brusreducering, etc., så du behöver vanligtvis ställa in bitar i flera olika kontrollregister innan du faktiskt kan ta en avläsning.

2) Dataregister Till skillnad från en kontrollregistrerar bank-of-switchar, tänker jag på datautmatningsregister som behållare som innehåller nummer som bara råkar lagras i binär form. Så du vill veta data, läs alltid dataregister som vem är jag för enhetsidentifiering, statusregister etc.

Så initialisering av en I²C-sensor är en process i flera steg och rätt ordningsföljd förklaras ofta skrivet i omvänd riktning, istället för en enkel i datablad. listan säger aldrig "För att få en avläsning från den här sensorn, gör (1), (2), (3), (4), etc", men du hittar beskrivningar av kontrollregistrets bitar som säger "innan du ställer in bit x i detta register måste du ställa in bit y i detta andra kontrollregister”.

Jag tycker fortfarande att ett datablad är mer interaktivt än de flesta texter. om du kommer att referera till det för en specifik bit eller information och det ger dig alla detaljer, kopplingar och referenser. Sätt dig ner och läs för att få ut alla dina referenser.:)

Steg 4: Börja med rörelse - accelerometer

Moderna accelerometrar är Micro Electro-Mechanical Systems (MEMS) -enheter, vilket innebär att de kan passa på ett litet chip inuti de minsta prylarna. En metod för att mäta acceleration som används av MEMS -accelerometrar är att använda en liten ledande massa hängande på fjädrar. Enhetens acceleration gör att fjädrarna sträcker sig eller dras ihop, och avledningen av den ledande massan kan mätas genom en kapacitetsförändring till närliggande, fasta plattor.

Accelerometrar specificeras med följande funktioner:

1. Antalet axlar, från en till tre axlar, märkta X, Y och Z i specifikationsdiagrammen. Observera att vissa accelerometrar kallas 6-axlar eller 9-axlar, men det betyder bara att de är buntade med andra MEMS-enheter som gyroskop och/eller magnetometrar. Var och en av dessa enheter har också tre axlar, varför det finns 3, 6 eller 9-axliga tröghetsmätningsenheter (IMU: er).
2. Typ av utgång, antingen analog eller digital. En digital accelerometer tar hand om att formatera accelerationsdata till en digital representation som kan läsas ut över I2C eller SPI.
3. Accelerationsområdet mätt i g, där 1g är accelerationen på grund av jordens gravitation.
4. Coprocessorer som kan ladda ner några av de beräkningar som behövs för att analysera rådata från MCU. De flesta accelerometrar har en enkel avbrottsförmåga att upptäcka en accelerationströskel (chock) och ett 0-g (fritt fall) tillstånd. Andra kan göra avancerad behandling av rådata för att erbjuda mer meningsfull data till MCU.

Steg 5: Gränssnitt med styrenhet

Eftersom vi känner till ESP Microcontrollers i trend kommer vi att använda ESP32 för vårt exempel. Så först behöver du en Nodemcu-32s.

Oroa dig inte om du har några andra ESP -kort eller till och med Arduino !!! Du behöver bara konfigurera din Arduino IDE och konfiguration enligt dina utvecklingskort, för Arduino, ESP NodeMCU, ESP32s etc … Du kommer också att behöva någon form av I2C -delar, vanligtvis på ett breakout -kort. I den här självstudien kommer jag att använda MMA8451 digital acceleratormätare.

Och några bygeltrådar ….

Steg 6: Anslutningar

Och här är en layout.

Jag använde följande anslutning från modulen ovan till min Nodemcu-32s-modul.

ESP32s - modul

3v3 - Vin

Gnd - Gnd

SDA 21 - SDA

SCL 22 - SCL

"Kom ihåg att oftast inte alla utvecklingsbrädor (mestadels i ESP) har en bra tydlig pinout för att avgöra vilka stift som används !! Så innan anslutning, identifiera din tavels rätt stift för att använda vilka stift som är för SDA och SCL."

Steg 7: Kod

Detta kräver Adafruit -biblioteket

från

Ladda ner, packa upp och du hittar mappen exempel, i mappen öppnar du bara MMA8451demo i din Arduino IDE och här är du …

du kommer att se följande kod för ditt MMA8451 sensorgränssnitt med din handkontroll

#omfatta

#include #include Adafruit_MMA8451 mma = Adafruit_MMA8451 (); void setup (void) {Serial.begin (9600); Wire.begin (4, 5); / * gå med i2c -buss med SDA = D1 och SCL = D2 för NodeMCU */ Serial.println ("Adafruit MMA8451 test!"); if (! mma.begin ()) {Serial.println ("Kan inte starta"); medan (1); } Serial.println ("MMA8451 hittades!"); mma.setRange (MMA8451_RANGE_2_G); Serial.print ("Range ="); Serial.print (2 << mma.getRange ()); Serial.println ("G"); } void loop () {// Läs "rå" data i 14-bitars räkningar mma.read (); Serial.print ("X: / t"); Serial.print (mma.x); Serial.print ("\ tY: / t"); Serial.print (mma.y); Serial.print ("\ tZ: / t"); Serial.print (mma.z); Serial.println (); / * Få en ny sensorhändelse */ sensors_event_t event; mma.getEvent (& event); / * Visa resultaten (acceleration mäts i m/s^2) */Serial.print ("X: / t"); Serial.print (event.acceleration.x); Serial.print ("\ t"); Serial.print ("Y: / t"); Serial.print (event.acceleration.y); Serial.print ("\ t"); Serial.print ("Z: / t"); Serial.print (event.acceleration.z); Serial.print ("\ t"); Serial.println ("m/s^2"); / * Få sensorns orientering */ uint8_t o = mma.getOrientation (); switch (o) {case MMA8451_PL_PUF: Serial.println ("Porträtt framåt"); ha sönder; fall MMA8451_PL_PUB: Serial.println ("Porträtt bakåt"); ha sönder; fall MMA8451_PL_PDF: Serial.println ("Porträtt nedåt"); ha sönder; fall MMA8451_PL_PDB: Serial.println ("Porträtt nedåt bakåt"); ha sönder; fall MMA8451_PL_LRF: Serial.println ("Landskap höger fram"); ha sönder; fall MMA8451_PL_LRB: Serial.println ("Landscape Right Back"); ha sönder; fall MMA8451_PL_LLF: Serial.println ("Landskap vänster fram"); ha sönder; fall MMA8451_PL_LLB: Serial.println ("Landscape Left Back"); ha sönder; } Serial.println (); fördröjning (1000); }

Spara, verifiera och ladda upp ……

Öppna den seriella bildskärmen och du kommer att se något liknande, jag rörde sensorn om därmed de olika avläsningarna

X: -2166 Y: 1872 Z: 2186

X: -2166 Y: 1872 Z: 2186X: -4,92 Y: 5,99 Z: 4,87 m/s^2

Landskap vänster fram

X: -224 Y: -2020 Z: 3188

X: -5,10 Y: -3,19 Z: 7,00 m/s^2

Porträtt på framsidan

Om allt gick som det skulle, så har du nu grunderna i I2C och hur du ansluter din enhet.

Men enheten fungerar inte ?? !

Fortsätt bara med nästa steg ……

Steg 8: Få din I2C -enhet att fungera

Grundläggande steg för att få I2C -enhetens arbete

Låt oss undersöka….

• Kabeldragning är korrekt.. (kolla igen)
• Programmet är korrekt.. (Ja, det är testexempel..)

Börja med etapper för att lösa ….

Steg 1: Kör I2C -enhetsskannerprogram för att kontrollera enhetsadress och först är din I2C -enhet ok

Du kan ladda ner skiss och kontrollera utdata.

Resultat - Enheten fungerar och sensoradressen stämmer

I2C -skanner. Läser in …

Hittad adress: 28 (0x1C) Klar. Hittade 1 enhet (er).

Steg 2: Kontrollera sensorbiblioteket

Öppna filen Adafruit_MMA8451.h och hitta enhetsadressen

Resultat - Adressen skiljer sig från min enhet ??.

/*=================================================== ========================== I2C ADRESS/BITS --------------------- ---------------------------------------------------------- * /#define MMA8451_DEFAULT_ADDRESS (0x1D) //! <Standard MMA8451 I2C -adress, om A är GND, dess 0x1C /*======================== ===================================================== */

Gör - Redigera fil från anteckningsblock (ändra adress) + Spara + Starta om IDE

Det fungerar. Du kan få dina avläsningar.

Tröskel inte….. ???

Steg 3: Kontrollera att Wire.begin skrivs över?

Öppna filen Adafruit_MMA8451.c och hitta Wire.begin.

Resultat - Detta uttalande skrivs över.

/************************************************* ************************* //*! @brief Konfigurerar HW (läser koefficientvärden, etc.)* / / *********************************** **************************************/ bool Adafruit_MMA8451:: begin (uint8_t i2caddr) {Wire.begin (); _i2caddr = i2caddr;

Gör - Redigera fil från anteckningsblock (kommentarsuttalande) + Spara + Starta om IDE

Och slutligen fungerar enheten☺ …

Jag överbelastar nästan den här självstudien eftersom dess huvudsakliga mål var att förklara hur man startar, hämtar data från datablad, ansluter och får I2C -enheten att fungera med ett mycket grundläggande exempel. Hoppas att allt kommer att gå som det ska, och det kommer att vara användbart att starta din sensor.