I2c-kommunikation på nuvoton mikrokontroller

I det stora systemet med inbäddade applikationer kan ingen mikrokontroller utföra alla aktiviteter på egen hand. Vid någon tidpunkt måste den kommunicera till andra enheter för att dela information, det finns många olika typer av kommunikationsprotokoll för att dela dessa informationer, men de mest använda är USART, IIC, SPI och CAN. Varje kommunikationsprotokoll har sina egna fördelar och nackdelar. Låt oss fokusera på IIC-delen för nu eftersom det är vad vi ska lära oss i denna handledning. Om du är ny här, kolla in Nuvoton Tutorials där vi har diskuterat varje kringutrustning av N76E003 Microcontroller från den grundläggande handboken. Om du vill lära dig att använda I2C med andra mikrokontroller kan du kolla in länkarna nedan.

Hur man använder I2C i Arduino: Kommunikation mellan två Arduino-kort
I2C-kommunikation med PIC-mikrokontroller PIC16F877
Gränssnitt 16X2 LCD med ESP32 med I2C
I2C-kommunikation med MSP430 Launchpad
Gränssnitt LCD med NodeMCU utan att använda I2C
Hur man hanterar multikommunikation (I2C SPI UART) i ett enda Arduino-program

I2C är ett viktigt kommunikationsprotokoll som utvecklats av Philips (nu NXP). Med hjälp av detta I2C-protokoll kan en MCU anslutas till flera enheter och starta kommunikation. I2C fungerar med endast två ledningar, nämligen SDA och SCL. Där SDA står för Serial data och SCL står för Serial Clock. Dessa två stift kräver emellertid pull-up-motstånd till VCC-spänningsnivån och med ett adekvat pull-up-motstånd kan bussen stödja 127 enheter med en unik adress.

Vad är I2C-kommunikationsprotokoll?

Termen IIC står för " Inter Integrated Circuits ". Det betecknas normalt som I2C eller I kvadrat C eller till och med som 2-tråds gränssnittsprotokoll (TWI) på vissa ställen men allt betyder detsamma. I2C är ett synkron kommunikationsprotokoll som betyder att båda enheterna som delar informationen måste dela en gemensam klocksignal. Den har bara två ledningar för att dela information varav den ena används för klocksignalen och den andra används för att skicka och ta emot data.

Hur fungerar I2C-kommunikation?

I2C-kommunikation introducerades först av Phillips. Som sagt tidigare har den två ledningar, dessa två ledningar kommer att anslutas över två enheter. Här kallas en enhet en master och den andra enheten kallas en slav. Kommunikation bör och kommer alltid att ske mellan två, en mästare och en slav. Fördelen med I2C-kommunikation är att mer än en slav kan anslutas till en mästare.

Den fullständiga kommunikationen sker via dessa två ledningar, nämligen Serial Clock (SCL) och Serial Data (SDA).

Serial Clock (SCL): Delar klocksignalen som genereras av mastern med slaven

Serial Data (SDA): Skickar data till och från mellan Master och slav.

Vid varje given tidpunkt är det bara befälhavaren som kan initiera kommunikationen. Eftersom det finns mer än en slav i bussen måste befälhavaren hänvisa till varje slav med en annan adress. När den bara adresseras kommer salven med den specifika adressen att svara med informationen medan de andra håller tyst. På så sätt kan vi använda samma buss för att kommunicera med flera enheter.

Var ska jag använda I2C-kommunikation?

I2C-kommunikation används endast för kortdistanskommunikation. Det är verkligen tillförlitligt i viss utsträckning eftersom det har en synkroniserad klockpuls för att göra det smart. Detta protokoll används främst för att kommunicera med sensorn eller andra enheter som måste skicka information till en master. Det är mycket praktiskt när en mikrokontroller måste kommunicera med många andra slavmoduler med ett minimum av endast ledningar. Om du letar efter långväga kommunikation bör du prova RS232 och om du letar efter mer tillförlitlig kommunikation bör du prova SPI-protokollet.

I2C på Nuvoton N76E003 - Hårdvarukrav

Eftersom kravet i detta projekt är att lära sig I2C-kommunikation med N76E003 kommer vi att använda en EEPROM som kommer att anslutas till I2C-datalinjen. Vi lagrar en del data i EEPROM och läser också samma och visar den med UART-skärmen.

