Preface

Please refer to the official Arduino Programming Language reference (also stored locally if Arduino installed)

Arduino is based on the C programming language, though it has some minor differences.

Ein günstiges (10,- €) und sehr gutes Buch ist:

Data Types

The length of the following datatypes is referring to Arduino. Note that lengths can vary depending on the platform - even if the language is C!

All datatypes are more or less similar in most of the modern programming languages. In some languages, variables must be explicitly bound to a certain datatype (as in C), in other languages, the compilers do this job for you.

Variables can be typecasted (= converted from one datatype to another) by using the relevant functions: int(), long() or float().

void		// 0 bytes 	0 bit 	=> 0
boolean		// 1 byte 	1 bit 	=> 0/1; true/false
char		// 1 byte 	8 bit 	=> -128..127
byte		// 1 bytes 	8 bit 	=> 0..255
int		// 2 bytes 	16 bit 	=> -32768..32767
unsigned int	// 2 bytes 	16 bit 	=> 0..65535
long		// 4 bytes 	32 bit 	=> -2147483648..2147483647
unsigned long	// 4 bytes 	32 bit 	=> 0..4294967295
float		// 4 bytes 	32 bit	=> -3.4028235E+38..3.4028235E+38
double		// 8 bytes 	64 bit	=> a lot!
	
Array
String
...


Variables

Variables have to be declared by:

 type name;

before they are used!

e.g.

int x;
byte b;

Variable names mustn't contain any special characters, especially no spaces. Try to use descriptive names for your variables. It's widely regarded good practise to use lower camel case for improved readability.

// This is nice lower camel case
boolean isEnabled;

Variables can be declared and instantiated in one step:

 type name = value;

e.g.

int x = 5;
long r = random(255);
int values[6] = {0,1,2,3,4,5};

Variable Scope

If a variable is declared inside a function, it is a local variable, if declared outside any function, it's scope is global, that means it can be accessed from anywhere.

// Global variable
int x = 7;
void myFunction() {
   // Local variable
   int a = 8;
}

Never give local variables and global variables the same name. Two local variables can have the same name only when they are defined in different functions!

// This is not ok!
int x = 5;
void myFunction() {
   int x = 3;
}

// This however is ok
void functionA() {
   int a = 7;
}

void functionB() {
   int a = 12;
}

Arrays

Arrays are data Structures holding multiple elements of the same datatype.

Declaring Arrays

Declaring Arrays is pretty much like declaring variables only for arrays the name is followed by square brackets '[]' enclosing an optional length parameter.

type name[length];

You don't have to define a length parameter but if if you do, the Array wont hold more elements than specified.

For example:

// Create an array without assigning values
int myArray[];
// Create a integer Array with 3 spaces
int someNumbers[3] = {1, 2, 3};
// Create a integer Array with an unlimited length
int moreNumbers[] = {1, 2, 3, 4};
// Create a String (in C this is an Array of chars)
int myWord[] = "hello";

Accessing Arrays

You can access variables stored in an Array by their index. Indices go from 0 to length-1. In an Array with 3 elements the first element has the index 0 and the last element has the index 2.

int someNumbers[] = {45, 5, 6};
int firstElement = someNumbers[0]; // = 45
int secondElement = someNumbers[1]; // = 5
int thirdElement = someNumbers[2]; // = 6

Creating an Array of Strings

Since Strings itself already are Arrays, creating an Array of Strings is basically creating two-dimensional Arrays. Since all this goes pretty deep into C programming it's best to just follow the example. Note the extra asterisk after the type.

char* myWords[] = {"One", "Two", "Three"};

Main Functions

An Arduino program consists of two basic functions: start() and loop():

void start() {
   // init code that is executed ONCE only: at the start of the program (eg. when power is attached)
}

void loop() {
   // code that gets executed as long as the arduino is powered
}


Functions

 returnType functionName(parameterType parameter) {
 	// Instruction
 	doWhatever();
 }


e.g. the two main Arduino functions:

void setup() {
	// Anweisungen, die einmal beim Start des Programms ausgeführt werden
	doWhatever();
}
void loop() {
	// Anweisungen, die fortlaufend ausgeführt werden
	doWhatever();
}

Instructions can be summarised as a function, e.g.:

void randomizeColor() {
	// Instructions
	doWhatever();
	// here may be a "return;" (but it mustn't, it's optional)
	return;
}

or

int multipliziere(int a, int b) {
	// Multipliziere a und b und gebe diesen Wert zurück
	return a * b;
}


Calling Functions

 variable = funktionsName(parameter);

e.g.:

int x = multipliziere(2,5);	// x = 10;
delay(1000);
c = min(x,y);

... see the Arduino Reference to find more pre-defined functions, that are ready to be used!



Diese Seite ist Teil des Werkmoduls GMU:Wearables von Michael Markert für GMUGestaltung medialer Umgebungen - Gestaltung medialer Umgebungen an der Bauhaus-Universität Weimar.