Segmenting code into functions allows a programmer to create modular pieces of code that perform a defined task and then return to the area of code from which the function was “called”. The typical case for creating a function is when one needs to perform the same action multiple times in a program.

For programmers accustomed to using BASIC, functions in 86Duino provide (and extend) the utility of using subroutines (GOSUB in BASIC).

Standardizing code fragments into functions has several advantages:

  • Functions help the programmer stay organized. Often this helps to conceptualize the program.
  • Functions codify one action in one place so that the function only has to be thought out and debugged once.
  • This also reduces chances for errors in modification, if the code needs to be changed.
  • Functions make the whole sketch smaller and more compact because sections of code are reused many times.
  • They make it easier to reuse code in other programs by making it more modular, and as a nice side effect, using functions also often makes the code more readable.

There are two required functions in an 86Duino sketch, setup() and loop(). Other functions must be created outside the brackets of those two functions. As an example, we will create a simple function to multiply two numbers.



To “call” our simple multiply function, we pass it parameters of the datatype that it is expecting:

void loop{
  int i = 2;
  int j = 3;
  int k;

  k = myMultiplyFunction(i, j); // k now contains 6

Our function needs to be declared outside any other function, so “myMultiplyFunction()” can go either above or below the “loop()” function.

The entire sketch would then look like this:

void setup(){

void loop() {
  int i = 2;
  int j = 3;
  int k;

  k = myMultiplyFunction(i, j); // k now contains 6

int myMultiplyFunction(int x, int y){
  int result;
  result = x * y;
  return result;

Another example

This function will read a sensor five times with analogRead() and calculate the average of five readings. It then scales the data to 8 bits (0-255), and inverts it, returning the inverted result.

int ReadSens_and_Condition(){
  int i;
  int sval = 0;

  for (i = 0; i < 5; i++){
    sval = sval + analogRead(0);    // sensor on analog pin 0

  sval = sval / 5;    // average
  sval = sval / 4;    // scale to 8 bits (0 - 255)
  sval = 255 - sval;  // invert output
  return sval;

To call our function we just assign it to a variable.

int sens;

sens = ReadSens_and_Condition();

Language Reference Home

The text of the 86Duino reference is a modification of the Arduino reference, and is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the reference are released into the public domain.