Läsa värden från en analog-till-digital konverterare

Artikel
05/10/2023

En analog-till-digital konverterare (ADC) är en enhet som kan läsa ett analogt indataspänningsvärde och konvertera det till ett digitalt värde. ADCs används för att läsa värden från thermistors, potentiometers och andra enheter som ändrar motstånd baserat på vissa villkor.

I det här avsnittet använder du .NET för att läsa värden från en ADC när du modulerar inspänningen med en potentiometer.

Krav

ARM-baserad (ARMv7 eller senare) enkelkortsdator (SBC)
MCP3008 analog-to-digital-konverterare
Potentiometer med tre stift
Skärbräda
Bygeltrådar
Raspberry Pi GPIO breakout board (valfritt/rekommenderat)
.NET SDK 7 eller senare

Anteckning

Den här självstudien skrivs förutsatt att målenheten är Raspberry Pi. Den här självstudien kan dock användas för alla Linux-baserade SBC som stöder .NET, till exempel Orange Pi, ODROID med mera.

Förbereda SBC

Se till att din SBC är konfigurerad för att stödja följande tjänster:

För många enheter krävs ingen ytterligare konfiguration. Använd kommandot för raspi-config Raspberry Pi. Mer information om raspi-configfinns i Raspberry Pi-dokumentationen.

Förbereda maskinvaran

Använd maskinvarukomponenterna för att skapa kretsen enligt följande diagram:

MCP3008 använder SPI (Serial Peripheral Interface) för att kommunicera. Följande är anslutningarna från MCP3008 till Raspberry Pi och potentiometern:

V_DD till 3.3V (visas i rött)
V_REF till 3,3V (röd)
AGND till marken (svart)
CLK till SCLK (orange)
D_UT till MISO (orange)
D_IN till MOSI (orange)
CS/SHDN till CE0 (grön)
DGND till marken (svart)
CH0 till variabel (mitten) stift på potentiometer (gul)

Leverera 3,3V och jord till de yttre stiften på potentiometern. Ordningen är oviktig.

Se följande pinout-diagram efter behov:

MCP3008	Raspberry Pi GPIO
	Bild med tillstånd Raspberry Pi Foundation.

Tips

En GPIO-gruppkort tillsammans med en brödbräda rekommenderas för att effektivisera anslutningarna till GPIO-huvudet.

Skapa appen

Utför följande steg i önskad utvecklingsmiljö:

Skapa en ny .NET-konsolapp med hjälp av .NET CLI eller Visual Studio. Ge den namnet AdcTutorial.
```
dotnet new console -o AdcTutorial
cd AdcTutorial
```
Lägg till paketet Iot.Device.Bindings i projektet. Använd antingen .NET CLI från projektkatalogen eller Visual Studio.
```
dotnet add package Iot.Device.Bindings --version 2.2.0-*
```
Ersätt innehållet i Program.cs med följande kod:
```
using System;
using System.Device.Spi;
using System.Threading;
using Iot.Device.Adc;

var hardwareSpiSettings = new SpiConnectionSettings(0, 0);

using SpiDevice spi = SpiDevice.Create(hardwareSpiSettings);
using var mcp = new Mcp3008(spi);
while (true)
{
    Console.Clear();
    double value = mcp.Read(0);
    Console.WriteLine($"{value}");
    Console.WriteLine($"{Math.Round(value/10.23, 1)}%");
    Thread.Sleep(500);
}
```
I koden ovan:
- hardwareSpiSettings är inställd på en ny instans av SpiConnectionSettings. Konstruktorn anger parametern busId till 0 och parametern chipSelectLine till 0.
- En användningsdeklaration skapar en instans av SpiDevice genom att anropa SpiDevice.Create och skicka in hardwareSpiSettings. Detta SpiDevice representerar SPI-bussen. using Deklarationen säkerställer att objektet tas bort och att maskinvaruresurser frigörs korrekt.
- En annan using deklaration skapar en instans av Mcp3008 och skickar SpiDevice till konstruktorn.
- En while loop körs på obestämd tid. Varje iteration:
  1. Rensar konsolen.
  2. Läser värdet för CH0 på ADC genom att anropa mcp.Read(0).
  3. Skriver raw-värdet till konsolen.
  4. Skriver värdet till konsolen formaterat i procent.
    - För att beräkna procentandelen divideras värdet med 10,23. MCP3008 är en 10-bitars ADC, vilket innebär att den returnerar 1024 möjliga värden mellan 0 och 1023. Att dividera värdet med 10,23 representerar värdet i procent.
    - Procentandelen avrundas till närmaste 0,1.
  5. Sover 500 ms.
Skapa appen. Om du använder .NET CLI kör du dotnet build. Tryck på Ctrl+Skift+B för att skapa i Visual Studio.
Distribuera appen till SBC som en fristående app. Anvisningar finns i Distribuera .NET-appar till Raspberry Pi. Se till att ge den körbara körningsbehörigheten med hjälp av chmod +x.
Kör appen på Raspberry Pi genom att växla till distributionskatalogen och köra den körbara filen.
```
./AdcTutorial
```
Observera utdata när du roterar potentiometeruppringningen. Detta beror på att potentiometern varierande den spänning som levereras till CH0 på ADC. ADC jämför indataspänningen på CH0 med referensspänningen som levereras till V_REF för att generera ett värde.
Avsluta programmet genom att trycka på Ctrl+C.

Grattis! Du har använt SPI för att läsa värden från en analog-till-digital konverterare.

Hämta källkoden

Källan för den här självstudien finns på GitHub.

Nästa steg

Lär dig hur du använder Generell användning indata/utdata för att blinka en lysdiod

Dela via