const int ledPin = 13;      // built-in LED

void setup() {
  pinMode(ledPin, OUTPUT);  // runs once
}

void loop() {               // repeats forever
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

const int ledPin = 8;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(500);
  digitalWrite(ledPin, LOW);
  delay(500);
}

void setup() {
  // Runs ONCE at the start
  // Set window size, initialize serial port
}

void draw() {
  // Runs CONTINUOUSLY — like loop() in Arduino
  // Draw shapes, text, update the display
}

import processing.serial.*;   // 1. Import the library

Serial myPort;                // 2. Declare the serial port object

void setup() {
  size(400, 300);
  printArray(Serial.list());  // 3. List available ports
  // 4. Open the port — index [0] is usually the first available
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');   // 5. Call serialEvent() once per full line
}

// Sensor value 0–1023 mapped to bar width 0–300 pixels:
float barWidth = map(sensorValue, 0, 1023, 0, 300);
rect(50, 100, barWidth, 30);

// Temperature 0–50 °C mapped to the red colour component:
float r = map(temperature, 0, 50, 0, 255);
fill(r, 0, 0);

MyProject/              ← sketch folder
├── MyProject.pde       ← main file (same name as folder)
└── data/               ← images, fonts, sounds

float t = 0;

void setup() {
  size(500, 300);
  textAlign(CENTER, CENTER);
}

void draw() {
  background(30);                 // dark grey background
  t++;

  // Animated colour using sine waves
  float r = 127 + 127 * sin(t * 0.05);
  float g = 127 + 127 * sin(t * 0.03);

  // Rounded rectangle (last argument = corner radius)
  fill(r, g, 100);
  rect(50, 80, 400, 60, 10);

  // White text centred in the rectangle
  fill(255);
  textSize(22);
  text("Processing + Arduino = Power!", 250, 110);

  // Animated circle
  fill(r, 50, 200);
  ellipse(250, 220, 60, 60);
}

int counter = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(counter);   // send number to Processing
  counter++;
  if (counter > 100) counter = 0;
  delay(500);
}

import processing.serial.*;

Serial myPort;
int receivedValue = 0;

void setup() {
  size(400, 250);
  printArray(Serial.list());              // check available ports
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(240);

  fill(50);
  textSize(20);
  text("Received from Arduino: " + receivedValue, 50, 80);

  fill(100, 150, 255);
  float barW = map(receivedValue, 0, 100, 0, 300);
  rect(50, 120, barW, 40);

  fill(0);
  textSize(16);
  text(receivedValue + " / 100", 50 + barW/2, 145);
}

void serialEvent(Serial p) {
  String incoming = p.readStringUntil('\n');
  if (incoming != null) {
    incoming = trim(incoming);
    if (incoming.matches("\\d+")) {       // only digits? then it is safe
      receivedValue = int(incoming);
    }
  }
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  float temperature = 23.5;   // in the real project: a sensor reading
  float humidity    = 61.0;

  Serial.print(temperature);
  Serial.print(",");          // comma separator
  Serial.println(humidity);   // newline at the end
  delay(1000);
}

import processing.serial.*;

Serial myPort;
float temperature = 0;
float humidity = 0;

void setup() {
  size(500, 300);
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  fill(0);
  textSize(22);
  text("Temperature: " + nf(temperature, 1, 1) + " \u00B0C", 50, 100);
  text("Humidity:    " + nf(humidity, 1, 1) + " %", 50, 150);

  fill(220, 50, 50);                                   // temperature bar
  rect(50, 170, map(temperature, 0, 50, 0, 380), 25);

  fill(50, 100, 220);                                  // humidity bar
  rect(50, 210, map(humidity, 0, 100, 0, 380), 25);
}

void serialEvent(Serial p) {
  String data = p.readStringUntil('\n');
  if (data != null && data.contains(",")) {
    String[] values = split(trim(data), ",");
    if (values.length == 2) {
      temperature = float(values[0]);
      humidity    = float(values[1]);
    }
  }
}

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);              // built-in LED
}

void loop() {
  if (Serial.available() > 0) {
    char cmd = Serial.read();
    if (cmd == '1')      digitalWrite(13, HIGH);  // LED ON
    else if (cmd == '0') digitalWrite(13, LOW);   // LED OFF
  }
}

import processing.serial.*;

Serial myPort;
boolean ledOn = false;

void setup() {
  size(400, 220);
  myPort = new Serial(this, Serial.list()[0], 9600);
  textAlign(CENTER, CENTER);
}

