zurück

Wissensdatenbank

Elektronik

Verschiedene Spannungs-Stärken

Spannung (V) Verwendung Typ
1,5 Nennspannung pro Zelle einer Alkali-Mangan-Batterie/Zink-Kohle-Batterie Gleichstrom
1,5 Nennspannung pro Zelle einer Alkali-Mangan-Batterie Gleichstrom
0,75 Edison-Lalande-Element (historische Batterie) Gleichstrom
3,7 Nennspannung einer Zelle eine Lithium-Polymer-Akkus (LiPo; 1S) Gleichstrom
5 Betriebsspannung der Arduino und vieler anderer Mikrocontroller Gleichstrom
1,5 Nennspannung einer Monozelle (Alkali-Mangan bzw. Zink-Kohle) Gleichstrom
1,2 Nennspannung einer wiederaufladbaren Monozelle (Nickel-Metallhydrid bzw. Nickel-Cadmium) Gleichstrom
1,5 Nennspannung einer Babyzelle (Alkali-Mangan bzw. Zink-Kohle) Gleichstrom
1,2 Nennspannung einer wiederaufladbaren Babyzelle (Nickel-Metallhydrid bzw. Nickel-Cadmium) Gleichstrom
1,5 Nennspannung einer AA-/Mignon-Zelle (Alkali-Mangan bzw. Zink-Kohle) Gleichstrom
1,2 Nennspannung einer wiederaufladbaren AA-/Mignon-Zelle (Nickel-Metallhydrid bzw. Nickel-Cadmium) Gleichstrom
1,5 Nennspannung einer AAA-/Micro-Zelle (Alkali-Mangan bzw. Zink-Kohle) Gleichstrom
1,2 Nennspannung einer wiederaufladbaren AAA-/Micro-Zelle (Nickel-Metallhydrid bzw. Nickel-Cadmium) Gleichstrom
4,5 Nennspannung einer Flachbatterie (3R12) Gleichstrom
9 Nennspannung eines 9V-Blocks Gleichstrom
3 Nennspannung einer CR2032 bzw. CR2016 Knopfbatterie Gleichstrom
12 Autobatterie (Blei-Akkumulator) Gleichstrom
6 Fahrraddynamo Wechselstrom
120 Netzspannung der USA Wechselstrom
230 Netzspannung in Europa (± 23V) Wechselstrom
400 Netzspannung im Dreiphasensystem des europäischen Netzstroms (sog. "Starkstrom") Wechselstrom
100 Netzspannung in Japan Wechselstrom

Wechselschalter

SP
Single Pole: one circuit controlled by the switch.
DP
Double Pole: two independent circuits controlled by the switch which are mechanically linked.
ST
Single Throw: closes a circuit at only one position. The center position is off.
DT
Double Throw, closes a circuit in the up or down position (On-On). A Double Throw switch can also have a center position such as On-Off-On.

Note: "Pole" should not be confused with "Terminal". The DPST switch, for example has four terminals however is a Double Pole (DP) and not a four pole (4P) switch.

SPDT
Single pole, double throw: A simple break-before-make changeover switch: C (COM, Common) is connected either to L1 or to L2.
DPDT
Double pole, double throw: Equivalent to two SPDT switches controlled by a single mechanism.
SPST
Single pole, single throw: A simple on-off switch: The two terminals are either connected together or disconnected from each other. An example is a light switch.
DPST
Double pole, single throw: Equivalent to two SPST switches controlled by a single mechanism.

see: Switches explained PDF (152kB)

Raspberry Pi

GPIO-Modes

GPIO.setmode() nimmt einen Parameter entgegen:
GPIO.BOARD: Hiermit werden die Nummern der Pin so interpretiert, wie sie auf der Platine durchnummeriert sind (rund eingerahmte Zahlen im folgenden Diagramm)
GPIO.BCM: ("Broadcom SOC channel") Hiermit werden die Nummer als GPIO-Nummierung verstanden. (die Zahlen in den Kästchen im folgenden Diagramm)
Die BCM-Zahlen haben sich aber in den einzelnen Versions des RPi verändert, so dass man bei der Portierung hier aufpassen muss, so erweist es sich als etwas sicherer, die BOARD-Zahlen zu verwenden.

Arduino

Datentypen

C STDINT Größe Minimum Maximum
void - - - -
boolean - 1 Byte - -
byte uint8_t 1 Byte 0 255
char int8_t 1 Byte -128 127
unsigned char uint8_t 1 Byte 0 255
int int16_t 2 Bytes -32768 32767
unsigned int uint16_t 2 Bytes 0 65535
word - 2 Bytes - -
long int32_t 4 Bytes -2147483648 -2147483647
unsigned long uint32_t 4 Bytes 0 4294967295
float - 4 Bytes -3.4028235E+38 3.4028235E+38
double2) - 8 Bytes -3.4028235E+308 -3.4028235E+308
string - 1 Byte + x - -
array - 1 Byte + x - -
enum - N/A - -
struct - N/A - -
pointer - N/A - -

