Nieuwe artikelen

5.4. Uitbreiding van digitale poorten voor NodeMCU ESP8266 met MCP23017-chip

We zullen LED-indicatie en geluidsalarm introduceren bij gebruik van de Nodemcu-module als smart home-controller. Het aantal pinnen op de Nodemcu module is veel minder dan op de Arduino Mega, dus we hebben de MCP23017 input expander IC nodig. De MCP23017-chip voegt 16 poorten toe die kunnen worden geconfigureerd voor zowel invoer als uitvoer (Figuur 5.7). De chip maakt gebruik van de populaire tweedraads I2C-bus.

Rijst. 5.7. MCP23017 pin-outs

Het adres van de MCP23017-chip voor het I2C-protocol kan worden ingesteld door een combinatie van signalen op de digitale ingangen A0 - A2 (Fig. 5.8), waarmee u 8 MCP23017-chips tegelijkertijd op de microcontroller kunt aansluiten, respectievelijk 16* 8=128 pinnen.

Rijst. 5.8. Het adres van de MCP23017-chip instellen

De chip heeft 2 poortenbanken A (GPA0-GPA7) en B (GPB0-GPAB), die elk kunnen worden geconfigureerd voor invoer of uitvoer.
Lijst 5.3. toont een voorbeeld van het opzetten van outputbanken A en B.

Lijst 5.3

// verbinding maken met de Wire.h-bibliotheek #erbij betrekken byte-invoer=0 ; ongeldige setup()(Serial.begin(9600); Wire.begin(0,2); // start I2C Wire.beginTransmission(0x20); // i2c - adres (A0-0,A1-0,A2-0) Draad.schrijven (0x00); // IODIRA registreer Wire.write (0x00); // stel POORT A in als uitvoer Wire.endTransmission(); ) lege lus(){ // lees gegevens van POORT B Wire.beginTransmission (0x20 ); Draad.schrijven (0x13); Wire.endTransmission(); Wire.requestFrom (0x20 , 1 ); input=Draad.lezen(); // schrijf ontvangen data naar PORT A Wire.beginTransmission (0x20 ); Draad.schrijven (0x12); // adres POORT A Wire.write (invoer); // POORT A Wire.endTransmission(); vertraging (100); // pauze)

Het gebruik van de MCP23017-chip zal het aantal digitale contacten van de Nodemcu-module met 16 uitbreiden en zal het organiseren van LED-indicatie en hoorbare signalering van kritische sensorparameters mogelijk maken.

Iedereen houdt van goedkope Arduino-boards, maar zo vaak mist een project letterlijk een of twee vrije poorten! En soms zijn er genoeg poorten, maar je wilt geen bundel draden naar een ander deel van de structuur trekken. Stel dat je meerdere knoppen en leds op het frontpaneel van het toestel moet plaatsen. Het is betrouwbaarder en gemakkelijker om ze op het moederbord aan te sluiten met slechts twee databusdraden, en niet met een kabel of een harnas, toch?

Voor dergelijke situaties zijn verschillende expanders (expanders) van Arduino-poorten ontworpen.

Doorgaans implementeren microcontroller-pinnen verschillende functies, dus uitbreidingen zijn anders:

1. Standaard GPIO-poortexpander
2. PWM-uitgangsuitbreiding
3. Analoge ingangsuitbreidingen - multiplexers en externe ADC's

