Note

If you have done CS F111, you can cruise through this level as it covers the basics of C/C++ programming. Even if you don't have knowledge of CS F111, you will be able to do this level as it is beginner-friendly.

Variables and DataTypes in C++

The Arduino microcontroller uses variables identical to C++ on most parts. Hence, we have the familiar C++ data types like int, float, double, char, bool, etc. However, beyond the C++ data types, we have the string datatype, which is used to store a sequence of characters.

// TODO: Variable Naming Conventions

Example:

int32_t myverylongvariable; // Bad Naming, Extremely Unreadable
int32_t my_very_long_variable; // Good, but unconvetional
int32_t MyVeryLongVariable; // Good, but unconventional. Pascal case is used with Classes

int32_t myVeryLongVariable; // Good

Most of these datatypes have sizes that depend on the compiler architecture being used (x32 or x64), and is often unreliable. To counteract this problem, we have integer datatypes that specify the size (in bytes) explicitly. For Example, int8_t has a fixed size of 8 bits, int32_t has a size of 32 bits or 4 bytes. Similarly, there are unsigned variations of the same types availabel as well. For example, uint8_t, uint64_t. We strongly recommend that you use these fixed-size integer datatypes whenever possible.

Size and Range of Some Standard Data Types:

Examples:

int a = 5;
int32_t b = 7; // Equicvalent to int in x64 compilers

unsigned int mask = 1234;
uint8_t mask = 0x11; // 8 bit unsigned integers most frequently used as bit masks

float f = 2.5f; // the f at the end of 2.5 signifies explicitly that this is a float
double d = 3.5; // floating point numbers are double precision by default

Bonus: Implicit and Explicit Type Casting

Please refer to this source for information on this topic

Operators

Operators may be unary (single operand) or binary (two operands). We look at the following types of operators:

1. Arithmetic Operators:

% is used with integer datatypes (eg: uint8_t, int32_t, etc) only.

2. Assignment Operations:

3. Relational operators:

int a = 7

4. Logical operators:

bool a = true

bool b = false

5. Bitwise operators:

uint8_t a = 0b0000_1011 = 0x0B

uint8_t b = 0b0000_0010 = 0x02

We will look at Bitwise operations in more detail further.

Conditionals

We now look at how to control the flow of execution of the program. Typically, every statement is executed line by line. However, there are times when we want to execute a statement only when a condition is true. This is where conditionals come in.

We have the following structure of Programs:

if (condition1) {
    // do something when condition1 is true
} else if (condition2) {
    // do something when condition2 is true
} else {
    // do something when neither condition is true
}

The ternary Operator

Ternary operator provides a simple way to execute a statement when a condition is true or false.

variable = condition ? value when condition is true : value when condition is false;

This is equivalent to:

if (condition) {
    variable = value when condition is true;
} else {
    variable = value when condition is false;
}

Example:

int32_t a = 5, b = 7;
int32_t maxAB = (a > b) ? a : b; // maxAB = 7

Loops

Loops are commands that execute a set of statements multiple times. There are two types of loops: while and for.

while loop

These loops execute a set of statements as long as a condition is true. The condition is checked at the beginning of each loop iteration. The loop is exited when the condition becomes false.

Syntax:

while (condition) {
    // Loop body
}

Example:

int32_t i = 0;
while (i < 10) {
    i++;
}

// Value of i after loop exits: 10 (Why not 9?)

for loop

These loops execute a set of statements once for each element in a collection. The collection is specified by the loop variable. This collection is defined by the loop variable.

Syntax:

for (variable = initial value; condition; increment variable) {
    // Loop Body
}

Example:

int32_t i;
for (i = 0; i < 10; i++) {
    // do something
}

The unspoken Brother

The third kind of Loops are the do while loops. These loops execute a set of statements as long as a condition is true. The condition is checked at the end of each loop iteration. The loop is exited when the condition becomes false.

Point out a case where do while loop is preferred over while loop.

Syntax:

do {
    // Loop Body
} while (condition);

Functions

A function is a named sequence of statements that perform a specific task. It is a block of code that performs a specific task.

Suppose we need to create a program to create a circle and color it. We can create two functions to solve this problem:

1. A function to draw the circle
2. A function to color the circle

Dividing a complex problem into smaller chunks makes our program easy to understand and reusable.

There are two types of function:

1. User-defined functions: Created by users
2. Built-in functions: Predefined in C++, or the compiler

User Defined Functions:

Naming A Function: In C++, the conventional practive is to use Camel Case for naming functions. This is similar to how variables are named.

Example:

int32_t myverylongfunction(); // Bad Naming, Extremely Unreadable
int32_t my_very_long_function(); // Good, but unconvetional
int32_t MyVeryLongFunction(); // Good, but unconventional. Pascal case is used with Classes

int32_t myVeryLongFunction(); // Good

Every function has a protype (or its signature/declaration) and a definition. The protype contains the return type of the function, the function name, and its parameters. The function definition contains the statements that the function performs.

Syntax:

returnType functionName (parameter1, parameter2, ...); // Function Protype

returnType functionName (parameter1, parameter2, ...) { // Function Definition
    // Function Body
}

The protype may exists independantly of the definition, but the definition always includes the protype.

Example:

bool isOdd(int32_t n) {
    /*
    Check if the number passed is odd
    Args:
        int32_t n: The number to check
    Returns:
        bool: True if the number is odd, false otherwise
    */
    return (n & 1);
}

Now that you've finished this section, you have all the programming knowledge required to get started.

C for Arduino Microcontrollers

Programming the Arduino Microcontrollers

Note: This doc assumes some basic familiarity with programming concepts as covered in CS F111: Computer Programming at BITS. Although some pre-requisite knowledge of programming structures is recommended, it is not requried.

Control Structure of a simple Arduino Program

Almost any arduino program consists of two important functions: setup() and loop(). These two functions are the building blocks of any arduino program. Most programs that you need to run on a microcontroller device have two major components:

1. Setting up the hardware and the program variables
2. Recurring tasks like collecting data or sending some data

These tasks are handled by the following two functions:

The setup() function

This function is called when your Arduino Board starts up. It is used to initalize any variables that you have to use in your program. It can also be used to set up any hardware that you need to use. The crucial part to remember is that this function is called exactly once. Anything, and everyhting that you don't need to run more than once, should be within this function.

The loop() function

This function is called repeatedly. It is the main function of your program. It is where you should put all the code that you want to run repeatedly. The loop function is called repeatedly until the program is stopped. (How is a program stopped?)

Sample Code Structure:

// Define Global Variables

void setup() {
    // Set up your microcontroller here
    // Initialize Variables
}

void loop() {
    // Collect some data
    // Send some data back
}

Once we understand the strucutre of a program, we can start writing the code. Let us look at the building blocks.