Hur styrs loopar och digitala signaler i Arduino Nano 33 IoT?

Att förstå hur man skapar och kontrollerar loopar är en grundläggande del av programmering för mikrokontrollersystem. På Arduino Nano 33 IoT används loopar för att repetera en uppgift – att läsa sensorer, skicka data, eller styra aktuatorer – i ett oändligt flöde. I grunden finns tre konstruktioner: for, while och do..while.

for-satsen används när antalet iterationer är känt. Den består av tre delar – initialisering, villkor och inkrementering – och lämpar sig för sekventiella processer, till exempel att räkna upp en räknare från noll till ett givet värde. while-satsen passar bättre för kontinuerliga tillstånd, där programmet väntar på att ett specifikt villkor ska uppfyllas. do..while används när man vill garantera att minst en iteration sker, oavsett villkorets initiala värde.

I praktiken kombineras dessa strukturer ofta med break och continue. Dessa två nyckelord ger en finare kontroll över programmets flöde. Med continue hoppar man över den aktuella iterationen och går vidare till nästa. Med break avbryts hela loopen. Ett typiskt exempel är att exkludera en iteration vid ett visst värde – till exempel när räknaren når 5 – och att avsluta loopen helt när räknaren överstiger 10.

I Arduino-sammanhang används dessa konstruktioner ofta för att styra beteenden i realtid. Genom Serial.print()-kommandon kan man observera programmets flöde via seriell monitor, vilket blir ett viktigt verktyg för felsökning och förståelse. Den slumpmässiga funktionen random() kan dessutom användas för att simulera variationer i dataflöden, vilket ger möjlighet att testa hur programmet reagerar på olika situationer.

När man går från logiska flöden till fysisk interaktion introduceras digital I/O – en central del i arbetet med mikrokontrollersystem. Arduino Nano 33 IoT erbjuder fjorton digitala in- och utgångar. Dessa pinnar, märkta D0 till D13, fungerar som bryggan mellan kod och hårdvara. Genom att koppla en tryckknapp till en ingång och en LED till en utgång kan man skapa ett mycket enkelt, men fundamentalt exempel: en knapp som tänder en lampa.

Programmet för en sådan uppgift är enkelt men elegant. Först definieras pinnar och tillståndsvariabler. I setup() anger man att LED-pinnen ska vara en utgång och knappen en ingång. I loop()-funktionen läses knappens tillstånd med digitalRead(), och detta tillstånd skrivs direkt till LED-pinnen med digitalWrite(). På detta sätt blir LED:en en direkt visuell representation av den elektriska signal som knappen genererar.

Det är viktigt att förstå att bakom dessa korta kodrader finns en djupare struktur: en kontinuerlig cykel mellan programlogik, hårdvarusignaler och mänsklig perception. När vi ser en LED blinka, ser vi inte bara ett elektriskt flöde – vi ser resultatet av en abstrakt logisk process som översätts till ljus.

För den som arbetar med Arduino Nano 33 IoT blir denna växelverkan mellan kod och verklighet själva kärnan i förståelsen av inbyggda system. Man lär sig inte bara att skriva program, utan att tänka i termer av händelser, tillstånd och återkoppling.

Viktigt att förstå är också samspelet mellan hårdvara och tid. Funktioner som delay() används ofta för att synkronisera händelser, men de blockerar exekveringen av andra delar av programmet. Ett mer avancerat tillvägagångssätt innebär att ersätta statiska fördröjningar med tidsbaserad logik – till exempel med hjälp av millis() – för att skapa icke-blockerande loopar som kan reagera på flera stimuli samtidigt.

Hur fungerar I2C-kommunikation på Arduino Nano 33 IoT?

I2C-kommunikation, eller Inter-Integrated Circuit, är en kommunikationsprotokoll som används för att koppla ihop olika enheter på ett enkelt sätt. På Arduino Nano 33 IoT finns möjlighet att använda denna teknik för att läsa av sensorinformation och kommunicera med andra I2C-enheter. I denna sektion får vi en detaljerad genomgång av hur man använder I2C på Arduino, särskilt för att scanna I2C-adresser och läsa sensordata från anslutna enheter.

För att komma igång med I2C på Arduino Nano 33 IoT använder vi Wire-biblioteket, vilket gör det enkelt att arbeta med I2C-kommunikation. För att använda detta bibliotek måste vi inkludera Wire.h i vårt program. Detta bibliotek tillhandahåller funktioner för att kommunicera med alla enheter som är kopplade till I2C-bussen på ett Arduino-kort. För att se ytterligare information om hur Wire-biblioteket fungerar kan man besöka Arduinos officiella webbsida.

