char Str1[15];
//Nella seguente sarà il compilatore ad aggiungere il carattere extra '\0'
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; // HA DIMENSIONE 8! Ovvero 7 + 1, l'1 è '\0'
//La seguente che ha il carattere null = '\0' ESPLICITO
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
 
//Array inizializzato con una stringa costante tra doppi apici ", il compilatore
//      aggiungerà '\0' alla fine e darà automaticamente la dimensione 8!
char Str4[] = "arduino";
//Definizione ed inizializzazione esplicita.. nota la dimensione 8!
char Str5[8] = "arduino";
//Come prima ma con extra-dimensionamento, '\0' sarà dopo la 0 di "arduino"
char Str6[15] = "arduino";

#include <iostream>
using namespace std;
 
char m_ArrDBSubTypes[3][10] = {"Number", "Letter", "Shape"};
 
void StampaArrayStr(char (&arr)[3][10]) {
  //La base dell'indice è 0 quindi per 3 elementi si cicla dino al'indice =2 (ovvero i < 3)
  for (int i = 0; i < 3; i++) {	
    cout << i << "-> " << arr[i] << "|\n";
  }
}
 
int main() 
{
    cout << "Test array:\n";
    StampaArrayStr(arrDBSubTypes);	
    return 0;
}

#include <iostream>
#include <cstring>	//Per usare la funzione di copia strcpy(destinazione, sorgente)
 
//COSTANTI
const int DIM_DB_VOBJ = 6;  const int DIM_DB_STYPE = 3;
const int DIM_STR_PicSubType = 8;
 
enum PictureType    {Text, Rectangle, Square, Circle, Triangle};
 
class MyVisualObject {
	public:
	//--------------- Attributi ----------------
	char Label;             //Opzionale nel caso l'oggetto da disegnare sia grafico e non testo		
	PictureType    PicType; //Enum.,   indica il tipo oggetto: testo, rettangolo, cerchio, triangolo
	char PicSubType[DIM_STR_PicSubType];	//Stringa sottotipo: "Number", "Letter", "Shape", "Symbol"		
	//--------------- END Attributi ------------
 
	//Costruttori:
	MyVisualObject() {}
	MyVisualObject(char label, PictureType picType, const char* picSubType) {
		Label = label; 
		PicType = picType; 
		strcpy(PicSubType, picSubType); //!! Copia da un array an un altro!
	}
};
 
MyVisualObject m_ArrDBVisualObj[DIM_DB_VOBJ];
 
void StampaArrObjOut() {
  for (int i=0; i<DIM_DB_VOBJ; i++){
    //cout << i << "\n";
    cout << i << "-> " << m_ArrDBVisualObj[i].Label << ", SubType=" << m_ArrDBVisualObj[i].PicSubType << "|\n";
  }
}
 
int main() 
{
    cout << "Test array:\n";
 
    //Assegnazione array di oggetti
    m_ArrDBVisualObj[0]  =  MyVisualObject('0', PictureType::Text, "Number");
    m_ArrDBVisualObj[1]  =  MyVisualObject('1', PictureType::Text, "Number");
	m_ArrDBVisualObj[2]  =  MyVisualObject('2', PictureType::Text, "Number");
	m_ArrDBVisualObj[3]  =  MyVisualObject('3', PictureType::Text, "Number");
	m_ArrDBVisualObj[4]  =  MyVisualObject('X', PictureType::Text, "Letter");
    m_ArrDBVisualObj[5]  =  MyVisualObject('Q', PictureType::Square, "Shape");
 
	StampaArrObjOut();
	return 0;
}

class MyVisualObject {
public:
	char Label;             //Opzionale nel caso l'oggetto da disegnare sia grafico e non testo
	PictureType    PicType; //Enum.,   indica il tipo oggetto: testo, rettangolo, cerchio, triangolo
	char PicSubType[DIM_STR_PicSubType];//Stringa, indica il sottotipo: "Number", "Letter", "Shape"
//Costruttori:
	MyVisualObject() {}
}
MyVisualObject m_ArrDBVisualObj[14]; 
//-------------------------------------------------------
 
bool StrCmp(const char* arr1, const char* arr2) {
    int i = 0;
    while (arr1[i] != '\0' && arr2[i] != '\0') {
        if (arr1[i] != arr2[i]) return false;
        i++;
    }
    return arr1[i] == '\0' && arr2[i] == '\0';
}
int main() 
{
    // Your existing code...
    bool isEqual = StrCmp(m_ArrDBVisualObj[0].PicSubType, "Number");
    cout << "Comparison result: " << (isEqual ? "Equal" : "Not Equal") << "\n";
 
    return 0;
}

