Page 20

void setup() { Serial.begin(115200); Serial.println("Hello floating point"); float x = 0.3; float y = 2.0; Serial.println(x / y, 7); Serial.println(y / x, 7); Serial.println( y * x, 7); }
Floating point precision issues that might turn up to bite you are not confined to division. The subtraction of two numbers that are very similar can produce a result that is imprecise and may cause issues if that small value is used in later calculations.
If adding up a lengthy sequence of floating point values it is good practice to start with the lowest values first.

Page 22

Page 22 introduces literal values. One of those can be used to define a binary number and the page suggests a format that is now deprecated (although still valid).

int bb = B1100011;
To avoid warning messages you should consider using the prefix 0b or 0B instead of the single B.
int bb = 0b1100011

The preferred new literal prefix is consistent with the hexadecimal prefix I suppose but that begs a question or two about a preceeding zero being used to define a numeric literal in Octal format. [This catches programmers out frequently.]

Page 28

void setup() { Serial.begin(115200); char pad[] = "just some text"; char test[] = "program"; Serial.println(test); test[-2] = 'z'; Serial.println(pad); }

void setup() { Serial.begin(115200); char test[12] = "program"; Serial.println(test); test[9] = 'x'; test[10] = 'y'; test[11] = '\0'; Serial.println(test); }

Page 37

