Theory: https://www.arduino.cc/en/Tutorial/DigitalPins.

/*
Example #1.1
*/
 
/* Constants */
// Set button pin
const int button = A0; 
 
// Set LED pin
const int led = 13; 
 
/* Global variables */
// Holds the current state of button
int buttonState = 0; 
 
void setup() 
{ 
  // Set LED pin to output
  pinMode(led, OUTPUT); 
  // Set button pin to input with internal pull-up activated
  pinMode(button, INPUT_PULLUP); 
}
 
void loop()
{
  // Get the curren state of button pin
  buttonState = digitalRead(button); 
  // If button is pressed then turn on LED
  if (buttonState == LOW) 
  { 
    digitalWrite(led, HIGH);
  } 
  // All other cases turn LED off
  else 
  { 
   digitalWrite(led, LOW);
  }
}

/*
Example #1.2
*/
 
// Setup is same with example #1.1
const int button = A0; 
const int led = 13; 
 
int buttonState = 0; 
 
void setup() 
{ 
  pinMode(led, OUTPUT); 
  pinMode(button, INPUT_PULLUP); 
}
 
void loop()
{
  //  Get the curren state of button pin
  buttonState = digitalRead(button); 
 
  // When button is pressed then set LED on and halt program for 1 second
  if (buttonState == LOW) 
  { 
    digitalWrite(led, HIGH);
    delay(1000); // 1000 millisekundit ehk 1 sekund
  }
  // Turn LED off
  digitalWrite(led, LOW);
}

/*
Example #1.3
*/
 
// Setup is same with example #1.1
const int button = A0; 
const int led = 13; 
 
int buttonState = 0; 
 
void setup() 
{ 
  pinMode(led, OUTPUT); 
  pinMode(button, INPUT_PULLUP); 
}
 
void loop() 
{
  // When button is pressed and hold the program stays inside while(1) loop
  if (digitalRead(button) == LOW) 
    {
   // Debounce effect eliminator delay
    delay(50); 
    while (digitalRead(button) == LOW)
     { 
     }
	// Invert LED current state
    digitalWrite(led, !digitalRead(led)); 
 
   // Debounce effect eliminator delay
    delay(50); 
    }
}

Modify example so that on button press LED blinks 3 times.

Modify example so that on button press LED starts to blink with constant interval. Second press ends the blinking.

/*
Example #2.1
*/
 
// Set potentiometer pin
const int pot = A1; 
 
// Set LED pin
const int led = 13; 
 
// Holds potentiometer digital value
int potState = 0; 
 
void setup()
{
  // Set LED pin to output
  pinMode(led, OUTPUT);
}
 
void loop() 
{
  // Get digital value of potentiometer
  poteOlek = digitalRead(pot);
 
  // When potentiometer digital value is logical "true" then turn on LED
  if(potState > 0)
  {
    digitalWrite(led, HIGH);
  }
  // All other cases set LED off
  else
  {
    digitalWrite(led, LOW);
  }
}

/* 
Example #2.2
*/
 
// Setup is same with example #2.1
const int pot = A1; 
const int led = 13; 
 
int potState = 0; 
 
void setup()
{
  pinMode(led, OUTPUT);
}
 
void loop() 
{
  // Get analog value of potentiometer
  poteOlek = analogRead(pot); 
 
  // Turn LED on
  digitalWrite(led, HIGH); 
 
  // Halt the program for potentiometer analog value number of milliseconds
  delay(potState);  
 
  // Turn LED off
  digitalWrite(led, LOW); 
 
  // Halt the program for potentiometer analog value number of milliseconds
  delay(poteOlek); 
}

/*
Example #2.3
*/
// Setup is same with example #2.1
 
const int pot = A1; 
const int led = 13; 
int potState = 0; 
 
void setup()
{
  pinMode(led, OUTPUT);
}
 
void loop() 
{
  // Get analog value of potentiometer
  potState = analogRead(pot); 
 
  // When potentiometer value is greater than 0 then set LED on halt program for short period
  if (poteOlek > 0) 
  {
    digitalWrite(led, HIGH);
    delayMicroseconds(poteOlek); 
  }
 
  // Turn LED off
  digitalWrite(led, LOW); 
 
  // Halt program for short period
  delayMicroseconds(1023 - poteOlek); 
}