Los daarvan is het vermeldenswaard digitaal-naar-analoog-converters (DAC's) en uitbreidingen van de I2C-busadresruimte. Deze apparaten dupliceren niet direct de functies van poorten, maar breiden de mogelijkheden van microcontrollers uit.

In het eerste artikel van de serie zullen we het hebben over de eenvoudigste en handigste uitbreidingen die werken als digitale I/O-poorten. Dit zijn microschakelingen en. Ze zijn gerangschikt en werken absoluut identiek en verschillen alleen in het aantal poorten.

Een uitbreidingsmodule voor Arduino kiezen

De meest populaire en goedkope module is gemaakt op de PCF8574-chip (Fig. 1)

Rijst. 1. Populaire PCF8574-poortuitbreidingsmodule

Voordelen:

• Lage prijs.
• Modules kunnen in een ketting worden aangesloten door simpelweg de stekkers van de ene module in de stopcontacten van de vorige te steken. Vergeet niet jumpers op verschillende module-adressen in te stellen!

nadelen:

• Kan niet rechtstreeks in een breadboard worden gestoken (ik raad aan om de poortconnector aan de achterkant te solderen).
• In totaal acht poorten in één module.

Als je in de stemming bent voor serieuzere projecten, bestel dan een 16-bits module voor PCF8575 op Aliexpress. Ik raad ten zeerste de module aan die wordt getoond in Fig. 2.

Rijst. 2. PCF8575-poortuitbreidingsmodule

Voordelen:

• Twee keer zoveel poorten.
• Ingebouwde 3.3V-voeding, u kunt andere modules van stroom voorzien.
• Ingebouwde logische niveau-aanpassing voor de I2C-bus bij verschillende voedingsspanningen.
• Handig formaat voor een breadboard.

nadelen:

• Boven prijs.

Hoe de PCF8574/PCF8575 GPIO-poortexpander werkt

Gegevensuitwisseling vindt plaats via de I2C-bus. Er zijn slechts vier draden nodig om verbinding te maken met het Arduino-bord, inclusief stroom. Het adres van de uitbreiding wordt ingesteld door drie jumpers op ingangen A0...A2, zodat acht identieke chips tegelijkertijd op de bus kunnen worden aangesloten en maximaal 8*8=64 extra poorten krijgen met PCF8574 of 8*16=128 met PCF8575 chippen.

Om gegevens naar de poort uit te voeren, schrijft u een gegevensbyte naar het adres van de module op de I2C-bus. Om gegevens van een poort te lezen, leest u een byte op hetzelfde adres. Een byte wordt altijd als een geheel geschreven en gelezen, het werken met individuele cijfers gebeurt programmatisch.

De uitgangen van de microschakeling zijn tegelijkertijd ingangen en er is geen serviceregister dat het doel van de uitgang bepaalt. Er is alleen een grendel waarin de uitvoerbyte wordt geschreven. Hoe is dit mogelijk?

De poorten werken op een open-collector manier en hebben interne pull-up weerstanden. Als er een logische nul naar de uitgang wordt geschreven, gaat de uitgangstransistor open, die de uitgang met geweld "naar aarde" trekt. Lezen van een dergelijke poort levert altijd nul op.

Wees voorzichtig bij het toepassen van een directe voedingsspanning op een pin met een laag niveau of als de stroom wordt overschreden 50 mA je verpest de chip!

Om een ​​poort als invoer te gebruiken, schrijft u er een één naar. In dit geval wordt de interne transistor gesloten en wordt het resultaat van het lezen bepaald door een extern logisch niveau dat op de pin wordt toegepast. De vrije uitgang wordt door een ingebouwde weerstand omhoog getrokken.

Om sommige van de poorten tegelijkertijd als input en sommige als output te gebruiken, voordat elke databyte naar de expander wordt geschreven, is het noodzakelijk om een ​​masker van eenheden toe te passen op die bits die overeenkomen met de inputs met behulp van de "logische OF"-bewerking . Dat is alles)))

generatie onderbreken

PCF857* poortuitbreidingen genereren onderbrekingspuls laag niveau op de INT-uitgang met elke verandering in het ingangssignaal op elke ingang van de microschakeling. Dit is handig als de uitbreiding een toetsenbord bedient. Maar u moet in de interrupt-handler bepalen welke knop is ingedrukt of losgelaten. De interruptgenerator is uitgerust met een chatteronderdrukkingsfilter.

Voorbeeld 1: Gebruik van de PCF8574-module

Laten we een eenvoudig circuit samenstellen van vier LED's, een PCF8574-module en een Arduino-bord (Fig. 3 en 4). Met dit schakelschema hebben we zelfs geen blusweerstanden voor LED's nodig. Er vloeit stroom door de LED en de ingebouwde weerstand is aangesloten op de stroomrail.

Rijst. 3. Bedradingsschema van de PCF8574-module

Rijst. 4. Circuitlay-out met PCF8574-module

Kopieer en plak schets 1 in het Arduino-bord:

// Module adres op de bus (A0, A1, A2 = 0) int adres = 0x38; // Gegevens gelezen van module uint8_t dataReceive; // Gegevens die naar de module moeten worden geschreven uint8_t dataSend; void setup () ( Wire.begin (); Serial.begin (9600); // Hoog naar alle PCF8574-poorten dataSend = B1111111; pcf8574_write (dataSend); ) void loop () ( // Lees een byte van module dataReceive = pcf8574_read (); // Uitvoer naar de monitor in binair formaat Serial.println (dataReceive, BIN); // Verschuif de bits naar links met een knabbel dataSend = dataReceive<< 4; // Накладываем битовую маску dataSend |= B00001111; // Записываем байт в модуль pcf8574_write(dataSend); delay(500); } // Процедура записи байта в модуль void pcf8574_write(uint8_t dt) { Wire.beginTransmission(address); Wire.write(dt); Wire.endTransmission(); } // Процедура чтения байта из модуля int8_t pcf8574_read() { Wire.beginTransmission(address); Wire.endTransmission(); Wire.requestFrom(address, 1); return (Wire.read()); }

Een hoog niveau wordt aanvankelijk naar alle poorten van de microschakeling geschreven, zodat poorten P0 ... P3 als ingangen kunnen werken.

De niveaus op de poortpinnen worden elke 500 ms uitgelezen en het meetresultaat wordt weergegeven op de monitor. Als u een van de P0...P3-ingangen op een gemeenschappelijke draad aansluit, verschijnt nul in zijn bit. Vervolgens wordt de leeswaarde vier bits naar links verschoven, het resultaat wordt naar de poort gestuurd en een van de LED's gaat uit. Als er bijvoorbeeld nul wordt gelezen op pin P0, gaat de LED die is aangesloten op pin P4 uit.

Merk op dat we voor elke schrijfactie naar de uitbreiding een bitmasker van enen moeten toepassen op alle bits die moeten worden ingevoerd: dataSend |= B00001111;

Subroutines voor het werken met de I2C-bus zijn enorm vereenvoudigd, er worden geen fouten verwerkt.

Advies: om het module-adres op de I2C-bus te vinden en te controleren, kunt u gebruiken. Het stuurt naar de terminal de adressen van alle apparaten die reageren op een busverzoek.

Voorbeeld 2: Gebruik van de PCF8575-module

De eigenaardigheid van de PCF8575-module is dat deze 16 poorten heeft, dus het is schrijf altijd twee bytes en lees twee bytes. Deze regel moet worden nageleefd, zelfs als de tweede byte niet nodig is.

Laten we het schema een beetje veranderen. We zullen de LED's verbinden met de poorten P10 ... P13 en we zullen de poorten P00 ... P03 met een jumper verbinden met de gemeenschappelijke draad (Fig. 5 en 6).

Rijst. 5. Bedradingsschema van de PCF8575-module

Rijst. 6. Circuitlay-out met PCF8575-module

Sketch 2 schrijft eerst enen naar alle poorten en leest vervolgens hun status elke 500 ms. De leesprocedure retourneert een 16-bits woord dat is verdeeld in bytes. De inhoud van de lage byte (pinnen P00…P07) wordt gekopieerd naar de hoge byte en terug geüpload naar de module. Als een van de uitgangen P00...P03 is aangesloten op een gemeenschappelijke draad, dan gaat een van de LED's die is aangesloten op P10...P13 uit.

// Bibliotheek voor het werken met I2C #include // Module adres op de bus standaard int adres = 0x20; // Gegevens gelezen van module uint8_t hi, lo; uint16_t dataReceive; uint8_tdataHighByte; // Hoge byte (P10...P17) uint8_t dataLowByte; // Lage byte (P00...P07) void setup() ( Wire.begin(); Serial.begin(9600); // Hoog niveau naar alle PCF8575-poorten dataHighByte = B1111111; dataLowByte = B11111111; pcf8575_write(dataLowByte, dataHighByte ); ) void loop() ( // Lees een byte uit de module dataReceive = pcf8575_read(); // Print naar de monitor in binair formaat Serial.println(dataReceive, BIN); // Extraheer de lage byte uit het lange woord dataLowByte = lowByte(dataReceive); // Kopieer de lage byte naar de hoge byte dataHighByte = dataLowByte; // Maskeer de lage byte dataLowByte |= B11111111; // Schrijf nieuwe gegevens naar de module, twee bytes pcf8575_write (dataLowByte, dataHighByte); delay(500); ) // Procedure voor het schrijven van een byte naar de module void pcf8575_write(uint8_t dtl, int8_t dth) ( Wire.beginTransmission(address); Wire.write(dtl); // Schrijf lage byte (P00... P07) Wire.write(dth); //Schrijf hoge byte (P10...P17) Wire.endTransmission();) // Procedure voor het lezen van een byte van module int16_t pcf8575_read( ) ( Wire.beginTransmission (adres); Wire.endTransmission(); Wire.requestFrom(adres, 2); lo = Draad.lezen(); // Lees lage byte (P00...P07) hi = Wire.read (); // Lees high byte (P10...P17) return (word (hi, lo)); // Geef een lang woord terug)

