lehrkraefte:blc:informatik:ffprg2-2020:esp32-io-and-vars [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Typen ======
Alles in C++ muss einen Typ haben. Der Typ einer Variablen kann nicht geändert werden. 
===== Zahl-Typen =====
Die Typen ''uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t'' sind in ihrer Bezeichnung klar, ob ohne Vorzeichen (**u**nsigned) und wieviele Bits diese umfassen. Eigentlich sollte ausschliesslich damit gearbeitet werden.

Traditionellerweise gibt es folgende Typen, die aber je nach Platform unterschiedlich gross sind. Bei char ist nicht einmal klar, ob wenn als Zahl interpretiert es mit oder ohne Vorzeichen geschehen soll.
  * **int** und **unsigned int** EPS32: 4 Bytes, Arduino Uno: 2 Bytes
  * **long** und **long long**: 4 und 8 Bytes.
  * **float** und **double** Fliesskommazahlen, 4 bzw. 8 Bytes.
  * **bool** true oder false
  * **char** oder **byte**.

==== Umwandlung der Typen ====
Ist in einem Ausdruck ein float oder double involviert, ist auch das Resultat ein float oder double.

Sind in einem Ausdruck nur ganzzahlige Typen involviert, ist auch das Resultat ganzzahlig, wobei immer gegen Null hin gerundet wird:
<code c++>
void setup() {
  Serial.begin(115200);
  delay(200);
  int a=7;
  int b=6;
  int c = a/b;
  Serial.printf("[int]  %d/%d ist gleich %d\n",a,b,c);
  a = -7;
  c = a/b;
  Serial.printf("[int]  %d/%d ist gleich %d\n",a,b,c);
}

void loop() {
  // tu nix
}
</code>

==== Ausgabe mit Serial.printf ====
  * %d (int)
  * %f (float, double)
  * %l (long)
  * %du, %llu (unsigned int, unsigned long long)
  * %c (char)
  * \n Zeilenumbruch

[[http://www.cplusplus.com/reference/cstdio/printf/|Mehr zu printf]]
==== Speicherbedarf und Umfang ====

<code c++>
// Der Preprocessor erlaubt auch Macros:
#define SHOWSIZE(T) Serial.printf(#T " belegt %d Bytes\n", sizeof(T))

#define HASSIGN(T) Serial.print("2-3 ergibt in " #T " "); Serial.println((T)(((T)2)-((T)3)))

void setup() {
  Serial.begin(115200);
  delay(400);  // So wird nach dem Kompilieren die Ausgabe direkt ohne Reset angezeigt
  Serial.println("\n--------------\nSize of Types:\n--------------");

  SHOWSIZE(char);
  SHOWSIZE(byte);
  SHOWSIZE(short);
  SHOWSIZE(int);
  SHOWSIZE(long);
  SHOWSIZE(long long);
  Serial.println("-----------");
  SHOWSIZE(float);
  SHOWSIZE(double);
  Serial.println("-----------");
  HASSIGN(char);
  HASSIGN(byte);
  HASSIGN(signed char);
  HASSIGN(unsigned short);
  HASSIGN(unsigned int);
  unsigned long long a = -1;
  Serial.printf("unsigned long long -1 ist %llu", a);  
}

void loop() {
  // nix tun...
}
</code>

==== Rechengeschwindigkeit ====
<code c++>
#define RUN(TYPE, FORMAT) addtest<TYPE>(1000000, #TYPE, FORMAT)
#define RUM(TYPE, FORMAT) multest<TYPE>(1000000, #TYPE, FORMAT)

template<typename T>
void addtest(int n, char *t, char *f) {
  long zeit = micros();
  // volatile bezeichnet Variablen, die z.B. von Interrupts verändert werden könnten.
  // Damit kann der Kompiler keine Optimierungen machen, weil sich der Wert ausserhalb
  // des normalen Programmflusses ändern könnte.
  volatile T r = 0;     // Damit das Ding nicht wegoptimiert wird.
  volatile T a = 3456;  // Damit das Ding nicht wegoptimiert wird.
  for (int i=0; i<n; i++) {
    r = r+a;
  }
  zeit = micros()-zeit;
  Serial.printf("%d Additionen mit Typ %s braucht %d us\n", n, t, zeit);
  // Wenn das Resultat nicht gebraucht wird, wird die ganze Schleife
  // gnadenlos wegoptimiert ;-)
  Serial.print("Das Resultat: ");
  Serial.printf(f, r);
  Serial.println();
}

template<typename T>
void multest(int n, char *t, char *f) {
  long zeit = micros();
  volatile T b = 27; // Damit das Ding nicht wegoptimiert wird.
  volatile T r = 0;  // Damit das Ding nicht wegoptimiert wird.
  T a = 5234;
  for (int i=0; i<n; i++) {
    r = a*b;
  }
  zeit = micros()-zeit;
  Serial.printf("%d Multiplikationen mit Typ %s braucht %d us\n", n, t, zeit);
  // Wenn das Resultat nicht gebraucht wird, wird die ganze Schleife
  // gnadenlos wegoptimiert ;-)
  Serial.print("Das Resultat: ");
  Serial.printf(f, r);
  Serial.println();
}


void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.print("------------\n\n");
  RUN(int, "%d");
  RUN(long long, "%llu");
  RUN(float, "%f");
  RUN(double, "%f");
  
  Serial.println();
  
  RUM(int, "%d");
  RUM(long long, "%llu");
  RUM(float, "%f");
  RUM(double, "%f");

}

void loop() {
  // tu nix
}
</code>