void draw() {
  background(240);
  fill(30);
  textSize(18);
  text("Arduino LED Control", 200, 30);
  text("Click buttons or press 1 / 0 on keyboard", 200, 60);

  fill(ledOn ? color(0, 200, 0) : color(180));     // ON button
  rect(60, 100, 120, 50, 8);
  fill(255);
  text("ON", 120, 125);

  fill(!ledOn ? color(200, 50, 50) : color(180));  // OFF button
  rect(220, 100, 120, 50, 8);
  fill(255);
  text("OFF", 280, 125);

  fill(30);
  textSize(16);
  text("Status: LED is " + (ledOn ? "ON" : "OFF"), 200, 190);
}

void setLed(boolean on) {
  myPort.write(on ? '1' : '0');
  ledOn = on;
}

void mousePressed() {
  if (mouseX > 60  && mouseX < 180 && mouseY > 100 && mouseY < 150) setLed(true);
  if (mouseX > 220 && mouseX < 340 && mouseY > 100 && mouseY < 150) setLed(false);
}

void keyPressed() {
  if (key == '1') setLed(true);
  if (key == '0') setLed(false);
}

Serial.println("24.5,60");   // temperature = 24.5 °C, humidity = 60 %

#include "DHT.h"

#define DHTPIN 2
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();   // Celsius

  if (isnan(humidity) || isnan(temperature)) {
    Serial.println("Failed to read from DHT sensor!");
    delay(2000);
    return;
  }

  Serial.print(temperature);
  Serial.print(",");
  Serial.println(humidity);
  delay(2000);                                 // DHT11: max. 1 reading per second
}

import processing.serial.*;

Serial myPort;
float temp = 0, hum = 0;

void setup() {
  size(500, 260);
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  fill(0);
  textSize(20);
  text("Temperature: " + nf(temp, 1, 1) + " \u00B0C", 50, 70);
  text("Humidity: " + nf(hum, 1, 1) + " %", 50, 150);

  fill(220, 50, 50);                                  // temperature bar 0–50 °C
  rect(50, 85, map(temp, 0, 50, 0, 400), 25);
  fill(50, 100, 220);                                 // humidity bar 0–100 %
  rect(50, 165, map(hum, 0, 100, 0, 400), 25);

  if (temp > 30) {                                    // alert system
    fill(255, 0, 0);
    text("WARNING: HIGH TEMPERATURE!", 50, 235);
  }
}

void serialEvent(Serial p) {
  String data = p.readStringUntil('\n');
  if (data != null && data.contains(",")) {
    String[] values = split(trim(data), ",");
    if (values.length == 2) {
      temp = float(values[0]);
      hum  = float(values[1]);
    }
  }
}

const int sensorPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int lightValue = analogRead(sensorPin);   // 0 (dark) … 1023 (bright)
  Serial.println(lightValue);
  delay(200);
}

import processing.serial.*;

Serial myPort;
int lightLevel = 0;

void setup() {
  size(400, 200);
  myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw() {
  background(255);
  fill(0);
  textSize(20);
  text("Light Intensity: " + lightLevel, 50, 100);

  if (myPort.available() > 0) {
    String val = myPort.readStringUntil('\n');
    if (val != null) lightLevel = int(trim(val));
  }
}

import processing.serial.*;

Serial myPort;
int lightLevel = 0;

void setup() {
  size(400, 200);
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  fill(0);
  textSize(20);
  text("Light Intensity: " + lightLevel, 50, 50);

  fill(0, 100, 255);
  rect(50, 100, map(lightLevel, 0, 1023, 0, 300), 30);
}

void serialEvent(Serial p) {
  String val = p.readStringUntil('\n');
  if (val != null) {
    val = trim(val);
    if (val.matches("\\d+")) lightLevel = int(val);
  }
}

#define trigPin 3
#define echoPin 2

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);          // 10 µs trigger pulse
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long duration = pulseIn(echoPin, HIGH, 30000);  // timeout 30 ms ≈ 5 m
  float distance = duration * 0.0343 / 2;         // cm
  Serial.println(distance);
  delay(200);
}

import processing.serial.*;

Serial myPort;
float distance;

void setup() {
  size(600, 200);
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  fill(0);
  textSize(24);
  text("Distance: " + nf(distance, 0, 2) + " cm", 50, 50);

  fill(100, 200, 255);                                    // horizontal bar
  rect(50, 100, map(constrain(distance, 0, 200), 0, 200, 0, width - 100), 30);
}

void serialEvent(Serial p) {
  String data = p.readStringUntil('\n');
  if (data != null) distance = float(trim(data));
}

#include <Servo.h>

Servo servo;
bool sweeping = false;
int angle = 0;
int step = 1;