Arduino-bibliotheek voor PCF8574/PCF8575

De bibliotheek kan worden gedownload van GitHub. Maar zoals je kunt zien, is het werken met poortverlengers heel eenvoudig en kun je gemakkelijk zonder een speciale bibliotheek.

Een van de belangrijkste voordelen van het Arduino-platform is zijn populariteit. Het populaire platform wordt actief ondersteund door fabrikanten van elektronische apparaten, die speciale versies van verschillende kaarten vrijgeven die de basisfunctionaliteit van de controller uitbreiden. Dergelijke borden, vrij logisch uitbreidingsborden genoemd (een andere naam: arduino-schild, schild), dienen om een ​​breed scala aan taken uit te voeren en kunnen het leven van een arduinist aanzienlijk vereenvoudigen. In dit artikel zullen we leren wat een Arduino-uitbreidingskaart is en hoe deze kan worden gebruikt om met verschillende Arduino-apparaten te werken: motoren (motordriverschilden), LCD-schermen (LCD-schilden), SD-kaarten (datalogger), sensoren (sensor schild) en vele anderen.

Laten we eerst de voorwaarden begrijpen. Het Arduino-uitbreidingsbord is een compleet apparaat dat is ontworpen om bepaalde functies uit te voeren en wordt aangesloten op de hoofdcontroller met behulp van standaardconnectoren. Een andere populaire naam voor een uitbreidingskaart is het Engelstalige Arduino-schild of gewoon schild. Alle benodigde elektronische componenten zijn op het uitbreidingsbord geïnstalleerd en interactie met de microcontroller en andere elementen van het moederbord vindt plaats via standaard arduino-pinnen. Meestal wordt het schild ook gevoed door het arduino-hoofdbord, hoewel het in veel gevallen mogelijk is om het van andere bronnen te voorzien. In elk schild zijn er een paar vrije pinnen die u naar eigen goeddunken kunt gebruiken door er andere componenten op aan te sluiten.

Het Engelse woord Shield wordt vertaald als schild, scherm, scherm. In onze context moet het worden begrepen als iets dat het controllerbord bedekt, dat een extra laag van het apparaat creëert, een scherm waarachter verschillende elementen verborgen zijn.

Waarom zijn arduino-schilden nodig?

Alles is heel eenvoudig: 1) zodat we tijd besparen, en 2) iemand kan er geld mee verdienen. Waarom tijd verspillen met het ontwerpen, plaatsen, solderen en debuggen van iets dat u al in elkaar kunt zetten en meteen kunt gebruiken? Goed ontworpen en geassembleerd op hoogwaardige hardware, zijn uitbreidingskaarten meestal betrouwbaarder en nemen ze minder ruimte in beslag in het uiteindelijke apparaat. Dit betekent niet dat u de zelfassemblage volledig moet opgeven en dat u het werkingsprincipe van bepaalde elementen niet hoeft te begrijpen. Een echte ingenieur probeert immers altijd te begrijpen hoe wat hij gebruikt werkt. Maar we zullen in staat zijn om complexere apparaten te maken als we niet elke keer het wiel opnieuw uitvinden, maar onze aandacht richten op wat maar weinig mensen voor ons hebben opgelost.

