Crash Course Programming for Arduino - Revision history

Mm: /* Data Types */

2009-11-29T02:01:06Z

Data Types

@@ Line 19: / Line 19: @@
 Variables can be typecasted (= converted from one datatype to another) by using the relevant functions: int(), long() or float().
-<source lang="c">
+{{Template:Datatypes}}
 == Variables ==

Mm: /* Functions */

2009-11-28T22:47:18Z

Functions

← Older revision		Revision as of 22:47, 28 November 2009
Line 212:		Line 212:
	[[Category:Arduino]]		[[Category:Arduino]]
	[[Category:C]]		[[Category:C]]
			[[Category:Electronics]]
	[[Category:Grundlagen]]		[[Category:Grundlagen]]
	[[Category:Hardware]]		[[Category:Hardware]]

Mm: assigned categories

2009-11-28T22:28:21Z

assigned categories

← Older revision		Revision as of 22:28, 28 November 2009
Line 5:		Line 5:
	Arduino is based on the C programming language, though it has some minor differences.		Arduino is based on the C programming language, though it has some minor differences.

	[http://de.wikibooks.org/wiki/C-Programmierung C-Programmierung (Wiki Book) Deutsch] - [http://en.wikibooks.org/wiki/C_Programming C-Programming (Wiki Book) English]		* [http://de.wikibooks.org/wiki/C-Programmierung C-Programmierung (Wiki Book) Deutsch]
			* [http://en.wikibooks.org/wiki/C_Programming C-Programming (Wiki Book) English]

	Ein günstiges (10,- €) und sehr gutes Buch ist: Helmut Erlenkötter "C Programmieren von Anfang an", ISBN 3499600749		Ein günstiges (10,- €) und sehr gutes Buch ist:
			* Helmut Erlenkötter "C Programmieren von Anfang an", ISBN 3499600749

	== Data Types ==		== Data Types ==
Line 207:		Line 209:
	-----		-----
	Diese Seite ist Teil des Werkmoduls ''[[GMU:Wearables]]'' von Michael Markert für GMU - Gestaltung medialer Umgebungen an der Bauhaus-Universität Weimar.		Diese Seite ist Teil des Werkmoduls ''[[GMU:Wearables]]'' von Michael Markert für GMU - Gestaltung medialer Umgebungen an der Bauhaus-Universität Weimar.

			[[Category:Arduino]]
			[[Category:C]]
			[[Category:Grundlagen]]
			[[Category:Hardware]]
			[[Category:Interfaces]]
			[[Category:Michael Markert]]
			[[Category:Programmiersprachen]]

Mm: converted for new wiki & geshi syntax

2009-11-28T22:20:40Z

converted for new wiki & geshi syntax

Show changes

Max at 13:42, 21 November 2009

2009-11-21T13:42:45Z

← Older revision		Revision as of 13:42, 21 November 2009
Line 206:		Line 206:

	-----		-----
	Diese Seite ist Teil des Werkmoduls ''[[~~WS08~~:Wearables]]'' von Michael Markert für ~~[http://www.damm-net.org~~ GMU - Gestaltung medialer Umgebungen] an der Bauhaus-Universität Weimar.		Diese Seite ist Teil des Werkmoduls ''[[GMU:Wearables]]'' von Michael Markert für GMU - Gestaltung medialer Umgebungen an der Bauhaus-Universität Weimar.

Max: Created page with '== Preface == Please refer to the official [http://arduino.cc/en/Reference/HomePage Arduino Programming Language reference] (also stored locally if Arduino installed) Arduino i…'

2009-11-21T13:42:09Z

Created page with '== Preface == Please refer to the official [http://arduino.cc/en/Reference/HomePage Arduino Programming Language reference] (also stored locally if Arduino installed) Arduino i…'

New page

== Preface ==

Please refer to the official [http://arduino.cc/en/Reference/HomePage Arduino Programming Language reference] (also stored locally if Arduino installed)

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

[http://de.wikibooks.org/wiki/C-Programmierung C-Programmierung (Wiki Book) Deutsch] - [http://en.wikibooks.org/wiki/C_Programming C-Programming (Wiki Book) English]

Ein günstiges (10,- €) und sehr gutes Buch ist: Helmut Erlenkötter "C Programmieren von Anfang an", ISBN 3499600749

== 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().

<code lang="c">
void 0 bytes, 0bit, 0
boolean 1 byte, 1 bit, 0/1
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 4 bytes, 32 bit

array
String
...
</code>

== Variables ==

Variables have to be declared by:
type name;
before they are used!

e.g.
<code lang="c">
int x;
byte b;
</code>

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 [http://en.wikipedia.org/wiki/Camel_case#Variations_and_synonyms lower camel case] for improved readability.

<code lang="c">
// This is nice lower camel case
boolean isEnabled;
</code>

Variables can be declared and instantiated in one step:

type name = value;

e.g.
<code lang="c">
int x = 5;
long r = random(255);
int values[6] = {0,1,2,3,4,5};
</code>
===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.

<code lang="c">
// Global variable
int x = 7;
void myFunction() {
// Local variable
int a = 8;
}
</code>

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!

<code lang="c">
// 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;
}
</code>

=== 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.

<code lang="c">
type name[length];

</code>

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

For example:
<code lang="c">
// 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";
</code>

==== 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.
<code lang="c">
int someNumbers[] = {45, 5, 6};
int firstElement = someNumbers[0]; // = 45
int secondElement = someNumbers[1]; // = 5
int thirdElement = someNumbers[2]; // = 6
</code>

==== 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.
<code lang="c">
char* myWords[] = {"One", "Two", "Three"};
</code>

== Main Functions ==

An Arduino program consists of two basic functions: start() and loop():
<code lang="c">
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
}
</code>

== Functions ==

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

e.g. the two main Arduino functions:

<code lang="c">
void setup() {
// Anweisungen, die einmal beim Start des Programms ausgeführt werden
doWhatever();
}
void loop() {
// Anweisungen, die fortlaufend ausgeführt werden
doWhatever();
}
</code>

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

<code lang="c">
void randomizeColor() {
// Instructions
doWhatever();
// here may be a "return;" (but it mustn't, it's optional)
return;
}
</code>
or
<code lang="c">
int multipliziere(int a, int b) {
// Multipliziere a und b und gebe diesen Wert zurück
return a * b;
}
</code>

'''Calling Functions'''

variable = funktionsName(parameter);

e.g.:
<code lang="c">
int x = multipliziere(2,5); // x = 10;
delay(1000);
c = min(x,y);
</code>

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



-----
Diese Seite ist Teil des Werkmoduls ''[[WS08:Wearables]]'' von Michael Markert für [http://www.damm-net.org GMU - Gestaltung medialer Umgebungen] an der Bauhaus-Universität Weimar.