• Beginnend met #
• One-Liners
• Geen ;
• Een stap voor compilatie
• Substitutie
• Gebruik
• Directives
• Macros

        #define THIS_EXISTS
        #ifdef THIS_EXIST
          //THEN DO THIS
        #endif

        #include <file>

        #define PI 3.14

        #define EDIT_BIT(bit) (1 << BIT )
      

• #define
• Object-Like Macro
• Function-Like Macro
• Substitutie

        #define THIS_EXISTS

        #define PI 3.14

        #define EDIT_BIT(bit) (1 << BIT )
      

Test Code met Variabele

        #include 
        static const  foo =  6;

        int  main() {
          printf("%d", foo);
          return 0;
        }
      

Test Code met Macro

        #include 
        #define foo 6

        int  main() {
          printf("%d",foo);
          return 0;
        }
      

Gecompileerde ASM Code met Variabele

        push rbp
        mov rbp,rsp
        sub rsp,0x20
        call d 
        mov eax,0x6
        mov edx,eax
        lea rcx,[rip+Ox4]
        call 20 
        mov eax,0x0
        add rsp,0x20
        pop rbp
        ret
        nop
      

Gecompileerde ASM Code met Macro

        push rbp
        mov rbp,rsp
        sub rsp,0x20
        call d 
        mov edx,0x6
        lea rcx,[rip+Ox0]
        call le 
        mov eax,0x0
        add rsp,0x20
        pop rbp
        ret
        nop
      

Gecompileerde Code

        sub rsp,Ox28
        call 9 
        lea rcx,[rip+Ox0]
        mov edx,0x6
        call 1a 
        xor eax,eax
        add rsp,Ox28
        ret
        nop
      

• Door preprocessor te gebruiken
• Declareer dit in het begin van de source file
• #include "TestHeader.h"
• "Zoekt in folder"
• #include <TestHeader.h>
• "Zoekt in PATH"

        
          #include "mylib.h"
          #include <mylib.h>
          int main(){
          }
        
      

• Geen ambiguïteit
• Geen 2 dezelfde includes
• Kan file size verkleinen

        #ifndef _TEST_LIB_H_
        #define _TEST_LIB_H_

          /***************/
          /*             */ 
          /*    YOUR     */ 
          /*    CODE     */ 
          /*    HERE     */ 
          /*             */ 
          /***************/

        #endif
      

mystruct.h

        struct myStruct{
          int x;
          double y;
          char z;
        };
      

myproject.ino

        #include "mystruct.h"
        #include "mystruct.h"

        void setup(){
          //DO SOMETHING
        }

        void loop(){
          //DO SOMETHING
        }
      

myproject.ino

        struct myStruct{
          int x;
          double y;
          char z;
        };
        // Dubbele declaratie 
        // Compile Error
        struct myStruct{ 
          int x;         
          double y;
          char z;
        };

        void setup(){
          //DO SOMETHING
        }

        void loop(){
          //DO SOMETHING
        }
      

mystruct.h

        #ifndef _TEST_LIB_H_
        #define _TEST_LIB_H_

        struct myStruct{
          int x;
          double y;
          char z;
        };
        #endif
      

myproject.ino

        #include "mystruct.h"
        #include "mystruct.h"

        void setup(){
          //DO SOMETHING
        }

        void loop(){
          //DO SOMETHING
        }
      

myproject.ino

        struct myStruct{
          int x;
          double y;
          char z;
        };
        // Geen compile error

        void setup(){
          //DO SOMETHING
        }

        void loop(){
          //DO SOMETHING
        }
      

• Selectief Include
• Specifieke output afhankelijk van compile opties
• Cross Compatibility
• Code verkleinen

#ifndef _AVR_IO_H_
#define _AVR_IO_H_

#include 

#if defined (__AVR_AT94K__)
#  include 
#elif defined (__AVR_AT43USB320__)
#  include 
#elif defined (__AVR_AT43USB355__)
#endif

#endif /* _AVR_IO_H_ */

      

• public
• Members toegankelijk buiten de class
• Geen set/get
• protected
• Members toegangelijk voor child classes
• Overerving niet vaak gebruik op het Arduino platform
• private
• Members alleen toegankelijk voor class members
• Set / Get nodig
• Default optie

        class Base {

          public:

          // public members go here

          protected:

          // protected members go here

          private:

          // private members go here
      }
      

          class Box {
             public:
                double length;      // Length of a box
                double breadth;     // Breadth of a box
                double height;      // Height of a box

                double getVolume(void) {
                   return length * breadth * height;
                }
          };
      

          class Box {
             public:
                double length;      // Length of a box
                double breadth;     // Breadth of a box
                double height;      // Height of a box
          };

          double Box::getVolume(void) {
            return length * breadth * height;
          }
      

        #ifndef Morse_h
        #define Morse_h

        #include "Arduino.h"

        class Morse
        {
          public:
            Morse(int pin);
            void dot();
            void dash();
          private:
            int _pin;
        };

        #endif
      

        Morse::Morse(int pin)
        {
          pinMode(pin, OUTPUT);
          _pin = pin;
        }

        void Morse::dot()
        {
          digitalWrite(_pin, HIGH);
          delay(250);
          digitalWrite(_pin, LOW);
          delay(250);  
        }

        void Morse::dash()
        {
          digitalWrite(_pin, HIGH);
          delay(1000);
          digitalWrite(_pin, LOW);
          delay(250);
        }
      

• Het volgende stuk code swap de variabelen niet
• Er word een lokale kopie gemaakt
• Dit noemt Pass By Value
• De originele data word beschermt

void swap(int x, int y){
  int tmp;
  tmp = x
  x = y;
  y = tmp;
}
void main(void){
  int a = 10;
  int b = 13;

  swap (a, b);
}
/*y == ? && z == ?*/
        

• De data wisselt tussen de variabelen
• Toegang tot de variabele is mogelijk door indirecte toegang
• Data moet niet gedupliceerd worden
• Pass By Reference
• Concept bestaat ook in andere programmeer talen

void swap(int *x, int *y){
  int tmp;
  tmp = *x
  *x = *y;
  *y = tmp;
}
void main(void){
  int a = 10;
  int b = 13;

  swap (&a, &b);
}
/*y == ? && z == ?*/
        

• Arrays is een blok van dezelfde data types
• Een array kan beschouwd worden als een pointer van hetzelfde type
• Een pointer kan een startpunt zijn voor een array

int *p
int a[1O]

p = &(a[2]);

/*Dan klopt het volgende*/
*p = a[2];
*(p+ 1) = a[3];
      

• Pointer is een adres
• Pointers geven niet altijd een lengte mee
• Functies mbt tot buffers hebben meestal beide nodig

void RF24::read(void *buf, uint8_t  len)
bool RF24::write(const void *buf, uint8_t len)
      

• De groote van een element - sizeof()

int data[10]="Hello World"
for (int i = 0; i < sizeof(data)/sizof(int); i++){
  //dosomething
}
    

int data[10]="Hello World"
 write(data, sizeof(data));
    

Status van een lamp: 1 ? 0

1 bit informatie

sizeof(int) = 4 bytes

• Overkill

Kleinste datatype =

• Byte

Oplossing

• Data verzamelen in één element