a csapok tömbként való tárolásának helyes módja

A tömb inicializálóinak majdnem helyesek; csak vesszővel kell elválasztania az értékeket:

  digitPins [] = {13, 12, 11, 10}; segPins [] = {2, 3, 4, 5, 6, 7 , 8};  

A pinMode () ciklust kell meghívnia; nem fogad el tömböt argumentumként.

Mi a helyzet a digitalWrite () -vel, ahol a HIGH és LOW keveréke van?

Vannak (legalábbis ) kétféleképpen: Készítsen HIGH és LOW értékeket tartalmazó tömböket, egyezzen a digitPins [] és a segPins [] tömbökkel egyenként. Vagy a könnyebb karbantartás érdekében deklarálja a pin # és az érték adatstruktúráját ( struct ); készítsen tömböt azokból. Kicsit összetettebb, de hasznosabb is. Tehát például:

  typedef struct {uint8_t pinNum; bool pinVal;} pinInit_t; pinInit_t digitPins [] {{13, HIGH}, {12, LOW}, {11, LOW}, {10, HIGH}}; void setup () {// tegye ide a beállítási kódot, futtassa egyszer:} void loop () {// tegye ide a fő kódot, hogy többször fusson:}  

struct az "adatszerkezet" rövidítése; lehetővé teszi, hogy a különböző típusú adatokat egyetlen megnevezett és címezhető egységgé egyesítse. A typedef új adattípust deklarál, és azt mondja: "Ne foglaljon most memóriát; ez (pinInit) csak leírás. A későbbiekben használom." Lehetővé teszi a pinInit megnevezett adattípus használatát, ahol csak natív adattípust használhat, és megengedett egy többértékű adattípus (például egy tömb).

Így létrehozhatunk egy tömböt pinInit s (pin- # / logikai értékpárok) csak az új típus nevének használatával.

Akkor az inicializáló kód a következőképpen nézhet ki:

  uint8_t i; for (i = 0; i < sizeof (digitPIN) / sizeof (pinInit_t); ++ i) {pinMode (digitPins [i] .pinNum, OUTPUT); digitalWrite (digitPins [i] .pinNum, digitPins [i] .pinVal);}  

A sizeof (digitPins) / sizeof (pinInit) kifejezés az inicializálók számát értékeli (bájtok száma a tömbben / bájtok száma egy tömb tagban).

A digitPins [i] .pinNum kifejezés jelentése: "a pinInit tömb digitPins-ben kapja meg az i-edik elemet ..." (ne feledje, ez egy értékpár), "... és vegye fel a "pinNum" tag értékét. Kicsit bonyolultabb, amikor először belegondolunk, de nézzük meg, milyen könnyen olvasható a tömb. És egy tipp a kifejezés elolvasására: visszafelé olvastam: "a pinNum tagja a digitPins tömb i-edik eleme. "

Holnap, vagy a következő hónapban, amikor újabb tűre van szükségünk, nem kell frissítenünk 2 tömböt (természetesen emlékezünk arra, hogy egymás között legyenek! ); csak adjon hozzá egy másik 2 értékű elemet az egy digitPins [] tömbhöz.

[KIEGÉSZÍTŐ KÓD és A KÓD MAGYARÁZATA]

Ez az a funkció, amelyet a megjegyzésekben közzétett linkben használnak:

  void number (int num) // num a megjelenítendő szám {for (int i = 0; i<7; i ++) // a 7 szegmensen (7 led) keresztül haladva {digitalWrite (segment [i], nums [szám] [i]); // mondd meg az arduinónak, hogy kapcsolja be vagy ki, melyik led vezetett}}  

Nagyszerű, mert a következő hívással használhatja:

  szám (/ * a megjeleníteni kívánt szám * /);  

A for ciklus használata elkerüli a sok dolog másolását és beillesztését. Ez lehetővé teszi sok memória megtakarítását is.

Ezután egy kis 0-9 időzítő megjelenítéséhez ezt megteheti:

  for (int i = 0 ; i<10; i ++) {szám (i); // megjeleníti a számkésleltetést (1000); // várjon 1 másodperc}  

[EREDETI VÁLASZ]

Használjon tömböt és egy hurok.

  int szegmensek = {2,3,4,5,6,7,8}; // a pinsvoid setup () deklarálása a (int i = 0; i<8; i ++) {pinMode (szegmensek [i], OUTPUT) számára; // kimenetnek nyilvánítás}}  

Nagyon hasznos. Ugyanezt tegye a számjegyekkel is.

Ez a módszer sok esetben működik:

• sok érzékelő, kapcsoló
• sok kimenet, például led, relé , tranzisztorok

Egyéni módszerhasználat

Használt hivatkozás: https://stackoverflow.com/a/33235154/5500092

Használhat olyan egyéni módszert is, mint ez:

  template<size_t size>void pinMode (const uint8_t (&pin) [size], uint8_t mode) {for (size_t i = 0; i < size; ++ i) {pinMode (pin [i ], mód); }} template<size_t size>void digitalWrite (const uint8_t (&pin) [size], uint8_t val) {for (size_t i = 0; i < size; ++ i) {digitalWrite (pin [i], val); }}  

Ezután meghatároz egy tömböt a csapokkal:

  uint8_t displayPins [4] = {13, 12, 11, 10}; uint8_t segmentPins [7] = {2, 3, 4, 5, 6, 7, 8};  

És végül a beállítás során:

  érvénytelen beállítás () {pinMode (displayPins, OUTPUT); pinMode (segmentPins, OUTPUT);} void loop () {// Logikája a digitalWrite szolgáltatással.}  

A logikája

PS: A logikájához, akár használhatja is:

  template<size_t size>void digitalWrite (const uint8_t (&pin) [size], const uint8_t (&val) [size]) {for (size_t i = 0; i < size; + i) {digitalWrite (pin [i], val [i]); }}  

És adjon meg minden szegmensszámhoz egy egyedi értéktömböt.

  uint8_t nulla [7] = {HIGH, HIGH, HIGH, HIGH, HIGH , HIGH, LOW}; ...  

Vagy akár:

  uint8_t szegmens [] [7] = {{HIGH, HIGH, HIGH, HIGH , HIGH, HIGH, LOW}, // 0 {____, ____, ____, ____, ____, ____, ____}, // 1 {____, ____, ____, ____, ____, ____, ____}, // 2. .. {____, ____, ____, ____, ____, ____, ____}}; // F  

És használja:

  digitalWrite (segmentPins, segment [5]); // kinyomtatni 5  

  func () {logikai csapok [] = {1,1,1,1,1,1,0}; mert (int i = 0; i<7; i ++) `digitalWrite (segPins [i], csapok [i]);}  

ez mind :)