Control LED on and off time with potentiometer.

Theory: https://www.arduino.cc/en/Reference/LiquidCrystal

/*
Example #3.1
*/
// Include LCD library
#include <LiquidCrystal.h> 
 
// Create LCD object and set hardware connection pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
void setup() 
{
  // Define LCD size
  lcd.begin(16, 2); 
 
  // Print out welcome message
  lcd.print("Hello World!"); 
}
 
void loop() 
{
  // Change cursor position to second line
  lcd.setCursor(0, 1); 
 
  // Print out program working time in seconds
  lcd.print(millis()/1000); 
}

/*
Example #3.2
*/
 
#include <LiquidCrystal.h>
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
  // Array to generate new character,
  // "0b" in front of the number tells the compiler that it's a binary number
byte customChar[8] = 
{
  0b11111,
  0b00000,
  0b01010,
  0b00000,
  0b10001,
  0b01110,
  0b00000,
  0b11111
};
 
void setup()
{
  // Load new character to LCD memory position "0"
  lcd.createChar(0, customChar); 
 
  // Define LCD size
  lcd.begin(16, 2); 
 
  // Display new custom character on LCD
  lcd.write((uint8_t)0);
}
void loop()
{
  // Do nothing
}

/*
Nimetus: Example #3.3
Kirjeldus: Reading LCD shield buttons
*/
 
#include <LiquidCrystal.h>
 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// Define button states constants
const int RIGHT = 0;
const int UP    = 1;
const int DOWN  = 2;
const int LEFT  = 3;
const int SELECT = 4;
const int NONE  = 5;
 
/* Global variables */
// Holds the value of pressed button
int pressedButton;
// Holds the value of analog input
int buttonValue;
 
void setup() 
{
  // Define LCD size
  lcd.begin(16, 2); 
 
  // Print explaining text
  lcd.print("ADC: ");
 
  // Print out analog input value
  lcd.print(analogRead(A0)); 
}
void loop() 
{
  // Calls out fucntion and saves returned value to variable
  pressedButton = checkButtons(); 
 
  // Check if there is a pressed button
  if(pressedButton < NONE)
  {
    lcd.clear(); // Clear LCD
 
    lcd.print("ADC: "); // Print out explaining text
 
    lcd.print(buttonValue); // Print out analog input value
 
    delay(500); // Halts program for 500ms to get stable text on LCD
  }
}
// Function read analog input value and compares it with values of button states
// Tagastab arvu vahemikus 0 kuni 5 vastavalt defineeritud konstandile
int checkButtons()
{
 // Get analog input value
 buttonValue = analogRead(A0);
 
 if (buttonValue < 50)   return RIGHT;
 if (buttonValue < 195)  return UP;
 if (buttonValue < 380)  return DOWN;
 if (buttonValue < 555)  return LEFT;
 if (buttonValue < 790)  return SELECT;
 // If no button state matches then return NONE
 return NONE;
}

Modify example so that text is center aligned.

Make a small animation with custom characters. Custom character code generator https://omerk.github.io/lcdchargen/

Libraries: https://www.arduino.cc/en/guide/libraries#toc4

/*
Example #4.2 
*/
 
// Vajalike teekide kaasamine
// LCD ekraani funktsioone sisaldav teek
#include <LiquidCrystal.h> 
// Ultrahelianduri funktsioone sisaldav teek
#include <NewPing.h> 
 
// Andurite ühendusviikude määramine
const int ultraheliKaugusandur_TRIGGER = A2;
const int ultraheliKaugusandur_ECHO = A3;
const int infrapunaLahedusandur = A4;
 
/* Globaalsed muutujad ja konstandid */
const int ultraheliKaugusandur_maksimumKaugus = 200;
int ultraheliKaugus, infrapunaNaebObjekti;
 
// LCD objekti tekitamine ja ühendusviikude määramine
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// Ultraheli kaugusanduri objekti tekitamine koos viikude ühendamisega
NewPing sonar(ultraheliKaugusandur_TRIGGER, ultraheliKaugusandur_ECHO,
ultraheliKaugusandur_maksimumKaugus);
 