#include <Arduino.h> //<-- Usando VS code e PlatformIO
 
int PIN_x  = 13; //Definisco con una costante il PIN per una determinata azione
 
void setup() {
    pinMode(PIN_x, INPUT);
}
 
void loop() {
    if (digitalRead(PIN_x) == HIGH) {
    // Si esegue azione specifica assegnata allo stato HIGH del pin 13
    }
}

int valoreTensione = analogRead(numeroPosta_analogica); //Valore tensione è da normalizzare!

// Constants
const float V_REF = 5.0;     // Analog reference voltage (e.g., 5V or 3.3V)
const float R_BITS = 10.0;   // ADC resolution (bits)
const float ADC_STEPS = (1 << int(R_BITS)) - 1; // Number of steps (2^R_BITS - 1)
 
const int potentiometerPin = A3; // Potentiometer wiper connected to analog pin A3
 
void setup() {

 Serial.begin(9600); // Initialize serial communication
 Serial.println(ADC_STEPS);

}
 
void loop() {

 int rawValue = analogRead(potentiometerPin); // Read the analog input
 float voltage = (rawValue / ADC_STEPS) * V_REF; // Convert to voltage

 

 Serial.print("Voltage: ");
 Serial.print(voltage, 3); // Print voltage with 3 decimal places
 Serial.println(" V");

 

 delay(200); // Small delay to avoid flooding the serial monitor

}

#include <LibPrintf.h>
 
void setup() {
  Serial.begin(9600);
  printf("Semplice testo\n");
  printf("x: %d \n", 100);
  printf("v: %f \n", 123.34);
 
  printf("%5d %5d %5d\n", 1, 22, 333);
  printf("%05d %05d %05d\n", 12, 23, 456);
  printf("%-5d %-5d %-5d\n", 12, 23, 456);
  printf("%+5d %+5d %+5d\n\n", 12, -23, 456);
  printf("%5.2f\n", 123.3456);
  printf("%10.2e\n\n", 123.3456);
  printf("str: %s\n", "Stringa innestata nel testo di output.");
  printf("perc: 10%%\n");
 
  printf("%*.*f\n", 10,3, 123.3456);
}
 
void loop() {
}

#include <EEPROM.h>
 
void setup() {
  Serial.begin(9600);
 
  while (!Serial) {
    //Attendo che venga aperto il monitor seriale
  }
 
  /*
     Definisco degli indirizzi di memoria.
     Ciascuno per ogni esempio.
  */
  int IND_0 = 0; // Per il metodo write() e read() nel successivo sketch
  int IND_1 = 10; // Per il metodo put() e get() nel successivo sketch
  int IND_2 = 20; // Per il metodo put() e get() con tipo di dato custom
  int IND_3 = 40; // Per il metodo EEPROM[] e update()
 
  //Valore di tipo float per il primo esempio put() e get()
  float tipoFloat = 0.65;
 
  //Struttura custom per il secondo esempio put() e get()
  struct CustomObj {
    byte numero;
    float conVirgola;
    char testo[10];
  };
 
  //Oggetto custom per il secondo esempio put() e get()
  CustomObj mioCustomObj = {
    2,
    9.21000f,
    "Ciaone"
  };
 
  //Il metodo write
  EEPROM.write(IND_0, 25); //salvo all'indirizzo 0 il valore 25
  Serial.println("Scrittura con metodo write eseguita.");
 
  //Il metodo put - primo esempio
  EEPROM.put(IND_1, tipoFloat); //salvo all'indirizzo 1 il valore di tipoFloat con il relativo tipo (float)
  Serial.println("Scrittura con metodo put - primo esempio eseguita.");
 
  //Il metodo put - secondo esempio
  EEPROM.put(IND_2, mioCustomObj); //salvo all'indirizzo 2 l'oggetto mioCustomObj avente struttura CustomObj
  Serial.println("Scrittura con metodo put - secondo esempio eseguita.");
 
  //EEPROM come array
  EEPROM[IND_3] = 9; //salvo all'indirizzo 3 il numero 9
  Serial.println("Scrittura con sintassi array eseguita.");
 
  Serial.println("Adesso carica il secondo sketch e controlla che ci sia tutto");
}

#include <EEPROM.h>
 
