Was ist der nominale GPIO-Pin-Ausgangsstrom?

8

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?

JeeShen Lee
quelle

Antworten:

5

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

John La Rooy
quelle
Ich habe mich an PIC gewöhnt, wo der Nennstrom fest / bewertet ist, und nicht erwartet, dass er programmierbar ist. Haben Sie eine Idee, wie man es auf 16mA programmiert? oder was ist der Standardwert?
JeeShen Lee
1
@JeeShenLee, der Standard ist 8mA
John La Rooy
4
Gibt es eine Chance auf einen Beispielcode?
Alex Chamberlain
Der Link funktioniert nicht mehr.
Nathan Osman
2

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
Hundeohren
quelle
Hast du das getestet? Ich denke, das ist ein Seg-Fehler?
Alex Chamberlain
Mir wurde klar, dass ich es erst heute Nachmittag testen kann, aber ich werde es mit einem vollständigen Arbeitsbeispiel aktualisieren.
Hundeohren
Warum sollte dieser Seg Fehler sein?
Hundeohren
Weil sich 0x20100000 nicht in Ihrem virtuellen Speicher befindet.
Alex Chamberlain
Ich kann verstehen, was Sie mit Mapping usw. meinen. Es wäre schön zu sehen, dass das irgendwann aktualisiert wird, damit der Code wie heruntergeladen funktioniert.
Alex Chamberlain
1

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

PiBorg
quelle
Wird nicht kompiliert, rawMem wird nicht in main () deklariert. Auch "BOOL" ist kein gültiger Datentyp, wird jedoch behoben, indem <stdbool.h> eingeschlossen und in Kleinbuchstaben "bool" geändert wird.
PTS