Getting Started with Arduino Programming

Hello friends! Today we will get started with Arduino programming by learning how a sketch is organized and how it interacts with the board's pins. We will begin with comments and the setup and loop functions, then move through digital input, digital output, analog measurement and pulse-width modulation.

If you have not installed the software or uploaded your first sketch, begin with Getting Started with Arduino Software. Here we will concentrate on the meaning of the code rather than the installation process. The examples use the classic Arduino Uno R3 with an ATmega328P, so its pin capabilities and resolutions provide our reference.

We will finish with a small project that reads a potentiometer and controls an LED while a button is pressed. This gives each new concept a practical purpose. The original IDE screenshots are retained as historical illustrations; their appearance may differ from your installed IDE, while the basic programming structure remains recognizable.

What Is an Arduino Sketch?

An Arduino sketch is a program written using C++ together with the functions and libraries supplied by the selected board's core. The IDE prepares the source, compiles it and links the required code into a program for that board. Uploading then transfers the resulting program through the board's supported programming method.

The compiler does not repeatedly read your loop function while the board runs. Compilation happens on the development computer. The microcontroller later executes machine instructions produced by that compilation. Keeping these stages separate helps explain why a compilation error, an upload error and incorrect runtime behavior require different troubleshooting.

Verify checks whether a program can be built for the selected target. It cannot establish that an external circuit is wired correctly or that a calculation represents the physical quantity you intended. A sketch can compile successfully and still read the wrong pin or use the wrong units.

Comments Make the Program Easier to Understand

A single-line comment begins with two forward slashes. A block comment starts with slash-star and ends with star-slash. Comments document the source without becoming normal executable statements. Syntax highlighting colors depend on the editor theme and are not part of the language.

// The button connects pin 2 to ground when pressed.
constexpr byte BUTTON_PIN = 2;

/*
  This example uses the internal pull-up resistor.
  Therefore a pressed button reads LOW.
*/

Use comments to explain assumptions, units and decisions. “Wait for the switch to remain stable for 25 ms” is more useful than “check an if statement.” A good comment helps somebody understand why the code exists, especially when the behavior is not obvious from a variable name.

Do not nest ordinary block comments inside one another. Also check whether a missing closing comment marker has accidentally hidden part of your sketch. When the compiler reports a confusing error far below your edit, an unfinished comment or string near the top can be the cause.

Understand setup and loop

A minimal Arduino program contains two functions:

void setup() {
  // Initialization after startup or reset.
}

void loop() {
  // Work that is repeated while the program runs.
}

setup runs once during each startup sequence. It is a suitable place to configure pins, initialize communication and establish the application's initial state. It runs again after a reset; “once” does not mean once for the entire lifetime of the board.

After setup returns, the Arduino runtime repeatedly calls loop. Within a normal function call, statements execute in their specified control-flow order. A delay, a long calculation or a blocking library call can postpone the next pass through loop. Repetition does not automatically make the program responsive.

The word void means that the function does not return a value. Parentheses hold its parameters; empty parentheses mean that these functions take none. Braces group their statements. Most simple statements end with a semicolon, but a function definition does not need an extra semicolon after its closing brace.

Variables, Constants and Scope

A variable stores a value that may change. A constant expresses a value that should remain fixed, such as a pin assignment. For example, constexpr byte LED_PIN = 9 gives the output a descriptive name and prevents accidental reassignment in the sketch.

A local variable declared inside a function normally belongs to that function's scope. A variable declared outside the functions can retain application state between calls. Choose the narrowest scope that makes the program understandable; not every temporary calculation needs to be global.

Names cannot contain spaces, so use sensorValue rather than sensor Value. C++ is case-sensitive: sensorValue and SensorValue are different identifiers. Use bool for a true-or-false condition and an appropriate numeric type for a measurement. You can choose a variable name, but you cannot invent a type name without defining it.

On the Uno's AVR core, an int is typically a signed 16-bit value. That makes it suitable for an analog reading from zero to 1023, but unsuitable for a long-running millisecond timestamp. Use unsigned long for the millis-based timing shown later. Code moved to another board should not assume that every type has the same width.

Configure Digital Pins with pinMode

A general-purpose pin can often be configured as input or output, subject to the chip and board's actual capabilities. This flexibility also exists in many AVR, PIC and other microcontrollers; it is not unique to Arduino. Supply, ground, reset and specialized pins should not be treated as unrestricted GPIO.

An unconnected high-impedance input can change unpredictably because no circuit defines its voltage. The problem is a floating electrical node, not the Arduino deliberately sending random data to it. A pull-up or pull-down provides a defined idle condition where the circuit requires one.