void setup() {
  Serial.begin(9600);
 
  while (!Serial) {
    //Attendo che venga aperto il monitor seriale
  }
 
  /*
     Definisco gli stessi indirizzi di memoria dello sketch precedente.
  */
  int IND_0 = 0; // Per il metodo write() e read() nel successivo sketch
  int IND_1 = 10; // Per il metodo put() e get() nel successivo sketch
  int IND_2 = 20; // Per il metodo put() e get() con tipo di dato custom
  int IND_3 = 40; // Per il metodo EEPROM[] e update()
 
  //Valore di tipo float per il primo esempio put() e get()
  float tipoFloat;
 
  //Struttura custom per il secondo esempio put() e get()
  struct CustomObj {
    byte numero;
    float conVirgola;
    char testo[10];
  };
 
  //Oggetto custom per il secondo esempio put() e get()
  CustomObj mioCustomObj;
 
  //Il metodo read
  int valPrimoEsempio = EEPROM.read(IND_0); //leggo dall'indirizzo 0
  Serial.print("Lettura con metodo read mi aspetto 25: ");
  Serial.println(valPrimoEsempio, DEC);// mi aspetto il valore 25
 
  //Il metodo get - primo esempio
  EEPROM.get(IND_1, tipoFloat); //leggo dall'indirizzo 1 il valore di tipo float e lo metto nella variabile tipoFloat
  Serial.print("Lettura con metodo get - primo esempio mi aspetto 0.65: ");
  Serial.println(tipoFloat, 2); // mi aspetto il valore 0.65
 
  //Il metodo get - secondo esempio
  EEPROM.get(IND_2, mioCustomObj); //leggo dall'indirizzo 2 e metto il contenuto nel mio oggetto custom
  Serial.println("Lettura con metodo get - secondo esempio mi aspetto (2, 9.21, 'Ciaone') ");
  Serial.println(mioCustomObj.numero, DEC); // mi aspetto 2
  Serial.println(mioCustomObj.conVirgola, 2); // mi aspetto 9.21
  Serial.println(mioCustomObj.testo);  // mi aspetto "Ciaone"
 
  //EEPROM come array
  EEPROM[IND_3] = 9; //salvo all'indirizzo 3 il numero 9
  Serial.println("Scrittura con sintassi array eseguita.");
 
  int valAsArray = EEPROM[IND_3]; //leggo dall'indirizzo 3
  Serial.print("Lettura con sintassi array mi aspetto 9: ");
  Serial.println(valAsArray); // mi aspetto 9
 
  //Aggiorno ultimo valore con metodo update()
  EEPROM.update(IND_3, 18);
  Serial.println("Aggiornamento valore con metodo update eseguito.");
 
  //leggo nuovamente dall'indirizzo 3
  int valAfterUpdate = EEPROM[IND_3];
  Serial.print("Lettura con sintassi array mi aspetto 18: ");
  Serial.println(valAfterUpdate); // mi aspetto 18
 
  Serial.println("Fatto!");
 
}
 
void loop() {
  // tutto avviene nel setup
}

#include <EEPROM.h>
 
int address = 0; // Indirizzo da controllare
 
void setup() {
  Serial.begin(9600);
 
  byte valore = EEPROM.read(address);
 
  if (valore == 0xFF) {
    Serial.println("EEPROM vuota, inizializzo...");
    // Scrivi qui i valori di default
    EEPROM.write(address, 1); // Esempio: scrivo 1
  } else {
    Serial.print("Valore trovato: ");
    Serial.println(valore);
  }
}
 
void loop() {}

#include <EEPROM.h>
 
const int addrFlag = 0;
const int addrData = 2;
const unsigned int SIGNATURE = 0xABCD; // Firma magica
 
void setup() {
  unsigned int checkSign;
  EEPROM.get(addrFlag, checkSign);
 
  if (checkSign != SIGNATURE) {
    // Prima esecuzione o EEPROM corrotta
    Serial.println("Inizializzazione EEPROM...");
    EEPROM.put(addrData, 123.45f); // Salva dati di default
    EEPROM.put(addrFlag, SIGNATURE); // Scrive la firma
  } else {
    // EEPROM già in uso
    float dati;
    EEPROM.get(addrData, dati);
    Serial.print("Dati letti: ");
    Serial.println(dati);
  }
}
void loop() {}

#include <EEPROM.h>
 
// Definire la dimensione della EEPROM (es. 512 byte)
#define EEPROM_SIZE 512
 
