Was ist der nominale GPIO-Pin-Ausgangsstrom?

Was ist der RPi GPIO Pin Ausgangsstrom?

Ich gehe davon aus, dass es mehr als 10 mA sind, da es problemlos LEDs ansteuern kann, aber was ist die Spezifikation?

Nach dem Zurücksetzen sind es 8mA. Sie können es zu 16mA programmieren obwohl

Um die PADS-Register so zu programmieren, dass sie den Ausgangsstrom ändern, wird im Folgenden der entsprechende Code angezeigt:

#define BCM2708_PERI_BASE        0x20000000
#define GPIO_BASE                (BCM2708_PERI_BASE + 0x200000) /* GPIO   */
#define PADS_BASE                (BCM2708_PERI_BASE + 0x100000) /* PADS   */

#define PADS0   *(pads+11)
#define PADS1   *(pads+12)
#define PADS2   *(pads+13)

// I/O access - Reqires maping.
volatile unsigned *pads;

Dann sollten Sie nach dem Zuordnen des Pads- Zeigers (siehe hier ) aus Ihrem Code in der Lage sein, die Pads-Register wie folgt einzustellen:

PADS0 = (0xFFFFFFF8 & PADS0) | 7; // Sets GPIO 0-27 to 16mA
PADS1 = (0xFFFFFFF8 & PADS1) | 4; // Sets GPIO 28-45 to 10mA
PADS2 = (0xFFFFFFF8 & PADS2);     // Sets GPIO 46-53 to 2mA

Wenn Sie einen Teil meines alten C-Codes tragen können, finden Sie hier ein Beispiel für die Durchführung der Zuordnung in C.

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <limits.h>
#include <unistd.h>
#include <time.h>
#include <signal.h>
#include <termios.h>
#include <ctype.h>

#define FALSE                    (0)
#define TRUE                     (!FALSE)
#define NULL_FD                  ((int)0)
#define MAP_NAME_LEN             (20)
#define NO_MASK                  (UINT_MAX)

#define BCM2708_PERI_BASE        0x20000000
#define GPIO_BASE                (BCM2708_PERI_BASE + 0x200000) /* GPIO   */
#define PADS_BASE                (BCM2708_PERI_BASE + 0x100000) /* PADS   */

#define PADS0                    (11 * 4)
#define PADS1                    (12 * 4)
#define PADS2                    (13 * 4)

#define PADS_CURRENT_MASK        (0x00000007)

typedef struct raw_memory {
    void *accessor;             // Base location for memory access
    unsigned int offset;        // Offset into base for the starting point
    unsigned int length;
    char name[MAP_NAME_LEN + 1];
} raw_memory;

int memFile = NULL_FD;
raw_memory rawMemPads= {MAP_FAILED, 0, 0, "PADS"};


void RegWrite(raw_memory *base, unsigned int address, unsigned int mask, unsigned int value);
unsigned int RegRead(raw_memory *base, unsigned int address);
BOOL MapMemory(raw_memory *base, int device, unsigned int startAddress, size_t size);
void UnmapMemory(raw_memory *base);

void RegWrite(raw_memory *base, unsigned int address, unsigned int mask, unsigned int value) {
    if (base->accessor == MAP_FAILED) {
        printf("RegWrite failed due to an unmapped base (%s)!\n", base->name);
    } else if (address >= base->length) {
        printf("RegWrite failed due to address out of bounds (%s, 0x%08X)!\n", base->name, address);
    } else {
        if (mask != NO_MASK) {
            unsigned int read = RegRead(base, address);
            value &= mask;
            value |= (~mask) & read;
        }
        *((unsigned int *)(base->accessor + base->offset + address)) = value;
    }
}

BOOL MapMemory(raw_memory *base, int device, unsigned int startAddress, size_t size) {
    // Unmap first if already allocated
    if (base->accessor != MAP_FAILED) {
        UnmapMemory(base);
    }
    // Align start address to the page size (we can only map page aligned blocks)
    base->offset = (unsigned int)(startAddress / getpagesize()) * getpagesize();
    // Compute the necessary size to cover the alignment
    base->length = (unsigned int)size;
    size += (size_t)(startAddress - base->offset);
    // Map the memory from the device to a local address
    base->accessor = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, device, base->offset);
    if (base->accessor == MAP_FAILED) {
        return FALSE;
    } else {
        // Calculate the offset needed by read / write functions to get startAddress as 0
        base->offset = startAddress - base->offset;
        return TRUE;
    }
}

void UnmapMemory(raw_memory *base) {
    if (base->accessor != MAP_FAILED) {
        munmap(base->accessor, base->offset + base->length);
        base->accessor = MAP_FAILED;
    } else {
    }
}

int main(void) {
    // Enable raw memory access
    if (memFile == NULL_FD) memFile = open("/dev/mem", O_RDWR | O_SYNC); 
    if (memFile == NULL_FD) {
        printf("Failed to open /dev/mem (are we root?) !\n");
        return 1;
    }

    // Map GPIO memory
    if (!MapMemory(&rawMemPads, memFile, PADS_BASE, 1024)) {
        printf("Failed to map GPIO device memory !\n");
        return 2;
    }

    // Actual work here
    RegWrite(&rawMem, PADS0, PADS_CURRENT_MASK, 7); // Sets GPIO 0-27 to 16mA
    RegWrite(&rawMem, PADS1, PADS_CURRENT_MASK, 4); // Sets GPIO 28-45 to 10mA
    RegWrite(&rawMem, PADS2, PADS_CURRENT_MASK, 0); // Sets GPIO 46-53 to 2mA

    // Any other code here
    //

    // Unmap the GPIO memory
    if (rawMemPads.accessor != MAP_FAILED) {
        UnmapMemory(&rawMemPads);
    }

    // Disable raw memory access
    if (memFile != NULL_FD) {
        close(memFile);
        memFile = NULL_FD;
    }

    return 0;
}

Entschuldigen Sie die Länge, es ist ein langes Stück Setup, so dass das Hauptbit des Codes für maskierte Schreibvorgänge kurz ist. Außerdem können Seiten ohne Ausrichtung ausgerichtet werden, was hier nicht wirklich ein Problem ist (ich hatte dieses Problem zuvor mit eine andere eingebettete Registerkarte). Beachten Sie, dass Sie die Binärdatei als root ausführen müssen, da sonst die Zuordnung fehlschlägt, da die Berechtigung für / dev / mem verweigert wird