So finden Sie die Geräte-id ein STM32F103RET

Können Sie diese Informationen finden Sie in STM32F103 Referenz-Handbuch. Genauer gesagt, Sie möchten, Lesen Sie Kapitel 30.2 Unique device ID register (96 bits).

Also deine Geräte-ID enthalten, in nur-lese-register, genannt U_ID. Dieses register Adresse 0x1ffff7e8. Es ist 96 bit lang, so dass es gelesen werden kann (zum Beispiel) mit 3 Operationen Lesen, je 32-bit lang. Natürlich können Sie nicht halten Sie es in eine variable. So sollten Sie kommen mit einigen Art und Weise der Speicherung im Gedächtnis. Es kann wie ein array, oder eine Struktur, etc.

Ich würde wahrscheinlich benutzen Sie eine Struktur für diesen Zweck, Verwendung von offsets beschrieben in Referenz-Handbuch:

#include <stdint.h>

struct u_id {
    uint16_t off0;
    uint16_t off2;
    uint32_t off4;
    uint32_t off8;
};

Wie zu Lesen, es ist bis zu Ihnen (hängt davon ab welches framework Sie verwenden, z.B. in libopencm3 Sie haben MMIO32 makro für diese). Im Allgemeinen Fall würde ich so etwas machen:

#define MMIO16(addr)  (*(volatile uint16_t *)(addr))
#define MMIO32(addr)  (*(volatile uint32_t *)(addr))
#define U_ID          0x1ffff7e8

/* Read U_ID register */
void uid_read(struct u_id *id)
{
    id->off0 = MMIO16(U_ID + 0x0);
    id->off2 = MMIO16(U_ID + 0x2);
    id->off4 = MMIO32(U_ID + 0x4);
    id->off8 = MMIO32(U_ID + 0x8);
}

Müssen Sie auch eine Funktion zum vergleichen von zwei IDs. Sie können entweder memcmp() oder einige benutzerdefinierte Funktion für diese Angelegenheit. Ich würde es vorziehen, eine benutzerdefinierte in diesem Fall:

#include <stdbool.h>

/* Returns true if IDs are the same */
bool uid_cmp(struct u_id *id1, struct u_id *id2)
{
    return id1->off0 == id2->off0 &&
           id1->off2 == id2->off2 &&
           id1->off4 == id2->off4 &&
           id1->off8 == id2->off8;
}

Können Sie es verwenden, wie:

int main(void)
{
    struct u_id id1 = { 0x0, 0x1, 0x2, 0x3 };
    struct u_id id2;
    bool same_id;

    uid_read(&id2);
    same_id = uid_cmp(&id1, &id2);

    printf("%s\n", same_id ? "equal" : "not equal");
    return 0;
}

UPDATE

Als ich verstehe Ihre situation:

1. Jedes Ihrer boards schicken soll einige unterbrechen zu Ihrem master-board (genauer gesagt, zu GPIO pin auf master-board).
2. Einmal "master" - Karte erhalten unterbrechen, startet es die übertragung (Anfrage) an Bord, wo der interrupt kam von (vermutlich mit I2C, SPI, UART oder so etwas wie, dass die Kommunikation zwischen den Brettern).
3. Dann client-Vorstand reagiert mit der device ID.
4. Interrupts behandelt werden, nacheinander, so dass Geräte-IDs erhalten Sie, eins nach dem anderen.

Bild unten zeigt den Fall mit I2C-bus verwendet für Getriebe-ID.

Board 1 haben Sie GPIO1 interrupt-handler ausgeführt, für Brett 2 -- GPIO-2-interrupt-handler. Damit Sie wissen, welche Fragen für device-ID. Also Geräte-ID erhalten Sie, ein zu einer Zeit. Von hier aus können Sie herausfinden, wie bewahren Sie diese IDs. Ich schlage vor, verwenden Sie regelmäßig array:

struct u_id device_ids[2];

Ist hier pseudo-code zeigt, wie diese bevölkern array:

void gpio1_isr(void)
{
    uint8_t i2c_buf[12];

    i2c_get(i2c_buf);
    memcpy(&device_ids[0], i2c_buf, 12);
}

void gpio2_isr(void)
{
    uint8_t i2c_buf[12];

    i2c_get(i2c_buf);
    memcpy(&device_ids[1], i2c_buf, 12);
}

(isr steht für Interrupt-Service-Routine, das ist das gleiche wie die interrupt-handler).

Wenn Sie sicher sind, dass Ihr zwei client-boards sind ready für die I2C übertragung in einer Zeit, als master-board ist gonna bitten Sie Sie, für IDs, die Sie loswerden können 2 GPIO-Leitungen und benutzen Sie einfach die I2C-Transaktionen von der master-Karte, um Kunden, Wann immer Sie wollen.