void setup() {
  Serial.begin(115200);
 
  // 1. Inizializzare la EEPROM
  if (!EEPROM.begin(EEPROM_SIZE)) {
    Serial.println("Errore nell'inizializzazione EEPROM");
    delay(1000);
    ESP.restart();
  }
 
  // --- SCRITTURA ---
  int valoreScritto = 12345;
  int indirizzo = 0;
 
  // EEPROM.put scrive qualsiasi tipo di dato (int, float, struct)
  EEPROM.put(indirizzo, valoreScritto);
 
  // 2. Fondamentale: commit() per rendere la scrittura permanente
  EEPROM.commit(); 
  Serial.println("Dato scritto e salvato.");
 
  // --- LETTURA ---
  int valoreLetto;
  EEPROM.get(indirizzo, valoreLetto);
 
  Serial.print("Dato letto dalla EEPROM: ");
  Serial.println(valoreLetto);
}
 
void loop() {
  // Loop vuoto
}

#include <Preferences.h>
Preferences prefs;
 
void setup() {
  prefs.begin("my-app", false); // Apre lo spazio "my-app" in lettura/scrittura
  prefs.putInt("punteggio", 42); // Salva un intero con chiave "punteggio"
  int valore = prefs.getInt("punteggio", 0); // Legge il valore (0 è il default)
  prefs.end();
}

//Il seguente è un "trucco" per evitare di includere più volte una stessa libreria
//la costate Blink_h non è usata direttamente se non come flag qui
#ifndef Blink_h
#define Blink_h
 
#include "Arduino.h"
 
class Blink {
    public:
        //Costruttore:
        Blink(int pin);
        void blink(int tim)
 
    private:
        int _pin
}
#endif

#include "Arduino.h"
#include "Blink.h"
 
//Implementazione costruttore!
Blink::Blink(int pin) {
    pinMode(pin, OUTPUT);
    _pin = pin;
}
 
void Blink::blink(int tim) {
    digitalWrite(_pin, HIGH);
    delay(tm);
    digitalWrite(_pin, LOW);    
    delay(tm);
}

#include "Blink.h"
 
Blink blink(13);
 
void setup() {}
 
void loop() {
    blink.blink(500);
}

Serial.println(F("Ciao mondo!"));

void setup() {  
  pinMode(LED_BUILTIN, OUTPUT); // Il pin LED_BUILTIN è il 13 ...
}
 
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // Accende il LED sulla scheda
  delay(1000);                      // Attende FERMANDO L'ESECUZIONE per 1 secondo
  digitalWrite(LED_BUILTIN, LOW);   // Si spegne il LED
  delay(1000);                      // Si attende 1 secondo sempre BLOCCANDO tutto
}

#include <Arduino.h>
 
unsigned long m_previousMillis = 0; // Intero lungo con i millisecondi dell'istante attuale DOPO l'accensione di Arduino
const long c_delayMillis = 1000;    // Millisecondi di attesa per una azione nel loop()
 
void setup() {
  pinMode(LED_BUILTIN, OUTPUT); // Imposta il pin del LED integrato come uscita  
}
 
void loop() {
  unsigned long currentMillis = millis(); // Millisecondi dell'istante attuale DOPO l'accensione di Arduino
 
  // Controlla se è passato il tempo di attesa
  if (currentMillis - m_previousMillis >= c_delayMillis) {
    m_previousMillis = currentMillis; // Aggiorna l'istante precedente
 
    // Cambia lo stato del LED
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
}

#define DEBUG 0
 
#if DEBUG
#define prt(x) Serial.print(x);
#define prtn(x) Serial.println(x);
#else 
#define prt(x)
#define prtn(x)
#endif
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  prt("Ciaone");
  prtn(" !");
}
 
void loop() {
  // put your main code here, to run repeatedly:
 
}

const int MAX_ELEMENTI = 10; // Dimensione massima dell'array
int mioArrayDinamico[MAX_ELEMENTI]; // Array statico
int numeroElementi = 0; // Contatore degli elementi attivi
 
void setup() {
  Serial.begin(9600);
}
 
void loop() {
  // Aggiungi un elemento (se c'è spazio)
  if (numeroElementi < MAX_ELEMENTI) {
    mioArrayDinamico[numeroElementi] = analogRead(A0); // Esempio: legge valore analogico
    numeroElementi++;
    Serial.print("Aggiunto elemento. Totale: ");
    Serial.println(numeroElementi);
  }
 
  // Rimuovi elemento (l'ultimo)
  if (numeroElementi > 0) {
    numeroElementi--;
    Serial.print("Rimosso elemento. Totale: ");
    Serial.println(numeroElementi);
  }
 
  // Leggi tutti gli elementi attivi
  for (int i = 0; i < numeroElementi; i++) {
    Serial.print("Elemento ");
    Serial.print(i);
    Serial.print(": ");
    Serial.println(mioArrayDinamico[i]);
  }
  delay(1000);
}