Natuurlijk moet je betalen voor de kansen. Bijna altijd zullen de kosten van het laatste schild hoger zijn dan de prijs van afzonderlijke componenten, u kunt een vergelijkbare optie altijd goedkoper maken. Maar hier is het aan u om te beslissen hoe belangrijk de tijd of het geld dat u eraan besteedt, voor u is. Rekening houdend met alle mogelijke hulp van de Chinese industrie, dalen de kosten van boards voortdurend, dus meestal wordt de keuze gemaakt voor het gebruik van kant-en-klare apparaten.

De meest populaire voorbeelden van schilden zijn uitbreidingskaarten voor het werken met sensoren, motoren, LCD-schermen, SD-kaarten, netwerk- en GPS-schilden, schilden met ingebouwde relais voor aansluiting op de belasting.

Arduino Shields aansluiten

Om het schild aan te sluiten, hoeft u het alleen maar voorzichtig op het moederbord te "plaatsen". Gewoonlijk kunnen de pinnen van het kamvormige schild (mannelijk) eenvoudig in de Arduino-bordconnectoren worden gestoken. In sommige gevallen is het nodig om de pinnen zorgvuldig te tweaken als het bord zelf niet netjes is gesoldeerd. Het belangrijkste hier is om voorzichtig te handelen en geen overmatige kracht uit te oefenen.

In de regel is het schild ontworpen voor een zeer specifieke versie van de controller, hoewel bijvoorbeeld veel Arduino Uno-schilden vrij goed werken met Arduino Mega-kaarten. De pinout op de mega is zo gemaakt dat de eerste 14 digitale contacten en de contacten aan de andere kant van het bord samenvallen met de locatie van de contacten op de UNO, zodat het schild van arduino het gemakkelijk wordt.

Arduino Shield-programmering

Het programmeren van een circuit met een uitbreidingskaart verschilt niet van het gebruikelijke programmeren van een arduino, omdat we vanuit het oogpunt van de controller onze apparaten eenvoudig op de gebruikelijke pinnen hebben aangesloten. In de schets moet u die pinnen specificeren die in het schild zijn verbonden met de overeenkomstige pinnen op het bord. In de regel geeft de fabrikant de overeenstemming van de pinnen op het schild zelf of in een afzonderlijke aansluithandleiding aan. Als je de schetsen downloadt die worden aanbevolen door de fabrikant van het bord, hoef je dat niet eens te doen.

Het lezen of schrijven van schildsignalen gebeurt ook op de gebruikelijke manier: met behulp van de functies en andere commando's die bekend zijn bij elke arduinist. In sommige gevallen zijn botsingen mogelijk wanneer u gewend bent aan dit verbindingsschema en de fabrikant een ander heeft gekozen (u hebt bijvoorbeeld de knop naar de grond getrokken en op het schild - naar stroom). Hier moet je gewoon voorzichtig zijn.

In de regel wordt dit uitbreidingsbord geleverd in arduino-kits en daarom ontmoeten arduino-mensen het vaakst. Het schild is vrij eenvoudig - de belangrijkste taak is om meer handige opties te bieden voor aansluiting op het Arduino-bord. Dit wordt gedaan via extra stroom- en aardingsconnectoren, die naar het bord worden gebracht naar elk van de analoge en digitale pinnen. Op het bord vind je ook connectoren voor het aansluiten van een externe stroombron (je moet jumpers installeren om te schakelen), een LED en een herstartknop. Afschermopties en gebruiksvoorbeelden vindt u in de afbeeldingen.

Er zijn verschillende versies van de sensoruitbreidingskaart. Ze verschillen allemaal in het aantal en type connectoren. De meest populaire versies van vandaag zijn Sensor Shield v4 en v5.

Dit arduino-schild is erg belangrijk in robotica-projecten. Hiermee kunt u in één keer reguliere en servomotoren op het Arduino-bord aansluiten. De hoofdtaak van het schild is om controle te bieden over apparaten die een stroom verbruiken die hoog genoeg is voor een gewoon Arduino-bord. Bijkomende kenmerken van het bord zijn de functie van het regelen van het motorvermogen (via PWM) en het veranderen van de draairichting. Er zijn veel soorten motorafschermingsborden. Ze hebben allemaal gemeen dat er in het circuit een krachtige transistor aanwezig is waarmee een externe belasting is aangesloten, koelelementen (meestal een radiator), circuits voor het aansluiten van externe voeding, connectoren voor het aansluiten van motoren en pinnen voor het aansluiten op een Arduino.