void setup() { Serial.begin(115200); byte x = 34; // maximum byte value is 255 int y = 32765; x = y; Serial.println(x); }

Page 38

void setup() { Serial.begin(115200); int x = 9; int y = 2; float f = x/ y; Serial.print("x / y = "); Serial.println(f); f = x / (float)y; Serial.print("x / (float)y = "); Serial.println(f); int a = 123; int b = 456; int c = a + b; Serial.print("a + b = "); Serial.println(c); c = (char)(a + b); Serial.print("(char)(a + b) = "); Serial.println(c); }

Page 42

void setup() {     Serial.begin(115200);     Serial.println("Type me a number 0 to 2"); } void loop() {     byte nChar = 0;     if (Serial.available() > 0) {         nChar = Serial.read();         switch(nChar){          case '0':             Serial.println("Lets go higher");             break;          case '1':             Serial.println("Getting started");             break;          case '2':             Serial.println("Thats my number");             break;          default:             Serial.println("Just 0 to 2, please");             break;         }     } }

Page 45

void setup() {     Serial.begin(115200);     for(int lp = 1; lp < 11; lp++) {      Serial.println(lp);     } }

Page 46

void setup() {     Serial.begin(115200);     for(int lp = 10, j = 0; lp > j; lp--) {      Serial.println(lp);     } }


The book correctly says that you can use any sort of numeric variable to control a for loop. That includes a float. However you need to take care that rounding errors do not upset things.

The following little code sample is a for loop controlled by a float where you might expect the output to the serial monitor would have 11 lines showing 0 to 1 in steps of 0.1.

for (float f = 0; f <= 1.0; f += 0.1) {      Serial.println(f, 7); }

What you get is just 10 lines because at that point the variable f has a value of 0.9000001. adding 0.1 to that value makes f more than 1.0 so the loop terminates. You have to watch those floats.
I got this excellent example from a Rod Stepen C# post. He points out a great solution should you need that sequence of 11 floating point numbers.

for (int i = 0; i < 11; i++) {     Serial.println(i * 0.1, 7); }

Page 51

void setup() { Serial.begin(115200); byte a = 244; int b = 12; Serial.println(ourMax(a, b)); } long ourMax(long x, long y) { if(x > y) {     return x; } return y; }

Page 52

void setup() { Serial.begin(115200); int test[] = {23, 76, 81, 1, 9, 677, 9876, 11}; Serial.print("Array test element count: "); Serial.println(sizeof(test) / sizeof(test[0])); Serial.println(getMax(test)); } int getMax(int mInts[]){ Serial.print("Size of argument mInts: "); Serial.println(sizeof(mInts)); }

Page 53

void setup() { Serial.begin(115200); int test[] = {23, 76, 81, 1, 9, 677, 9876, 11}; Serial.print("Maximum value: "); Serial.println(getMax(test, sizeof(test) / sizeof(test[0]))); } int getMax(int mInts[], int arrayLen){ int maxVal = -32768; // lowest 16 bit int value for(int i = 0; i < arrayLen; i++) {     if (mInts[i] > maxVal){      maxVal = mInts[i];     } } return maxVal; }

Page 54

void setup() { Serial.begin(115200); float test = 32.8765; long res2 = 0; long res1 = myFunct(test, &res2); Serial.print("Result: "); Serial.println(res1); Serial.print("Other result: "); Serial.println(res2); } long myFunct(float num, long* b) { long a = floor(num); // floor returns the int part of num b = a * a; // sets the value of res2 back in the setup() function              // to the square of a return a; }

Page 58

void setup() { Serial.begin(115200); Serial.print("Series total is "); Serial.println(getSum(9, 34, 76, 54, 34, 12, 22, 90, 101, 33)); } int getSum(int x, ...) { int sum = 0 ; va_list args; va_start(args, x); for(int i = 0 ; i < x ; i++) {     sum += va_arg(args, int); } va_end(args); return sum; }

Page 60

void setup() { Serial.begin(115200); int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int* po = &array[0]; for (int i = 0; i < 9; i++) {     Serial.print("Pointer value: ");     Serial.print((int)po);     Serial.print(" array value: ");     Serial.println(*po);     po++; } foo(array); } void foo(int array[]) { Serial.print("Pointer to array: "); Serial.println((int)array); Serial.print("value at array[0]: "); Serial.println(*array); }

Page 63

void setup() { Serial.begin(115200); char array[][9] = {"January", "February", "March", "April"}; inspect(array); } void inspect(char array[][9]){ for (int p = 0; p < 4; p++) {     Serial.print("Pointer value: ");     Serial.println((int)array);     Serial.println(*array);     array++; // increment the pointer } }

Page 64

void setup() { Serial.begin(115200); char months[][2][9] = {     {"Jan", "January"},     {"Feb", "February"},     {"Mar", "March"},     {"Apr", "April"},     {"May", "May"},     {"Jun", "June"},     {"Jul", "July"},     {"Aug", "August"},     {"Sep", "September"},     {"Oct", "October"},     {"Nov", "November"},     {"Dec", "December"} }; Serial.println(months[0][0]);     // outputs “Jan” Serial.println(months[3][1]); // outputs “April” Serial.println(&months[0][0][0]); // outputs “Jan” Serial.println(&months[3][1][0]); // outputs “April” }

Page 65

void setup() { Serial.begin(115200); int x = 7; int* p1 = &x; int **p2 = &p1; Serial.print("The address of x: "); Serial.println((int)p1); Serial.print("The value of x: "); Serial.println(*p1); Serial.print("The address of pointer p1: "); Serial.println((int)&p1); Serial.print("The value at P2: "); Serial.println((int)p2); Serial.print("The value P2 indirectly points to: "); Serial.println(**p2); Serial.print("The address of P2: "); Serial.println((int)&p2); }

Page 68

void setup() { Serial.begin(115200); int (*ptr)(float, int); // declares the pointer type ptr = func1;             // ptr is initialised int a = ptr(3.2, 5);     // calls func1() using ptr Serial.println(a); ptr = func2;             // resets ptr to point to func2() Serial.println(ptr(55.0, 5)); // calls func2() using ptr } int func1(float x, int y){ return y *= x; } int func2(float x, int y){ return x /y; }

void (*actions[3])(int, int); // declares a function pointer array const int IN_1 = A0 ; const int IN_2 = A1 ; void setup() { Serial.begin(115200); actions[0] = actionA; // initialises the array elements actions[1] = actionB; actions[2] = actionC; } void loop() { int a = analogRead(IN_1); // will get a random value int b = analogRead(IN_2); // if pin not connected if(Serial.available()) {     int act = Serial.parseInt();     actions[act](a, b);     // calls a function selected from the                             // function pointer array } } void actionA(int temp, int sg) { Serial.println("Running action A"); // dummy actions } void actionB(int temp, int sg) { Serial.println("Running action B"); } void actionC(int temp, int sg) { Serial.println("Running action C"); }

Page 69

void setup() { Serial.begin(115200); Serial.println(math(21, 4, mod)); } int math(int a, int b, int (*mathOp)(int, int)) { return mathOp(a, b); } int sum(int a, int b) { return a + b; } int prod(int a, int b) { return a * b; } int divd(int a, int b) { return a / b; } int mod(int a, int b) { return a % b; }

Page 70

typedef int (*fptr)(int); // defines the fptr function pointer type void setup() { Serial.begin(115200); fptr z = func(-4); Serial.println(z(3)); Serial.println(func(7)(4)); } int f1(int x) { return x * 23; } int f2(int x) { return x * 56; } fptr func(int a) {     // defines a function that returns the fptr type if(a > 0) {     return f1;     // returns a pointer to f1 } return f2;        // returns a pointer to f2 }

Page 75

struct compo { struct {     byte red;     byte green;     byte blue; } colours; byte bright; }; void setup() { Serial.begin(115200); compo nextComp; nextComp.colours.red = 255; compo* comptr = &nextComp;    // defines the pointer Serial.println((*comptr).colours.red);    // uses the pointer to access the struct instance member }

Page 77

union { int tempInt; float tempFloat; long tempLong; } tempVar = {tempFloat: 67.8};     // initialises a float value in tempVar union vars{ int intVar; float fVar; };                 // declares a named union type vars void setup() { Serial.begin(115200); Serial.println(tempVar.tempFloat);    // displays 67.80 vars myVar;             // creates an instance of the vars union type myVar.fVar = 8.9876;         // assigns a float value to that instance Serial.println(myVar.intVar);     // result is ?? vars myOtherVar = {intVar: 327}; // creates and initialises new instance of vars }

Page 79

enum ValueType {INTS, FLOATS, LONGS, UINTS, ULONGS, BYTE}; struct variant { ValueType v_type; union {     int intVar;     float floatVar;     long longVar;     unsigned int uintVar;     unsigned long ulongVar;     byte byteVar; }; }; void setup() { Serial.begin(115200); variant arg = {INTS, {intVar: 77}}; Serial.println(arg.intVar); variant* vptr = &arg; vptr->intVar = 45; Serial.println(vptr->intVar); }

Page 80

union { struct{     byte b0:1;     byte b1:1;     byte b2:1;     byte b3:1;     byte b4:1;     byte b5:1;     byte b6:1;     byte b7:1; }bits; byte bt; } binb; void setup() { Serial.begin(115200); binb.bt = 'a'; // set the union byte value Serial.println(binb.bt, BIN);     // display the significant bits of the byte Serial.println(binb.bits.b0);     // display individual bits Serial.println(binb.bits.b1); Serial.println(binb.bits.b2); Serial.println(binb.bits.b3); Serial.println(binb.bits.b4); Serial.println(binb.bits.b5); Serial.println(binb.bits.b6); Serial.println(binb.bits.b7); binb.bits.b1 = 1;     // set one of the bits Serial.println((char)binb.bt);    // review the result }

Page 82

struct Position{ int x; int y; int z; Position operator+(const Position& p){     Position pos;     pos.x = this->x + p.x;     pos.y = this->y + p.y;     pos.z = this->z + p.z;     return pos; }; }; inline Position operator++(Position& p) { p.x++; p.y++; p.z++; } void setup() { Serial.begin(115200); Position pos = {23, 45, 46}; Position vect = {5, 10, 0}; pos = pos + vect; Serial.print("x: "); Serial.print(pos.x); Serial.print(", y: "); Serial.print(pos.y); Serial.print(", z: "); Serial.println(pos.z); pos++; Serial.print("x: "); Serial.print(pos.x); Serial.print(", y: "); Serial.print(pos.y); Serial.print(", z: "); Serial.println(pos.z); }

Page 83

struct Position{ int x; int y; int z; Position operator+(const Position& p){     Position pos;     pos.x = this->x + p.x;     pos.y = this->y + p.y;     pos.z = this->z + p.z;     return pos; }; }; inline Position operator++(Position& p) { p.x++; p.y++; p.z++; } template<class T> inline Print &operator <<(Print &obj, T arg) { obj.print(arg); return obj; } #define endl "\n" void setup() { Serial.begin(115200); Position pos = {23, 45, 46}; Position vect = {5, 10, 0}; pos = pos + vect; Serial << "x: " << pos.x << ", y: " << pos.y << ", z: " << pos.z << endl; pos++; Serial << "x: " << pos.x << ", y: " << pos.y << ", z: " << pos.z << endl; }

template<class T> inline T const& Min (T const& a, T const& b) { return (a > b) ? b : a; } void setup() { Serial.begin(115200); Serial.print("Min of 8 or 9 is: "); Serial.println(Min(8, 9)); Serial.print("Min of 76.9 or 4.5: "); Serial.println(Min(76.9, 4.5)); }