2) doppelte Präzision nur auf Arduino Due, ansonsten gleich float

SRAM / Flash / EEPROM

char message[] = "Hello World!"; speichert den Inhalt dieser Variablen im SRAM. Um diesen Speicher zu sparen, kann man Variablen auch im Flash (PROGMEM) memory speichern:
const PROGMEM char message[] = "Hello World!";
oder man benutzt folgendes Makro z.B.:
Serial.print(F("Hello, World"));
Es ist auch möglich, den EEPROM zu benutzen, aber dazu braucht man die Library EEPROM

printf

int serial_putchar(char c, FILE* f)
{
    if (c == '\n') serial_putchar('\r', f);
    return Serial.write(c) == 1? 0 : 1;
}

FILE serial_stdout;

void setup()
{
    Serial.begin(9600);

    // Set up stdout
    fdev_setup_stream(&serial_stdout, serial_putchar, NULL, _FDEV_SETUP_WRITE);
    stdout = &serial_stdout;

    printf("My favorite number is %6d!\n", 12);
}

Freien SRAM ermitteln (var. 1)

int freeRam ()
{
    extern int __heap_start, *__brkval;
    int v;
    return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

Serial.println(freeRam());

Freien SRAM ermitteln (var. 2)

int memoryTest()
{
    int byteCounter = 0;
    byte *byteArray;
    while ( (byteArray = (byte*) malloc (byteCounter * sizeof(byte))) != NULL ) {
        byteCounter++;
        free(byteArray);
    }
    free(byteArray);
    return byteCounter;
}

PWM für mehr Outputs

Ein kleiner Trick, um statt den 6 üblichen PWM-Pins auf dem Arduino quasi analogen Output zu ermöglich ist, statt die Pins mit GND zu verbinden, mit einem der PWM-Pins zu verbinden. Dadurch können alle diese Pins (auch nicht-PWM-fähige) die Möglichkeit erhalten mit analogWrite gesteuert zu werden, allerdings nur alles zusammen (siehe auch den Beitrag vom Hobbyelektroniker):

#define PIN_PWM 11

const byte leds[] = {2, 3, 4, 5, 6, 7};

void setup()
{
    pinMode(PIN_PWM, OUTPUT);
    for(byte i=0; i<sizeof(leds)/sizeof(byte); i++) {
        pinMode(leds[i], OUTPUT);
        digitalWrite(leds[i], HIGH);
    }
}

void loop()
{
    for(byte b=0; b<=255; b++) {
        analogWrite(PIN_PWM, b);
        delay(10);
    }
}

Glättung von Eingangs-Signalen

Fehlerhafte bzz. sprunghafte Eingangssignale werden mit dem folgenden Sketch geglättet/gemittelt. Als Sensor an A0 dient z.B. ein Potentiometer. (Quelle: http://www.arduino.cc/en/Tutorial/Smoothing)


// Define the number of samples to keep track of. The higher the number, the
// more the readings will be smoothed, but the slower the output will respond to
// the input. Using a constant rather than a normal variable lets us use this
// value to determine the size of the readings array.
const int numReadings = 10;

int readings[numReadings];      // the readings from the analog input
int readIndex = 0;              // the index of the current reading
int total = 0;                  // the running total
int average = 0;                // the average

int inputPin = A0;

void setup()
{
    Serial.begin(9600);
    // initialize all the readings to 0:
    for (int thisReading = 0; thisReading < numReadings; thisReading++) {
        readings[thisReading] = 0;
    }
}

void loop()
{
    // subtract the last reading:
    total = total - readings[readIndex];
    // read from the sensor:
    readings[readIndex] = analogRead(inputPin);
    // add the reading to the total:
    total = total + readings[readIndex];
    // advance to the next position in the array:
    readIndex = readIndex + 1;

    // if we're at the end of the array...
    if (readIndex >= numReadings) {
        // ...wrap around to the beginning:
        readIndex = 0;
    }

    // calculate the average:
    average = total / numReadings;

    // send it to the computer as ASCII digits
    Serial.println(average);
    delay(1);
}

Funk

Antennenlänge

λ = c / f      (Wellenlänge = Lichtgeschwindigkeit / Frequenz)
Lichtgeschwindigkeit = 299.792.458 m/s
Nun soll eine Antenne so sein, daß sie ein Vielfaches oder ein ganzzahliger Bruchteil der Wellenlänge ist, da sonst die Energieverluste an den Enden zu hoch sind. Wenn die Antennenlänge gleich der Wellenlänge ist, dann sind die Wellenknoten genau am Ende der Antenne und die Verluste sind sehr gering.