Eftersom det lagrade värdet kommer att skrivas ut i UART krävs alla typer av USB till UART-omvandlare. Du kan också kolla in handboken om UART med Nuvoton om du inte är ny i UART-kommunikation på N76E003. För vår applikation använder vi CP2102 UART till USB-omvandlare. Förutom ovanstående kräver vi också följande komponenter-

EEPROM 24C02
2st 4,7k motstånd

För att inte nämna, förutom ovanstående komponenter, behöver vi ett N76E003-mikrokontrollerbaserat utvecklingskort samt Nu-Link-programmeraren. Dessutom krävs paneler och anslutningskablar för att ansluta alla komponenter.

Gränssnitt AT24LC64 med Nuvoton N76E003 - Kretsschema

Som vi kan se i schematiska nedan är EEPROM ansluten i I2C-linjen tillsammans med två uppdragningsmotstånd. Längst till vänster visas programmeringsgränssnittsanslutningen.

Jag använde ett brödbräda för AT24LC64 IC och kopplade IC till mitt nuvoton programmerarkort med hjälp av bygeln. Min hårdvaruinstallation tillsammans med nu-ink-programmeraren visas nedan.

I2C-stift på Nuvoton N76E003

Stiftdiagrammet för N76E003 kan ses i bilden nedan-

Som vi kan se har varje stift olika specifikationer och varje stift kan användas för flera ändamål. Dock är stift 1,4 används som I2C SDA stift, kommer det att förlora PWM och andra funktioner. Men det är inte ett problem eftersom det inte krävs någon annan funktionalitet för detta projekt. Samma sak kommer att hända för P1.3 är SCL-stiftet på I2C.

Eftersom I2C-stift fungerar som en GPIO, måste den konfigureras. Alla GPIO-stift kan konfigureras i läget nedan.

Enligt databladet PxM1.n och PxM2. n är två register som används för att bestämma I / O-portens styrfunktion. I databladet anges att för att använda I2C-funktionaliteten måste I / O-lägen användas som Open-drain för I2C-relaterad kommunikation.

I2C-kommunikation i N76E003

I2C-kringutrustningen är en viktig sak för alla mikrokontroller som stöder I2C-funktioner. Många typer av olika mikrokontroller levereras med en inbyggd kringutrustning I2C. I vissa fall kan dock I2C konfigureras manuellt med hjälp av programvarukontroll där I2C-relaterad hårdvarustöd inte är tillgänglig (till exempel många 8051 mikrokontroller). Nuvoton N76E003 kommer dock med I2C perifert stöd.

M76E003 stöder fyra typer av operationer i I2C-lägen - huvudsändare, huvudmottagare, slavsändare och slavmottagare. Den stöder också standardhastigheter (100 kbps) och snabba (upp till 400 kbps) hastigheter för I2C-linjen. I2C fungerar med få generiska regler i SCL- och SDA-signallinjerna.

Start- och stoppvillkor:

Det är en viktig sak i I2C-kommunikation. När data överförs till I2C-linjen börjar det med startvillkor och slutar med ett stoppvillkor.

Startvillkoret är hög-till-låg-övergången på SDA när SCL-linjen är hög och stopptillståndet är låg-till-hög-övergången på SDA när SCL-linjen är hög. Dessa två villkor genereras av mastern (MCU eller något som styr de andra slavenheterna). Bussledningen förblir upptagen i detta tillstånd när startvillkoret initieras och förblir fritt igen när stopptillståndet initieras.

Start- och stoppvillkoret visas utmärkt i signalperspektivet i databladet N76E003-

7-bitars adress med dataformat:

N76E003 stöder en 7-bitars adress och dataformat. Efter att startvillkoret har initierats måste masterenheten skicka data till I2C-linjen. De första uppgifterna är viktiga. Om dessa data inte skapas eller överförs ordentligt identifieras inte den anslutna enheten och ytterligare kommunikation kan inte göras.

Data består av en 7-bitars lång slavadress, betecknad som SLA. Den här 7-bitars långa adressen måste vara unik för varje enhet om flera enheter är anslutna på bussen. Efter 7-bitarsadressen är den 8: e biten datariktningsbit. Beroende på den åttonde biten skickar master informationen till slavenheten om huruvida data kommer att skrivas i slavenheten eller om data kommer att läsas från slavenheten. Den åttonde biten är R / W-biten som kallas läs- eller skrivmeddelande. Som vi alla vet kan 8-bitars information vara 128 typer, vilket stöder 128 enheter, men I2C stöder 127 typer av enheter på samma buss men inte 128. Eftersom 0x00-adressen är en reserverad adress som kallas en allmän samtalsadress. Om befälhavaren vill skicka information till alla enheter,den kommer att adressera 0x00 och varje enhet kommer att spela på samma sätt som per enskild programvarukonfiguration.