void setup() {
  Serial.begin(9600);
  servo.attach(9);
}

void loop() {
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    sweeping = (command == "1");      // "1" = START, anything else = STOP
  }

  if (sweeping) {                     // one small step per loop()
    angle += step;
    if (angle >= 180 || angle <= 0) step = -step;
    servo.write(angle);
    delay(10);
  }
}

import processing.serial.*;

Serial myPort;
boolean isSweeping = false;

void setup() {
  size(400, 200);
  myPort = new Serial(this, Serial.list()[0], 9600);
  textAlign(CENTER, CENTER);
}

void draw() {
  background(240);
  textSize(16);
  fill(0);
  text("Servo Control", width/2, 30);
  drawButton("START", 100, 100, isSweeping);
  drawButton("STOP", 250, 100, !isSweeping);
}

void drawButton(String label, int x, int y, boolean active) {
  fill(active ? color(0, 200, 0) : color(180));
  rect(x, y, 100, 40, 7);
  fill(0);
  text(label, x + 50, y + 20);
}

void mousePressed() {
  if (mouseX > 100 && mouseX < 200 && mouseY > 100 && mouseY < 140) {
    myPort.write("1\n");
    isSweeping = true;
  } else if (mouseX > 250 && mouseX < 350 && mouseY > 100 && mouseY < 140) {
    myPort.write("0\n");
    isSweeping = false;
  }
}

#include <Servo.h>

const int TRIG_PIN = 6;
const int ECHO_PIN = 7;
const int SERVO_PIN = 9;
const int DISTANCE_THRESHOLD = 50;   // centimetres

Servo servo;
float duration_us, distance_cm;

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  servo.attach(SERVO_PIN);
  servo.write(0);
}

void loop() {
  digitalWrite(TRIG_PIN, HIGH);      // 10 µs pulse
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  duration_us = pulseIn(ECHO_PIN, HIGH);
  distance_cm = 0.017 * duration_us; // = 0.0343 / 2

  if (distance_cm < DISTANCE_THRESHOLD) servo.write(90);
  else                                  servo.write(0);

  Serial.print("distance: ");
  Serial.print(distance_cm);
  Serial.println(" cm");
  delay(500);
}

#include <Servo.h>

Servo myServo;
#define trigPin 9
#define echoPin 10

float measure() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  long duration = pulseIn(echoPin, HIGH, 30000);
  return duration * 0.0343 / 2;
}

void setup() {
  Serial.begin(9600);
  myServo.attach(6);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  for (int angle = 0; angle <= 180; angle += 2) {
    myServo.write(angle);
    delay(50);
    Serial.print(angle);
    Serial.print(",");
    Serial.println(measure());
  }
  for (int angle = 180; angle >= 0; angle -= 2) {   // sweep back too
    myServo.write(angle);
    delay(50);
    Serial.print(angle);
    Serial.print(",");
    Serial.println(measure());
  }
}

import processing.serial.*;

Serial myPort;
int angle;
float distance;

void setup() {
  size(600, 600);
  myPort = new Serial(this, Serial.list()[0], 9600);
  background(0);
}

void draw() {
  if (myPort.available() > 0) {
    String data = myPort.readStringUntil('\n');
    if (data != null && data.contains(",")) {
      String[] parts = split(trim(data), ",");
      if (parts.length == 2) {
        angle = int(parts[0]);
        distance = float(parts[1]);
        float r = map(distance, 0, 100, 0, 250);
        float x = width/2 + r * cos(radians(angle));
        float y = height  - r * sin(radians(angle));
        stroke(0, 255, 0);
        fill(0, 255, 0);
        ellipse(x, y, 5, 5);
      }
    }
  }
}

const int analogPin = A0;
const float Vin = 5.0;
const float R_known = 1000.0;     // known resistor in ohms

void setup() {
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(analogPin);
  if (raw == 0) {
    Serial.println(-1);           // nothing connected (open circuit)
  } else {
    float Vout = raw * Vin / 1023.0;
    float Rx = R_known * (Vin / Vout - 1);
    Serial.println(Rx);           // send resistance to Processing
  }
  delay(500);
}

import processing.serial.*;

Serial myPort;
float resistance = 0;

void setup() {
  size(400, 200);
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  fill(0);
  textSize(20);
  text("Measured Resistance:", 50, 80);
  if (resistance < 0) text("no resistor", 50, 120);
  else                text(nf(resistance, 1, 2) + " \u03A9", 50, 120);
}

void serialEvent(Serial p) {
  String val = p.readStringUntil('\n');
  if (val != null) resistance = float(trim(val));
}