Kategorie: Software

Veröffentlicht am
von

API documentation

Response example

{
    "version": "2024.03.18",
    "date": "2024-03-18 20:34:02",
    "vendors": [
        {
            "id": "1209",
            "name": "Generic",
            "devices": [
                {
                    "id": "0001",
                    "name": "pid.codes Test PID"
                },
                ...
            ]
        },
        ...
    ]
}

Filters

To get a specific device or list of devices you can add VID and PID filters to the request.
The request can be:

  • a single VID or PID
  • a list of multiple VIDs or PIDs
  • a specific pair of VID and PID

as well as each combination of them.

If the request contains a list of multiple VIDs all PIDs will be filtered independently like a request without VID.

All VIDs and PIDs need to be in HEX format with 4 digits!

GET request

GET request filters are part of the URL. They are specified as query string/parameter.

// single VID/PID
vid=(VID)
pid=(PID)

// list of VIDs/PIDs
vid[]=(VID 1)&vid[]=(VID 2)&...
pid[]=(PID 1)&pid[]=(PID 2)&...

Examples for GET request filters:

// all devices with vendor ID 0x1209
apps.sebastianlang.net/usb-ids?vid=1209

// all devices with product ID 0x0001
apps.sebastianlang.net/usb-ids?pid=0001

// a specific device with VID 0x1209 and PID 0x0001
apps.sebastianlang.net/usb-ids?vid=1209&pid=0001

// two devices (0x0001, 0x0002) from the same vendor 0x1209
apps.sebastianlang.net/usb-ids?vid=1209&pid[]=0001&pid[]=0002

POST request

POST request filters are part of the body data. They need to be in JSON format as single object or list of objects.

// single object
{
    "vid": "(VID)",
    "pid": "(PID)"
}

// list of objects
[
    {
        "vid": "(VID)",
        "pid": "(PID)"
    },
    {
        "vid": "(VID)",
        "pid": [
            "(PID 1)",
            "(PID 2)",
            ...
        ]
    },
    {
        "vid": [
            "(VID 1)",
            "(VID 2)",
            ...
        ]
    },
    ...
]

Examples for POST request filters:

// all devices with vendor ID 0x1209
{
    "vid": "1209"
}

// all devices with product ID 0x0001
{
    "pid": "0001"
}

// a specific device with VID 0x1209 and PID 0x0001
{
    "vid": "1209",
    "pid": "0001"
}

// two devices (0x0001, 0x0002) from the same vendor 0x1209
{
    "vid": "1209",
    "pid": [
        "0001",
        "0002"
    ]
}

// all devices with vendor ID 0x1209 or 0x1234
{
    "vid": [
        "1209",
        "1234"
    ]
}

// multiple filters in one requests
[
    {
        "vid": "1209",
        "pid": "0001"
    },
    {
        "vid": "1234",
        "pid": "0000"
    },
    {
        "vid": [
            "2341",
            "0403"
        ]
    }
]

Veröffentlicht am
von

Die Programmiersprache C wurde Anfang der 70er Jahre von Dennis Ritchie entwickelt. Sie ist sehr leistungsstark und effizient. Daher stellt sie auch die Basis vieler neuer moderner Programmiersprachen dar.

Dieser Artikel ist eine kurze Zusammenfassung der wichtigsten Eigenschaften der Programmiersprache und ihrer Syntax.

Eigenschaften

  • Ermöglicht schnelle und direkte Speicherzugriffe
  • Case-sensitiv
  • Null-basierter Index
  • Keine objektorientierte Programmiersprache (vgl. C++)
  • Nicht typsicher

Syntax

In C folgt jedem Befehl ein Semikolon, außer nach Präprozessoranweisungen.

Kommentare

// Einzeiliger Kommentar
/*
   Mehrzeiliger
   Kommentar
*/

Datentypen

Für für die Größenordnung der Datentypen in C gilt:
char ≤ short int ≤ int ≤ long int ≤ long long int.

Anmerkung: Empfohlen wird die Verwendung der neuen Integer-Datentypen, die im C99-Standard definiert wurden, da hier gewährleistet ist, dass die Größe der Datentypen bei allen Compilern gleich groß ist. Bei den alten Integer-Datentypen kann die Größe je nach Compiler unterschiedlich sein. Auch die Genauigkeit (signifikante Nachkommastellen) von Gleitkommazahlen ist abhängig vom Compiler.

Neuer Datentyp Alter Datentyp Größe Wertebereich
 int8_t char  1 Byte -128
bis
127
uint8_t unsigned char  1 Byte 0
bis
255
 int16_t int 2 Byte -32.768
bis
32.767
uint16_t unsigned int 2 Byte 0
bis
65.535
 int32_t long 4 Byte -2.147.483.648
bis
2.147.483.647
uint32_t unsigned long 4 Byte 0
bis
4.294.967.295
 int64_t long long 8 Byte -9.223.372.036.854.775.808
bis
9.223.372.036.854.775.807
uint64_t unsigned long long 8 Byte 0
bis
18.446.744.073.709.551.615
Datentyp Größe Wertebereich
Kein bzw. beliebiger Typ
void
Boolsche Zahl
bool 1 Byte 0 (false)
oder
1 (true)
Zeichen (natürliche Zahlen)

signed		 char
char		 1 Byte -128
bis
127
unsigned char 1 Byte 0
bis
255
Natürliche Zahlen


signed
signed		 short
short int
short
short int		 2 Byte -32.768
bis
32.767
unsigned
unsigned		 short
short int		 2 Byte 0
bis
65.535