For our button, configure pin 2 as INPUT_PULLUP and connect the switch between pin 2 and ground. Released reads HIGH; pressed reads LOW. Arduino's InputPullupSerial example uses this arrangement. Check the internal connections of a four-leg tactile switch so that the two wires reach opposite switched contacts.

Read and Write Digital Signals

digitalRead returns the input's interpreted logic state. It does not configure the pin mode. digitalWrite sets an output HIGH or LOW when the pin is configured as an output. The actual output voltage and allowable current depend on the board and loading; HIGH does not mean exactly 5.000 V under every condition.

constexpr byte BUTTON_PIN = 2;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  bool pressed = digitalRead(BUTTON_PIN) == LOW;
  digitalWrite(LED_BUILTIN, pressed ? HIGH : LOW);
}

This complete introductory sketch makes the built-in LED follow the button. The conditional operator selects HIGH when pressed is true and LOW otherwise. You can write the same decision using if and else if that is easier to read. Start with this small circuit before combining several functions.

A mechanical button can bounce between states during a transition. A simple indicator may tolerate that, but a press counter can register several presses from one action. Debouncing accepts a new state only after it remains stable for a chosen interval; the final example implements that explicitly.

Protect an External LED with a Resistor

For an external red LED, connect output pin 9 through a 680-ohm resistor to the LED anode, with the cathode connected to ground. The resistor can also be placed on the cathode side as long as it remains in series. Confirm polarity from the part's documentation rather than relying only on lead length.

Using an approximate 5 V output and 2 V LED forward drop, the current is I = (5 − 2) / 680 = 0.0044 A, or about 4.4 mA. This is an estimate because both output voltage and forward voltage vary. It is a modest indicator current, not a reason to operate the pin at its absolute maximum rating.

Never connect a motor, solenoid or relay coil directly to a GPIO pin. Those loads require appropriate drivers and protection. The output in this beginner project is intentionally a small LED so that programming can be learned without introducing a separate power stage.

Measure Analog Voltage with analogRead

The Uno R3 has an analog-to-digital converter that normally returns a 10-bit result from zero to 1023. Connect the two outer terminals of a 10-kilohm potentiometer to 5 V and ground, and connect the wiper to A0. Turning the knob changes the voltage at A0.

int sensorValue = analogRead(A0);

Use the A0 name to make the intended analog channel clear. Analog channel numbers and digital pin numbers are not interchangeable descriptions. A single read returns one measurement; storing it does not cause the variable to update automatically whenever the voltage changes. Call analogRead again when you want another sample.

For an ideal 10-bit converter, one code interval is approximately VREF / 1024. With a 5.00 V reference, that interval is about 4.88 mV. A reading of 512 corresponds approximately to 512 × 5 / 1024 = 2.50 V. Reference accuracy, noise and converter error limit the precision of the actual result.

Mapping endpoints with 1023 is useful for some user-interface scaling, but it is not the same as deriving the ADC's ideal code width. Be explicit about which calculation you are making. Also keep the input within the permitted electrical range; a negative voltage or an excessive voltage is not made safe by calling analogRead.

Use PWM for LED Brightness

On the Uno R3, analogWrite on a PWM-capable pin controls the fraction of time that a digital output is HIGH. It does not produce a continuously adjustable DC voltage directly. The standard PWM pins are 3, 5, 6, 9, 10 and 11, and the usual duty command ranges from zero to 255.

A command of zero means off, while 255 means continuously on for this output use. A value near 128 gives approximately half duty. The LED switches rapidly; the observed brightness responds to the time-averaged light, although perceived brightness is not perfectly linear with the numeric command.

Approximate duty cycle = PWM command / 255.

Calling analogWrite(3, HIGH) supplies the numeric value one, because HIGH is a logic constant. It therefore requests a very small duty cycle on a normal PWM pin, not full brightness. Use digitalWrite for a simple on/off output or a duty value such as 128 for PWM. Arduino's analog input and output example demonstrates the distinction.

Some other Arduino boards provide true digital-to-analog converters on particular pins. That does not change the Uno R3's hardware. Check the selected board's documentation before transferring a design that depends on a particular voltage, pin or resolution.

Complete Project: Button-Controlled LED Dimmer

Now combine the button on pin 2, the potentiometer on A0 and the external LED with its series resistor on pin 9. While the button is pressed, the potentiometer sets the LED's PWM command. Releasing the button turns the LED off. Serial output reports measurements at intervals without deliberately blocking the main loop.

constexpr byte BUTTON_PIN = 2;
constexpr byte LED_PIN = 9;
constexpr byte POT_PIN = A0;
constexpr unsigned long DEBOUNCE_MS = 25;
constexpr unsigned long REPORT_MS = 250;