Således ser dataöverföringen ut som nedan-

Erkänna:

I ovanstående dataadressbild kallas den nionde biten följt av R / W-biten bekräftelsebiten. Det är viktigt eftersom master eller slav använder denna bit för att svara på datasändaren genom att dra SDA-linjen lågt. För att få bekräftelsebiten måste sändaren släppa SDA-linjen.

Programmering N76E003 för I2C-kommunikation

Det kompletta programmet som används i denna handledning finns längst ner på denna sida. Förklaringen till viktiga segment i koden är följande:

Ställ in stiften som öppet avlopp och konfigurera dem för I2C:

Låt oss börja med I2C-stiftavsnittet först. Som beskrivits tidigare måste I2C SCL- och SDA-portarna konfigureras och ställas in som open-drain-konfiguration. För att göra detta använder vi en I2C.h-rubrikfil tillsammans med en I2C.c-källfil . Kodavsnittet ser ut så här-

gör {P13_OpenDrain_Mode; P14_OpenDrain_Mode; clr_I2CPX;} medan (0)

Ovanstående kod ställer in P13 och P14 som Open-Drain-stift och clr_I2CPX används för att välja P13 och P14 som SCL-stift på P1.3 och SDA-stift på P1.4.

Denna I2CPX är den 0: e biten av I2C-kontrollregistret I2CON. Om denna I2C_PX är inställd på 1 ändras stiften till P0.2 som SCL och P1.6 som SDA. Vi kommer dock att använda P13 och P14. Alternativa stift används inte här.

I2C-kontrollregister I2CON:

I2C-kontrollregistret I2CON används för att styra I2C-operationerna. Den första biten är I2C-stiftvalsbiten. Om du ställer in 0 konfigureras I2C-stiftet som P13 och P14.

AA-bit är bekräftelseflaggan, om AA-flaggan är inställd kommer en ACK att returneras under bekräftelseklockpulsen på SCL-linjen. Om det rensas kommer ett NACK (hög nivå på SDA) att returneras under SCL-linjens bekräftade klockpuls.

Nästa bit är SI som är I2C-statusavbrottet. Om I2C-statusavbrott är aktiverat bör användaren kontrollera I2STAT-registret för att avgöra vilket steg som har passerat och bör vidta åtgärden.

STO är STOP-flaggan som ställs in i huvudläge. STO rensas automatiskt av hårdvara när STOP- tillståndet har upptäckts.

Nästa bit är STA-biten. Om denna flagga är inställd genererar I2C ett START-tillstånd om bussen är ledig. Om bussen är upptagen väntar I2C på ett STOP-tillstånd och genererar ett START-tillstånd som följer. Om STA är inställt medan I2C redan är i mastermod och en eller flera byte har sänts eller mottagits, genererar I2C ett upprepat START-tillstånd. STA måste rensas manuellt av programvaran.

Den sista, I2CEN är I2C-bussens aktiverings- eller inaktiveringsbit.

EEPROM 24C02:

Kommer nu till 24C02. Kortstödspaketet för N76E003 har en I2C-kod för 24LC64 och kan enkelt modifieras. Vi kommer dock att använda en enkel metod för att förstå I2C-funktionen.

Om någon vill använda detaljerad gränssnitt med EEPROM 24C02, kan EEPROM-programmet i BSP användas.

Vi ansluter bara 24C02 i I2C där N76E003 kommer att vara master och EEPROM kommer att vara en slav. Således kommer vi att skriva in data till EEPROM-adressen och läsa samma.

24C02 EEPROM pinout visas nedan-

A0, A1 och A2 är tre stift för adressval. WP-stiften är skrivskyddsstift och måste anslutas till VSS för att möjliggöra skrivning till EEPROM.

Funktionen Byte Write visas i bilden nedan-

Hela skrivcykeln sker med en startbit. Därefter måste kontrollbyten skickas in. I kontrollbyte krävs följande saker -

Efter startbiten består av slavadressen. 1010 är det statiska och A0, A1 och A2 är den maskinvaruanslutningsbaserade adressen. Om de tre stiften är anslutna med GND- eller VSS-matning kommer den att läsas som 0. Om den annars är ansluten till VCC kommer den att läsas som 1. I vårt fall är alla A0, A1 och A2 anslutna till VSS. Således kommer alla dessa att vara 0.