De organisatie van het werk met het netwerk is een van de belangrijkste taken in moderne projecten. Om via Ethernet verbinding te maken met een lokaal netwerk, is er een bijbehorende uitbreidingskaart.

Prototyping uitbreidingskaarten

Deze borden zijn vrij eenvoudig - ze hebben contactvlakken voor montage-elementen, een resetknop wordt weergegeven en het is mogelijk om externe voeding aan te sluiten. Het doel van deze schilden is om de compactheid van het apparaat te vergroten, wanneer alle benodigde componenten zich direct boven het moederbord bevinden.

Arduino LCD-schild en tft-schild

Dit type schild wordt gebruikt om te werken met LCD-schermen in Arduino. Zoals u weet, is het aansluiten van zelfs het eenvoudigste 2-regelige tekstscherm verre van een triviale taak: u moet 6 schermcontacten tegelijk correct aansluiten, de voeding niet meegerekend. Het is veel gemakkelijker om een ​​kant-en-klare module in een Arduino-bord te plaatsen en eenvoudig de bijbehorende schets te uploaden. In het populaire LCD Keypad Shield worden direct 4 tot 8 knoppen op het bord aangesloten, waardoor je direct een externe interface voor de gebruiker van het apparaat kunt organiseren. TFT Shield helpt ook

Arduino datalogger schild

Een andere taak die vrij moeilijk zelf in uw producten te implementeren is, is de opslag van gegevens die worden ontvangen van sensoren met tijdreferentie. Het kant-en-klare schild maakt het niet alleen mogelijk om gegevens op te slaan en tijd te ontvangen van de ingebouwde klok, maar ook om sensoren op een handige manier aan te sluiten door te solderen of op de printplaat.

Korte samenvatting

In dit artikel hebben we slechts een klein deel overwogen van het enorme aanbod van verschillende apparaten die de functionaliteit van arduino uitbreiden. Met uitbreidingskaarten kunt u zich concentreren op het belangrijkste - de logica van uw programma. De makers van de schilden zorgden voor de juiste en betrouwbare installatie, de nodige stroomvoorziening. Het enige dat je nog hoeft te doen, is het bord vinden dat je nodig hebt met behulp van het gekoesterde Engelse woord schild, het verbinden met de arduino en de schets uploaden. Gewoonlijk bestaat elke programmering van een schild uit het uitvoeren van eenvoudige acties om de interne variabelen van een reeds voltooid programma te hernoemen. Als resultaat krijgen we gebruiksgemak en verbinding, evenals de snelheid van assemblage van afgewerkte apparaten of prototypes.

Het nadeel van het gebruik van uitbreidingskaarten zijn hun kosten en mogelijk verlies aan efficiëntie vanwege de veelzijdigheid van schilden die in hun aard ligt. Voor uw specifieke toepassing of eindapparaat zijn mogelijk niet alle functies van het schild nodig. In dit geval moet u het schild alleen gebruiken in de fase van prototyping en testen, en bij het maken van de definitieve versie van uw apparaat, overweeg dan om het te vervangen door een ontwerp met uw eigen schema en lay-outtype. Het is aan jou, je hebt alle mogelijkheden voor de juiste keuze.

→ Hoe breid je het aantal analoge in- en uitgangen op je Arduino uit?

Hoe breid je het aantal analoge in- en uitgangen op je Arduino uit?

Met een multiplexer of demultiplexer kunt u het aantal in- en uitgangen op uw Arduino uitbreiden.
De 4051 is een 8-kanaals analoge multiplexer/demultiplexer, dus:
* Als u de 4051 als multiplexer gebruikt: u kunt een van de 8 verschillende ingangen selecteren en de status ervan aflezen aan de controller.
* Als u de 4051 als demultiplexer gebruikt, kunt u een van de 8 verschillende uitgangen selecteren en daar de gewenste waarde schrijven.

Ook kan de 4051 analoge waarden aan, in je Arduino kun je 0-5V analoge signalen gebruiken en het IC aansluiten op de analoge ingangen op de Arduino.

