zurück zur Übersicht...

Wissensdatenbank

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.