void setup() 
{
  // LCD ridade ja veergude määramine vastavalt riistvarale
  lcd.begin(16, 2); 
 
  // Selgitavate tekstide kuvamine ekraanil
  lcd.print("Kaugus:");
  lcd.setCursor(0, 1);
  lcd.print("Naeb:");
}
void loop() 
{
  // Ultrahelianduriga kaguse mõõtmine sentimeetrites ja muutujasse salvestamine
  ultraheliKaugus = sonar.ping_cm();
 
  // Lähedusanduri väärtuse lugemine ja muutujasse salvestamine
  infrapunaNaebObjekti = digitalRead(infrapunaLahedusandur); 
 
  // Kursori esimesele reale ja tähemärgile 9 nihutamine
  lcd.setCursor(9, 0);
 
  // Ekraani kaugusanduri mõõdetud kauguse kuvamine
  lcd.print(ultraheliKaugus); 
 
  /* Trükime üle järgnevad kolm tähemärki tühikutega,
     et vana lugemi väärtus ei jääks ekraanil näha */
  lcd.print("   "); 
 
  // Kursori teisele reale ja tähemärgile 9 nihutamine
  lcd.setCursor(9, 1); 
 
  // Kui infrapunalähedusanduri väljund on kõrge, siis kirjuta ekraanile "ei"
  if(infrapunaNaebObjekti == 1) lcd.print("ei "); 
 
  // Kui infrapunalähedusanduri väljund on madal, siis kirjuta ekraanile "jah"
  else lcd.print("jah"); 
 
  // Väike viide, et tekst ekraanil oleks loetavam
  delay(500); 
}

Find out which sensor sample time is faster.

/*
Example #5.1
*/
// Mootori viikude määramine juhtmooduli juhtimiseks.
// Mootori liikumissuund sõltub ka mootori ühendamise polaarsusest.
const int vasak_A = 10; // juhtmooduli viik A-1A
const int vasak_B = 12; // juhtmooduli viik A-1B
const int parem_A = 11; // juhtmooduli viik B-1A
const int parem_B = 13; // juhtmooduli viik B-2A
 
void setup() 
{
  // Mootori juhtviikude väljundiks seadistamine
  pinMode(vasak_A,OUTPUT);
  pinMode(vasak_B,OUTPUT);
  pinMode(parem_A,OUTPUT);
  pinMode(parem_B,OUTPUT);
 
  mootorid(0,0); // Mootori algne peatamine
  delay(2000); // Viide, et robot laua pealt kohe plehku ei paneks
}
 
void loop() 
{
 
  mootorid(1,1); // Robot sõidab otse
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
 
  mootorid(-1,1); // Robot keerab vasakule
  delay(500);  // Viide - robot säilitab viite pikkuse liikumise
}
 
// Funktsioon mootori liikumissuundade määramiseks
void mootorid(int vasak, int parem)
{
  // Vasak mootor
  if(vasak == 1)
  { // Vasak mootor edasi
    digitalWrite(vasak_A,HIGH);
    digitalWrite(vasak_B,LOW);
  }
  else if(vasak == -1)
  { // Vasak mootor tagasi
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,HIGH);
  }
  else
  { // Vasak mootor seisma
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,LOW);
  }
 
  // Parem mootor
  if(parem == 1)
  { // Parem mootor edasi
    digitalWrite(parem_A,HIGH);
    digitalWrite(parem_B,LOW);
  }
  else if(parem == -1)
  { // Parem mootor tagasi
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,HIGH);
  }
  else
  { // Parem mootor seisma
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,LOW);
  }
}

/* Nimetus: 
Example #5.2
*/
// Mootori viikude määramine juhtmooduli juhtimiseks
// Mootori liikumissuund sõltub ka mootori ühendamise polaarsusest
const int vasak_A = 10; // juhtmooduli viik A-1A
const int vasak_B = 12; // juhtmooduli viik A-1B
const int parem_A = 11; // juhtmooduli viik B-1A
const int parem_B = 13; // juhtmooduli viik B-2B
 