Om de gewenste microcircuitingang en de lees- of schrijfmodus te selecteren, moeten we drie stuursignalen gebruiken (S0, S1 en S2). Elk van deze pinnen moet worden aangesloten op een van de digitale uitgangen van de Arduino. Elke uitgang heeft een nummer (S0 = 1; S1 = 2; S2 = 4) en als een van deze uitgangen is ingesteld op een hoog logisch niveau, is het aantal weergegeven pinnen 4051.

Bijvoorbeeld:
* Als je log “1” instelt op de ingangen van de microschakeling S0 en S1 en log “0” op S2, dan is de ingang y3 van de microschakeling geselecteerd, dit ziet er zo uit (1 +2 +0 = 3).
* Als je log “1” instelt op de ingangen van de microschakeling S0 en S2 en log “0” op S1, dan is de ingang y5 van de microschakeling geselecteerd, dit ziet er zo uit (1 +0 +4 = 5).

Het is niet mogelijk om de status naar meer dan één 4051-pin tegelijk te lezen of te schrijven. Maar je kunt de status vrij snel uit de output van de chip lezen en schrijven. Er is geen vertraging nodig tussen het selecteren, lezen of schrijven van de status van de 4051-pinnen.

* Z ----- gemeenschappelijk ingangs- of uitgangssignaal (verbonden met Arduino I/O)
* E ----- ingang inschakelen (actieve log "0") (verbonden met aarde (GND))
* Vee --- negatieve voedingsspanning (aangesloten op aarde (GND))
* GND --- massa negatief (0 V)
* S0-S2 - selecteer ingangen (verbonden met drie Arduino digitale pinnen)
* y0-Y7 - onafhankelijke in-/uitgangen
* Vcc --- positieve voedingsspanning (5V)

De linker afbeelding hierboven is een voorbeeld van het gebruik van een 9 multiplexer om 64 analoge ingangen te lezen met slechts één Arduino analoge ingang.
De rechter afbeelding hierboven is een voorbeeld van het gebruik van twee 4051's (een geconfigureerd als een demultiplexer en een als een multiplexer) in een 8x8-matrix om 64 knoppen of andere digitale ingangen te testen van slechts één digitale ingang op de Arduino (van de tweede setup u kunt slechts twee knoppen tegelijk hebben), anders moet u de eerste (linker) instelling gebruiken).

Codevoorbeeld:

// Voorbeeld voor het gebruik van 4051 analoge multiplexer/demultiplexer
// door David C.

int led = 13 ; // Stel de LED in op de 13e poot
int r0 = 0 ; // waarde selecteer uitgang naar 4051 (S0)
int r1 = 0 ; // waarde selecteren uitgang naar 4051 (S1)
int r2 = 0 ; // waarde selecteren uitgang naar 4051 (S2)
int rij = 0; // sla de bin-code op
int-telling = 0; // kwast
int bin = ( 000, 1, 10, 11, 100, 101, 110, 111 ); // Een reeks binaire getallen die het nummer van de geselecteerde invoer / uitvoer van de 4051-chip definiëren, van 1 tot 8.
void setup () ( // INITIALISEREN
pinMode (2 , UITGANG); // s0 uitgang
pinMode (3 , UITGANG); // s1 uitgang
pinMode (4 , UITGANG); // s2 uitgang
digitalWrite (led , HOOG) ; // steek de LED aan
beginSerial(9600) ; // UART-wisselkoers
}