bool lastRawPressed = false;
bool stablePressed = false;
unsigned long changedAt = 0;
unsigned long reportedAt = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  analogWrite(LED_PIN, 0);
  Serial.begin(9600);
}

void loop() {
  const unsigned long now = millis();
  const bool rawPressed = digitalRead(BUTTON_PIN) == LOW;
  if (rawPressed != lastRawPressed) {
    lastRawPressed = rawPressed;
    changedAt = now;
  }
  if (now - changedAt >= DEBOUNCE_MS) {
    stablePressed = rawPressed;
  }

  const int adc = analogRead(POT_PIN);
  const byte requestedDuty = adc / 4;
  const byte appliedDuty = stablePressed ? requestedDuty : 0;
  analogWrite(LED_PIN, appliedDuty);

  if (now - reportedAt >= REPORT_MS) {
    reportedAt = now;
    Serial.print(F("ADC="));
    Serial.print(adc);
    Serial.print(F(" pressed="));
    Serial.print(stablePressed);
    Serial.print(F(" PWM="));
    Serial.println(appliedDuty);
  }
}

Integer division by four maps the 1024 ADC codes into 256 PWM commands. Readings from zero through three produce zero, and readings from 1020 through 1023 produce 255. This deliberate loss of resolution matches the output command width and is easier to inspect than an unexplained scaling expression.

The debounce timer restarts whenever the raw switch state changes. Once that state remains unchanged for 25 ms, it becomes the accepted state. This value is an example to test with your switch. Arduino's debounce tutorial discusses why a mechanical switch needs this treatment.

The reporting interval uses unsigned subtraction rather than waiting inside delay. The program therefore continues reading the button between reports. Serial printing can still occupy processor time and eventually block if output is produced faster than it can be transmitted, so avoid adding unlimited messages inside loop.

Upload, Test and Investigate

1. Disconnect power and check the potentiometer, button and LED wiring.
2. Select the Uno R3 and the correct port, then compile and upload the complete sketch.
3. Open Serial Monitor at 9600 baud.
4. With the button released, verify that the applied PWM is zero while the ADC reading changes with the knob.
5. Hold the button and turn the knob slowly. Check that the PWM value spans approximately zero to 255.
6. Release the button and check that the LED turns off after the short debounce interval.
7. If the result differs, compare the printed input state, ADC value and applied duty before changing several things at once.

These are checks for your own build, not a claim that this revised example has been executed on a physical board here. Compile first, inspect the wiring second, and compare observed behavior with each stated rule. A measurement near an endpoint may vary slightly because real circuits are not perfectly noiseless.

Common Errors and Their Meaning

Review and Next Steps

Be careful with assignment and comparison when you begin writing your own decisions. A single equals sign assigns a value, whereas a double equals sign compares two values. An accidental assignment inside an if condition may compile and still produce the wrong behavior. Give conditions descriptive names, such as stablePressed, so that their purpose remains visible during review.

Also remember that libraries can share hardware resources. PWM generation uses timers, and another library may reconfigure a timer for a different task. If an output changes unexpectedly after adding a library, check its timer and pin requirements before assuming that the LED or potentiometer has failed.

You now have a complete path from a physical input to a program decision and a controlled output. setup establishes the hardware configuration, loop updates the state, digitalRead handles a logical condition, analogRead measures voltage and analogWrite controls PWM duty on a supported pin.

For the next experiment, change the application deliberately: make the button toggle an enable state instead of requiring a continuous press. That requires detecting a transition of the debounced state rather than toggling on every pass through loop. Write down the expected state changes before editing the sketch.

If you plan to move the compiled program into a simulator, continue with How to Get a HEX File from Arduino. For the broader difference between a microcontroller board and a small computer, see Arduino versus Raspberry Pi.

Frequently Asked Questions

Is setup an infinite loop?

No. It runs once per startup sequence and normally returns. The runtime repeatedly calls loop afterward.

Does analogRead continuously update a variable?

No. Each call obtains a reading. The variable retains its last assigned value until your program assigns another value.

Can every pin generate PWM?

No. Use pins supported by the selected board and core. The Uno R3's usual PWM pins are 3, 5, 6, 9, 10 and 11.

Why is the button active LOW?

The internal pull-up holds the released input HIGH. Pressing the button connects the input to ground, so the program interprets LOW as pressed.

Does a successful build prove the circuit works?

No. Compilation checks the program's build requirements. Correct connections, electrical limits and intended behavior still need to be checked on the actual circuit or in an appropriate model.