int *mioArray;
int dimensione = 0;
 
void setup() {
  Serial.begin(9600);
  // Alloca per 5 elementi iniziali
  mioArray = (int*)malloc(5 * sizeof(int));
  if (mioArray != NULL) {
    dimensione = 5;
    Serial.println("Allocazione iniziale riuscita.");
  }
}
 
void loop() {
  // Esempio: rialloca per aggiungere altri elementi
  if (dimensione < 10) {
    int *nuovoArray = (int*)realloc(mioArray, 10 * sizeof(int));
    if (nuovoArray != NULL) {
      mioArray = nuovoArray;
      dimensione = 10;
      Serial.println("Reallocazione riuscita.");
    }
  }
  // ... usa mioArray ...
  delay(2000);
}

/* 
  Sketch generated by the Arduino IoT Cloud Thing "Untitled"
  https://create.arduino.cc/cloud/things/8cb07275-7f5c-414f-86cc-7b7e9c80389a 
 
  Arduino IoT Cloud Variables description
 
  The following variables are automatically generated and updated when changes are made to the Thing
 
  String dispositivoParlante;
  String messaggio;
 
  Variables which are marked as READ/WRITE in the Cloud Thing will also have functions
  which are called when their values are changed from the Dashboard.
  These functions are generated with the Thing and added at the end of this sketch.
*/
 
#include "thingProperties.h"
 
void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 
 
  // Defined in thingProperties.h
  initProperties();
 
  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
 
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}
 
void loop() {
  ArduinoCloud.update();
  // Your code here 
 
 
}
 
/*
  Since Messaggio is READ_WRITE variable, onMessaggioChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onMessaggioChange()  {
  // Add your code here to act upon Messaggio change
}
 
/*
  Since DispositivoParlante is READ_WRITE variable, onDispositivoParlanteChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onDispositivoParlanteChange()  {
  // Add your code here to act upon DispositivoParlante change
}

int number = 1234;
int *pointer;       //pointer è una variabile che conterrà un puntatore e sarà di tipo intero
pointer = &number;  //pointer conterrà l'indirizzo di memoria della variabile number
*pointer = 10;      //modifica inserendo 10 nella memoria puntata da pointer ==> number sarà così diventato 10

int i=0, j=0;
int *p, *q;
p=&i; //p conterrà l'indirizzo di i
*p=3; //poiché p punta ad i, l'istruzione equivale a scrivere: i=3;
j=*p; //è come scrivere assegna a j il contenuto puntato da p, equivale a j=i;
q=p; //equivale a scrivere q=&i;

char arrCaratteri[15] = "Salve Peppino.";
char *p; //E' un PUNTATORE a variabile di tipo char (volendo anche il 1°elemento di un array di caratteri)
 
//Ora SI ASSEGNA a p l'indirizzo dell'array !!!
p = arrCaratteri; //p punterà alla testa dell'array ovvero al carattere 'S'
 
//DA QUI IN POI scrivere   *p    è come scrivere    arrCaratteri[0]  !!!

void setup() {	
   Serial.begin(9600);		
   unsigned long previousMillis = millis();
   unsigned long currentMillis = millis();
   while (!Serial         //Attende che il Serial Monitor sia pronto
      && (currentMillis - previousMillis <= 10000)) {//timeout 10s Xevitare blocco se SerialMonitor non partisse
         currentMillis = millis();
   }
   Serial.println(F("Serial Monitor inizializzato correttamente...")); 
   //..altre istruzioni qui...
}

void setup() {
  Serial.begin(9600);
  Serial.print("Board: ");
 
  #if defined(ARDUINO_AVR_UNO)
    Serial.println("Arduino Uno");
  #elif defined(ARDUINO_AVR_MEGA2560)
    Serial.println("Arduino Mega 2560");
  #elif defined(ARDUINO_AVR_NANO)
    Serial.println("Arduino Nano");
  #elif defined(__AVR_ATmega32U4__)
    Serial.println("Arduino Leonardo/Micro");
  #elif defined(ESP8266)
    Serial.println("ESP8266 board");
  #elif defined(ESP32)
    Serial.println("ESP32 board");
  #else
    Serial.println("Unknown/Other board");
  #endif
}
 
void loop() {
  // Your main code here
}