void setup() 
{
  // Mootori juhtviikude väljundiks seadistamine
  pinMode(vasak_A,OUTPUT);
  pinMode(vasak_B,OUTPUT);
  pinMode(parem_A,OUTPUT);
  pinMode(parem_B,OUTPUT);
 
  mootorid(0,0); // Mootori algne peatamine
  delay(2000); // Viide, et robot laua pealt kohe plehku ei paneks
}
void loop()
 {
  mootorid(100,100); // Robot sõidab otse aeglaselt
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
  mootorid(100,255); // Robot keerab sujuvalt vasakule
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
  mootorid(-255,-255); // Robot tagurdab kiiresti
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
  mootorid(-255,-100); // Robot tagurdab sujuvalt paremale
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
  mootorid(150,-150); // Robot keerab kohapeal paremale
  delay(2000); // Viide - robot säilitab viite pikkuse liikumise
}
 
// Funktsioon mootori liikumissuuna ja kiiruse määramiseks
void mootorid(int vasak, int parem)
 {
  // Vasak mootor
  if(vasak > 0 && vasak <= 255)
  { // Vasak mootor otse
    analogWrite(vasak_A,vasak);
    digitalWrite(vasak_B,LOW);
  }
  else if(vasak < 0 && vasak >= -255)
  { // Vasak mootor tagurpidi
    analogWrite(vasak_A,255+vasak);
    digitalWrite(vasak_B,HIGH);
  }
  else
  { // Vasak mootor seisma
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,LOW);
  }
 
  // Parem mootor
  if(parem > 0 && parem <= 255)
  { // Parem mootor otse
    analogWrite(parem_A,parem);
    digitalWrite(parem_B,LOW);
  }
  else if(parem < 0 && parem >= -255)
  { // Parem mootor tagurpidi
    analogWrite(parem_A,255+parem);
    digitalWrite(parem_B,HIGH);
  }
  else
  { // Parem mootor seisma
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,LOW);
  }
}

Modify exampe so that robot drives number eight shape.

Make robot parallel park itself.

Theory: https://www.arduino.cc/en/Reference/Map

/*
Example #6.1
*/
 
// Vajalike teekide kaasamine
#include <Servo.h> 
 
// Servo objekti tekitamine nimega mootor
Servo mootor; 
 
// Seadmete ühendusviikude määramine
const int pote = A1; 
const int servo = 3;
 
void setup()
{
  // Servo objekti sidumine kindla Arduino viiguga
  mootor.attach(servo);
}
 
void loop()
{
 /* Muutuja tekitamine ja map funktsiooni kasutamine,
    et väärtused sobivasse vahemikku teisendada */
  int servoAsend = map(analogRead(pote),0,1023,0,180);
 
 /* Servomootorile positsiooni andmine vahemikus 0-180
    (üldiselt vastab väärtus mootori pöördenurga kraadidele) */
  mootor.write(servoAsend);
}

/*
Example #6.2
*/
 
// Kõikide vajalike teekide lisamine
#include <Servo.h>
#include <NewPing.h>
 
// Servo ja ultrahelianduri ühendusviikude määramine
#define MOOTOR 3
#define TRIG A3
#define ECHO A4
 
// Servo objekti tekitamine nimega sensM
Servo sensM;
 
// Anduri objekti tekitamine nimega sonar
NewPing sonar(TRIG, ECHO, 200);
 
void setup()
{
  // Servo objekti ja ühendusviigu sidumine
  sensM.attach(MOOTOR); 
 
  // Jadaliidese tavakiirusel käivitamine (9600 baudi)
  Serial.begin(9600); 
}
 
void loop() 
{
 
  // Jadaliidesesse selgitava teksti saatmine
  Serial.print("Kaugus: ");
 
  // Tsükkel, mis iga 10 kraadise servo liikumise järel teostab kauguse mõõtmise 
  for (int i = 0; i <= 180; i += 10) 
  {
    // Servo hoova liigutamine positsiooni i
    sensM.write(i); 
 
    // Viide, et servo jõuaks saavutada ette antud positsiooni enne uut mõõtmist
    delay(250); 
 
    // Uus kaugus mõõtmine ja  tulemuse jadapordi kirjutamine
    Serial.print(sonar.ping_cm()); 
    Serial.print(", ");
  }
 
  // Servo algpositsiooni liigutamine
  sensM.write(0); 
 
  // Viide, et servo jõuaks tagasi algpositsiooni
  delay(1000); 
 
  // Reavahetuse tekitamine jadapordis
  Serial.println(""); 
}

Modify the example so that servo motor tries to be towards a close by object.

Modify the example so that it returns the minimum and maximum distances and at what angles they were taken. Write data to serial port.