This is a list of useful functions for the Arduino. I found it posted on the MAKE magazine website.

ArduinoHelperFx.ino

//http://makezine.com/2014/03/24/arduino-helper-functions-2/
/*Here’s some helpful functions for Arduino.
Blinking an LED

This function blinks an LED light as many times as requested, at the requested blinking rate.
*/
void blinkLED(byte targetPin, int numBlinks, int blinkRate) {
  for (int i=0; i < numBlinks; i++) {
    digitalWrite(targetPin, HIGH);   
    delay(blinkRate);                
    digitalWrite(targetPin, LOW);   
    delay(blinkRate);
  }
}

/*Blinking a Number

Back in the dawn age of computing sometimes things went wrong enough that the only way to
communicate an error to the user was to blink a light. When dealing with micro-controllers
this can sometimes come in handy. The following function blinks a sequence to indicate a
number visually.
*/
void blinkNumber(char* numString) {
    int versLength = strlen(numString);
  delay(200);
    for (int i =0 ; i < versLength; i++) {
      int number = numString[i] -48;
      if (number == 0){
        blinkLED(LED_A,1,20);
        delay(160);
      }
      if (number > 0 && number < 10) blinkLED(LED_A,number,200);
      delay(400);
    }
}

/*Buzzing a Buzzer

A generalised generalised function to make use of Piezo buzzers without having to think through the
math each time you want to hear a particular sound frequency. All you need to do is tell the function
which pin you’d like to use, the frequency you want to hear, and the duration to play that frequency.
*/
void buzz(int targetPin, long frequency, long length) {
  long delayValue = 1000000/frequency/2;
  long numCycles = frequency * length/ 1000;
  for (long i=0; i < numCycles; i++){ 
    digitalWrite(targetPin,HIGH);
    delayMicroseconds(delayValue); 
    digitalWrite(targetPin,LOW);
    delayMicroseconds(delayValue); 
  }
}
/*
Checking Free RAM

The ATmega328 has 32K of program memory but only 2K of SRAM. Program memory is for code and RAM is for
dynamic variables. Actually it’s effectively less than 2K of RAM, because the Arduino libraries will
take up some dynamic memory space for themselves.

The Arduino environment will happily let you compile a program that exceeds the micro-controller’s
SRAM limits, however program behavior will become totally unpredictable, the code will do bizarre
things and/or crash. This function will return the number of bytes currently free in SRAM.
*/
int memoryTest() {
  int byteCounter = 0;
  byte *byteArray; 
  while ( (byteArray = (byte*) malloc (byteCounter * sizeof(byte))) != NULL ) {
    byteCounter++; 
    free(byteArray); 
  }
  free(byteArray); 
  return byteCounter;
}

/*Mapping Bigger Numbers

This is a version of the map function capable of handling larger positive numbers,
although it fails with negative ones.
*/
long mapBig(unsigned long x, unsigned long in_min, unsigned long in_max, 
            unsigned long out_min, unsigned long out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

/*Connecting to WiFi

The new Arduino WiFi shield is a pretty nice board. However dealing with different
types of network can be troublesome. The following code snippet, will attempt to
connect to a WPA/WPA2 encrypted WiFi network whose SSID is stored in the ssid variable,
and password stored in the pass variable. However if it can’t find that network it
will fall back and scan for open WiFi networks instead.
*/
    if (WiFi.status() == WL_NO_SHIELD) {
      Serial.println("WiFi shield not present"); 
      while(true);
    }   

    if ( stringFromCharString(ssid) != "" ) {
       while ( status != WL_CONNECTED) { 
         timesWeTriedToConnect++;
         Serial.print(F("Attempting to connect to SSID (attempt "));
         Serial.print( timesWeTriedToConnect );
         Serial.print(F(" of 5): "));
         Serial.println(ssid);
         status = WiFi.begin(ssid, pass); // Connect to WPA/WPA2 network. 
         delay(2000);
         if ( timesWeTriedToConnect >= 5 ) break;
       } 
    }    
    if ( status != WL_CONNECTED ) {
       Serial.print("Unable to connect to ssid '");
       Serial.print( ssid );
       Serial.println( "'");
       Serial.println("** Scanning for open networks **");
       byte numSsid = WiFi.scanNetworks();
       Serial.print("number of available networks:");
       Serial.println(numSsid);
       for (int thisNet = 0; thisNet<numSsid; thisNet++) {
          Serial.print(thisNet);
          Serial.print(") ");
          Serial.print(WiFi.SSID(thisNet));
          Serial.print("\tSignal: ");
          Serial.print(WiFi.RSSI(thisNet));
          Serial.print(" dBm");
          Serial.print("\tEncryption: ");
          Serial.println(WiFi.encryptionType(thisNet));
          if ( WiFi.encryptionType(thisNet) == 7 ) {
             Serial.println( "Attempting to connect to open network...");
             status = WiFi.begin( WiFi.SSID(thisNet));
             delay(10000);
             if( status == WL_CONNECTED ) break;
          }
      }
    }
    if ( status != WL_CONNECTED ) {
      Serial.println( "Unable to connect to network" );
      // don't continue:
      while(true);
    }

/*Reading and Writing to the EEPROM

Sometimes it can be useful to store numbers, or other data, into the Arduino’s EEPROM to
protect it against power-cycling. Using the included EEPROM library it’s actually pretty
easy to write a number to EEPROM,
*/
void setNumber(unsigned long ctr) {

   Serial.print("Setting number in EEPROM to = ");
   Serial.println( ctr );
   EEPROM.write(4,(ctr & 0xFFFFFFFF) >> 24); // write the MSB
   EEPROM.write(3,(ctr & 0xFFFFFF) >> 16); // write the 3rdB
   EEPROM.write(2,(ctr & 0xFFFF) >> 8); // write the 2ndB
   EEPROM.write(1,ctr & 0xFF); // write the LSB
}

//and then to read the number back,

unsigned long getNumber() {
   unsigned long ctr;

   //initial setting of number
   if (EEPROM.read(5) != 1) { 

      // if number set status is false
      Serial.println("Initializing number in EEPROM");
      EEPROM.write(1,0); // write LSB zero
      EEPROM.write(2,0); // write 2ndB zero
      EEPROM.write(3,0); // write 3rdB zero
      EEPROM.write(4,0); // write MSB zero
      EEPROM.write(5,1); // counter set status is true
   }

   //get the number - add Bytes for 32-bit number
   ctr = (EEPROM.read(4) << 24) + (EEPROM.read(3) << 16) + (EEPROM.read(2) << 8) + (EEPROM.read(1));
   Serial.print("Getting number from EEPROM = ");
   Serial.println( ctr );
   return ctr;
}

/*Code for this post was provided by Rob Faludi and Alasdair Allan. It is reposted here on the MAKE
site with permission. This post was original published on May 13 2013.*/