signed		 int
int		 2 Byte -32.768
bis
32.767
unsigned int 2 Byte 0
bis
65.535


signed
signed		 long
long int
long
long int		 4 Byte -2.147.483.648
bis
2.147.483.647
unsigned
unsigned		 long
long int		 4 Byte 0
bis
4.294.967.295


signed
signed		 long long
long long int
long long
long long int		 8 Byte -9.223.372.036.854.775.808
bis
9.223.372.036.854.775.807
unsigned
unsigned		 long long
long long int		 8 Byte 0
bis
18.446.744.073.709.551.615
size_t Maximales unsigned int (Prozessorabhängig)
Gleitkommazahlen
float 4 Byte 1,175494351E-38
bis
3,402823466E+38
double 8 Byte 2,2250738585072014E-308
bis
1,7976931348623158E+308
long double 16 Byte 3.4E-4932
bis
1.1E+4932

Variablen & Arrays

bool  bZustand = true;

int   iZahl = 3;
int   iZahl1, iZahl2 = 7;

float fKommazahl = 42.69;
int   iVektor[4] = {1,2,3,4};
int   iMatrix[2][3] = {{1,2,3},{4,5,6}};

char  cZeichen = 'S';
char  cZeichenkette[] = "Hallo Welt!";

Schlüsselwörter für Variablen

  • const: Konstante
  • static: Variable wird nach einem Anweisungsblock nicht verworfen, sondern speichert ihren Wert bis zum nächsten Aufrufen des Anweisungsblocks
  • register: Variable wird optimiert für schnelle und häufige Zugriffe als Registervariable im Prozessor gespeichert (wird bei modernen Compilern nicht empfohlen, da diese selbstständig Optimierungsaufgaben übernehmen)
  • volatile: Variable kann sich jederzeit ändern (z.B. durch eine Interrupt-Routine) und wird daher nicht optimiert und immer direkt aus dem Hardwarespeicher gelesen
  • extern: Variable ist in einem anderen C-File/H-File deklariert und verweist auf diese

Definition eines Datentyps

typedef unsigned long ulong; //ulong = unsigned long
ulong iZahl = 24;

Strukturierte Datentypen

typedef struct _Person {
    char  Name[30];
    int   Alter;
    float Groesse;
} Person;

Person sPersonen[10];

Union-Datenstruktur

Eine Union-Datenstruktur ähnelt einem strukturierten Datentyp, jedoch mit dem Unterschied, dass alle Untervariablen die selbe Speichergröße belegen. Der Speicherbedarf wird durch das größte Element bestimmt.

typedef union _Fahrzeug {
    typedef struct _Auto {
        int  Typ;       // 2 Byte
        int  Farbcode;  // 2 Byte
    } Auto;
    typedef struct _Fahrrad {
        bool Einrad;    // 1 Byte
        int  Modell;    // 2 Byte
        int  Farbcode;  // 2 Byte
    } Fahrrad;
} Fahrzeug;
typedef struct _Mobil {
    int Datentyp;       // Typ der Union-Datenstruktur
    Fahrzeug sFahrzeug; // 5 Byte
} Mobil;

Enumeration

enum Farbe {rot, gruen, blau};
/* rot   = 0
   gruen = 1
   blau  = 2
*/

enum Groesse {
    xs,
    s = 2,
    m,
    l = 2,
    xl
};
/* xs = 0
   s = 2
   m = 2
   l = 2
   xl = 4
*/

Zeiger

Zeiger (engl. pointer) halten die Speicheradresse des ersten Bytes einer Variablen. 
int iZahl;        // Variable vom Typ Integer
int *pZeiger;     // Zeiger mit Sprungweite Integer (2 Byte)
pZeiger = &iZahl; // Adresse von iZahl in pZeiger speichern
*pZeiger = 180;   // An der Adresse von pZeiger den Wert 180 zuweisen (iZahl ist jetzt also 180)

char str[20]; // Zeichenkette mit 20 Zeichen
char *pStr;   // Zeiger mit Sprungweite Character (1 Byte)
pStr = str;   // Anfangsadresse der Zeichenkette in pStr speichern (Arrays sind bereits Zeiger)

Person sMensch;      // Variable vom Strukturtyp Person
Person *pMensch;     // Pointer mit Sprungweite des Strukturtyps Person
pMensch = &sMensch;  // Adresse von sMensch in pMensch speichern
pMensch->Alter = 18; // An der Adresse des Unterelements Alter von pMensch den Wert 18 zuweisen (sMensch.Alter ist jetzt also 18)

Standard-Bibliotheken

  • <stdlib.h> // Standard-Bibliothek
  • <stdio.h> // Input Output Bibliothek
  • <stdbool.h> // Boolsche Zahl
  • <limit.h> // Natürliche Zahlen
  • <float.h> // Gleitkommazahlen
  • <stdint.h> // Neue Integer-Datentypen nach C99-Standard

Beispiel-Programmcode: Hello World

//Bibliotheken
#include <stdlib.h>
#include <stdio.h>

int main() {
    printf("Hello World!\n"); //Ausgabe auf der Konsole

    system("pause"); //Programm anhalten
    return EXIT_SUCCESS; //Programm beenden
}

Literatur

Notiz:

http://eriedel.info/info/c-prog/cpl1.html

https://de.wikipedia.org/wiki/C_(Programmiersprache)

https://de.wikipedia.org/wiki/C-Standard-Bibliothek