lege lus()(
for (count = 0 ; count ≤ 7 ; count ++) ( // doorloop array-elementen van 1 tot 8
rij = bak [telling];
r0 = rij & 0x01 ;
r1 = (rij >> 1) & 0x01 ; //
r2 = (rij >> 2) & 0x01 ; //
digitalWrite(2, r0) ;
digitalWrite(3, r1) ;
digitalWrite(4, r2) ;
Serieel.println(bak);
vertraging (1000);

SPI- of I2C ADC-chips zijn direct beschikbaar in een reeks resoluties, samplefrequenties en aantal kanalen. Ze zijn vrij eenvoudig toe te voegen aan elke Arduino.

De MCP3208 zal bijvoorbeeld 8 kanalen van 12-bits resolutie per SPI geven, dat wil zeggen 3 pinnen (MOSI/MISO/SCK) + 1 per chip (SS). Dus 1 chip is 4 pins, 2 chips 5 pins, 3 chips 6 pins, etc.

Het toevoegen van veel IC's aan de SPI-bus kan echter op zichzelf al hinderlijk zijn met de verhoogde capaciteit van al die ingangen, wat betekent dat je de berichtsnelheid een beetje moet vertragen of wat extra buffering moet toevoegen om de bus zwaarder te laten rijden.

I2C-chips kunnen lastiger zijn om te hebben, omdat er slechts een beperkt aantal adressen op de I2C-bus is - plus op veel Arduino's is I2C ook twee analoge pinnen die je misschien niet wilt opofferen.

De tweede optie omvat het gebruik van analoge multiplexers (bijv. 4051) om verschillende bronnen naar de bestaande analoge ingangen te schakelen.

De derde optie, die je waarschijnlijk nog niet hebt overwogen, is om meerdere arduino's (of andere goedkope microcontrollers) elk wat op te halen en vervolgens een communicatiemethode tussen hen (of met een enkele master) te implementeren. Dit heeft als bijkomend voordeel dat u meerdere kanalen tegelijk kunt samplen (één per microcontroller), wat uw werk enigszins versnelt.

Voortbouwend op Mazhenko's antwoord, kun je een analoge multiplexer zoals de 74HC4051 gebruiken om van één analoge poort 8 te maken.

Zijn neef, de 74HC4067, zal 16 poorten multiplexen. Nu met 6 analoge ingangen op de Arduino Uno kun je 6 x 16 ingangen = 96 hebben. De A/B/C-besturingssignalen kunnen parallel zijn.

Hiermee kun je 96 ingangen afhandelen met 6 extra chips en vrij eenvoudige code. Ik heb codevoorbeelden op mijn 74HC4051 mux/demux-pagina.

Voor 8 ingangen code:

// Voorbeeld van gebruik van de 74HC4051 multiplexer/demultiplexer // Auteur: Nick Gammon // Datum: 14 maart 2013 const byte sensor = A0; //waar de multiplexer in/uit-poort is aangesloten // de multiplexer adresselectielijnen (A/B/C) const byte addressA = 6;//low-order bit const byte addressB = 5; const byte addressC = 4; //high-order bit void setup()(Serial.begin(115200); Serial.println("Start multiplexer test..."); pinMode(addressA, OUTPUT); pinMode(addressB, OUTPUT ); pinMode (addressC, OUTPUT); ) // einde van setup int readSensor (const byte which) ( //selecteer het juiste MUX-kanaal digitalWrite (addressA, (welke & 1) ? HIGH: LOW); //low-order bit digitalWrite (adresB, (welke & 2) ? HIGH: LOW); digitalWrite (addressC, (welke & 4) ? HIGH: LOW); //high-order bit // lees nu de sensorretour analoogRead (sensor);) / /end of readSensor void loop () ( //toon alle 8 sensormetingen voor (byte i = 0; i< 7; i++) { Serial.print ("Sensor "); Serial.print (i); Serial.print (" reads: "); Serial.println (readSensor (i)); } delay (1000); } //end of loop

Ik heb precies met hetzelfde probleem gewerkt. Ik heb een programma nodig dat 100 thermistoren leest... Waarom? tja, als je het nodig hebt.

Ik heb het al afgemaakt.

Ik heb de 74HC4051 multiplexer/demultiplexer geprobeerd. Maar om de een of andere reden kreeg ik niet het gewenste resultaat.

Het eerste dat je zult vinden... POWER, je hebt een externe voeding nodig, in mijn geval heb ik net een spanningsdeler gemaakt en de thermistor op die voeding aangesloten en gebruik dan gewoon de analoge poort om te lezen...

Ik gebruik het I2C-protocol, 8 arduino Mega 7-slaves en één master. en na het verzenden van stuur Integer, float en blah blah werkte niet voor mij om het gewoon te doen. Het kan een analoge read over I2C sturen en de master doet alle noodzakelijke conversies.

Als je nog steeds geïnteresseerd bent, kan ik je de broncode voor master en slaves sturen. Met deze sjabloon kun je tot 50 arduino's verbinden en de master zoekt naar elke arduino die op het netwerk is aangesloten en vraagt ​​om gegevens.