Spenderar på läs- eller skrivvillkor. Värdet på adressen med läs- eller skrivbiten blir - 0xA0 för skriv och 0xA1 för läsning. Nästa är bekräftelsebiten och efter det kommer en 8-bitars adress att överföras där data måste lagras och slutligen de data som kommer att lagras på respektive plats. Dessa saker görs i steg för steg-format i huvudfunktionen.

Huvudfunktion och While Loop:

ogiltigt huvud (ogiltigt) {char c = 0x00; InitialUART0_Timer3 (115200); TI = 1; // Viktigt, använd skrivfunktionen måste ställa in TI = 1; I2C_init (); medan (1) {EEPROM_write (1,0x55); c = EEPROM_read (1); printf ("\ n Det lästa värdet är% x", c & 0xff); }; }

Huvudfunktionen är enkel, den skriver kontinuerligt värden till EEPROM i adressen 1 och läser data. Data skrivs sedan ut med printf-funktionen. Printf skriver ut värdet i hex.

EEPROM-skrivfunktionen består av följande saker som beskrivs i avsnittet EEPROM-

ogiltig EEPROM_write (osignerad char-adress, osignerad char-värde) {I2C_start (); I2C_write (0xA0); I2C_write (adress); I2C_write (värde); I2C_stop (); }

I2C startfunktion består av följande saker-

ogiltigt I2C_start (ogiltigt) {signerad intid = timeout; set_STA; clr_SI; medan ((SI == 0) && (tid> 0)) {tid--; }; }

I den här funktionen kontrolleras SI-status tillsammans med den fördefinierade timeoutperioden (definierad i I2C.h där den fördefinierade tiden är inställd på 1000). Startfunktionen börjar med att ställa in STA och rensa SI.

ogiltigt I2C_stop (ogiltigt) {undertecknat int time = timeout; clr_SI; set_STO; medan ((STO == 1) && (tid> 0)) {tid--; }; }

Samma som Start, stop-funktionen används. Den stoppfunktionen initieras genom att inrätta STO följt av att rensa SI. Nedanför funktionen är I2C läsfunktion-

osignerad char I2C_read (osignerad char ack_mode) {signerad intid = timeout; osignerat teckenvärde = 0x00; set_AA; clr_SI; medan ((SI == 0) && (t> 0)) {tid--; }; värde = I2DAT; if (ack_mode == I2C_NACK) {t = timeout_count; clr_AA; clr_SI; medan ((SI == 0) && (t> 0)) {tid--; }; } returvärde; }

Den ack_mode och I2C_NACK , båda är definierade i I2C sidhuvudfilen som 0 och 1 respektive.

På samma sätt skapas skrivfunktionen-

ogiltigt I2C_write (osignerat teckenvärde) {signerad int-time = timeout; I2DAT = värde; clr_STA; clr_SI; medan ((SI == 0) && (tid> 0)) {tid--; }; }

Blinkar koden och utdata

Koden returnerade 0 varning och 0 fel och blinkade med hjälp av standardblinkningsmetoden av Keil. Om du är ny, kolla in igång med nuvoton tutorial för att förstå hur du laddar upp kod. Kodens sammanställningsinformation finns nedan.

Bygg mål 'I2C_EEPROM' som sammanställer I2C_EEPROM.c… sammanställer I2C.c… länkar… Programstorlek: data = 59.2 xdata = 0 kod = 2409 skapar hexfil från ". \ Output \ I2C_EEPROM"… ". \ Output \ I2C_EEPROM "- 0 Fel, 0 Varning (ar). Byggtid förfluten: 00:00:04 Sammanfattning av batch-byggnad: 1 lyckades, 0 misslyckades, 0 hoppades över - Tid förfluten: 00:00:04

Maskinvaran sätts upp på en bräda och fungerar som förväntat. Som du kan se på bilden nedan kunde vi skriva ett värde på EEPROM och läsa det tillbaka från minnet och visa det på den seriella bildskärmen.

Kolla in videon nedan för en fullständig demonstration av hur styrelsen fungerar för den här koden. Hoppas att du gillade handledningen och lärde dig något användbart om du har några frågor, lämna dem i kommentarsektionen nedan. Du kan också använda våra forum för att skicka andra tekniska frågor.