I vårt exempel kommer vi att bygga ett program som skannar alla I2C-enheter som är kopplade till Arduino Nano 33 IoT, inklusive två interna sensorer i kortet. Vi använder en extern modul, PCF8591, som en AD/DA-konverterare (analog till digital/digital till analog). Detta är ett vanligt scenario för att läsa av sensordata från externa enheter över I2C-bussen.

Koden för att skanna I2C-adresser på Arduino Nano 33 IoT ser ut på följande sätt:

cpp
Copy code
#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Serial.println("\nI2C Scanner");
}
void loop() {
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
      nDevices++;
    } else if (error == 4) {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found");
  else
    Serial.println("done");
  delay(5000);
}

När detta program körs på Arduino Nano 33 IoT, börjar det skanna I2C-adresser från 0x01 till 0x7F (127 adresser). Om en enhet svarar på en adress, rapporteras den som upptäckt i Serial Monitor. I vårt exempel kommer den externa PCF8591-modulen att rapporteras med adressen 0x48, och de två interna sensorerna i Arduino Nano 33 IoT kommer att rapporteras med adresserna 0x60 och 0x6A.

Hur fungerar det?

Först inleder vi I2C och seriella kommunikation i funktionen setup(). Här anger vi baudhastigheten för den seriella kommunikationen (115200 bps) och startar I2C-kommunikationen med Wire.begin().

När vi går till loop()-funktionen, börjar vi en loop där varje adress från 1 till 127 skickas ett transmissionskommando via Wire.beginTransmission(). Efter detta avslutar vi transmissionen med Wire.endTransmission(). Om det inte uppstår något fel under transmissionen, betyder det att en I2C-enhet är ansluten till den aktuella adressen och vi rapporterar adressen via Serial.println(). Om ett fel uppstår, särskilt felkod 4 (okänt fel), rapporteras detta också.

Denna I2C-scanner är användbar för att verifiera vilka I2C-enheter som är korrekt anslutna och fungerar med din Arduino Nano 33 IoT. Den ger en enkel metod för att felsöka anslutningarna och säkerställa att alla enheter är korrekt identifierade på bussen.

Att läsa sensordata från I2C-enheter

För att läsa data från dessa sensorer använder vi samma I2C-kommunikation som tidigare, men vi ändrar nu vilken sensor (kanal) vi vill läsa från. Här är ett exempel på hur vi läser data från varje sensor:

cpp
Copy code
#include "Wire.h"
#define PCF8591 0x48 // I2C-adress
#define PCF8591_ADC_CH0 0x00 // Termistor
#define PCF8591_ADC_CH1 0x01 // Fotovoltaisk cell
#define PCF8591_ADC_CH2 0x02
#define PCF8591_ADC_CH3 0x03 // Potentiometer
byte ADC1, ADC2, ADC3;
void setup() {
  Wire.begin();
  Serial.begin(9600);
}
void loop() {
  // Läs från termistor
  Wire.beginTransmission(PCF8591);
  Wire.write((byte)PCF8591_ADC_CH0);
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(PCF8591, 2);
  delay(100);
  ADC1 = Wire.read();
  ADC1 = Wire.read();
  Serial.print("Termistor=");
  Serial.println(ADC1);
  // Läs från fotovoltaisk cell
  Wire.beginTransmission(PCF8591);
  Wire.write(PCF8591_ADC_CH1);
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(PCF8591, 2);
  delay(100);
  ADC2 = Wire.read();
  ADC2 = Wire.read();
  Serial.print("Fotovoltaisk cell=");
  Serial.println(ADC2);
  // Läs från potentiometer
  Wire.beginTransmission(PCF8591);
  Wire.write(PCF8591_ADC_CH3);
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(PCF8591, 2);
  delay(100);
  ADC3 = Wire.read();
  ADC3 = Wire.read();
  Serial.print("Potentiometer=");
  Serial.println(ADC3);
  delay(500);
}

När detta program körs på Arduino Nano 33 IoT, kommer sensordata från varje ansluten sensor att visas i Serial Monitor.

Sammanfattning av funktioner och användning

• I2C Scanning: Genom att skanna I2C-adresser kan vi upptäcka alla anslutna I2C-enheter och säkerställa att de är korrekt identifierade. Detta är användbart för felsökning och verifiering av anslutningar.

• Sensorläsning: När enheter har identifierats, kan vi läsa av data från externa sensorer, såsom termistorer, fotovoltaiska celler och potentiometrar. För detta används en enkel metod där varje sensor har sin egen kanaladress.

• Fehlerkoder: Om något går fel under I2C-kommunikationen (t.ex. en sensor inte svarar eller en okänd felkod inträffar), kommer dessa fel att visas, vilket underlättar felsökning.