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() {
}

//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!"));

// save some unsigned ints
    const PROGMEM uint16_t charSet[] = { 65000, 32796, 16843, 10, 11234};
 
    // save some chars
    const char signMessage[] PROGMEM = {"I AM PREDATOR,  UNSEEN COMBATANT. CREATED BY THE UNITED STATES DEPART"};
 
    unsigned int displayInt;
    char myChar;
 
 
    void setup() {
      Serial.begin(9600);
      while (!Serial);  // wait for serial port to connect. Needed for native USB
 
      // put your setup code here, to run once:
      // read back a 2-byte int
      for (byte k = 0; k < 5; k++) {
        displayInt = pgm_read_word_near(charSet + k);
        Serial.println(displayInt);
      }
      Serial.println();
 
      // read back a char
      int signMessageLength = strlen_P(signMessage);
      for (byte k = 0; k < signMessageLength; k++) {
        myChar = pgm_read_byte_near(signMessage + k);
        Serial.print(myChar);
      }
 
      Serial.println();
    }
 
    void loop() {
      // put your main code here, to run repeatedly:
    }

void setup() {
   Serial.begin(9600); // Inizializzazione con 9600 baud
   while (Serial);  // Da Arduino 4 in poi occorre attendere che l'inizializzazione seriale sia davvero operativa
}
 
void loop() {
    Serial.println("Testo con accapo!");
    Serial.print("Solo testo (NON con accapo)!");
}

//??? String stringaLetta = Serial.readStringUntil('\n');
String readString;
 
while(Serial.available()) //all the time there is something to read
{
	//read the input
    delay(50);  //waste some time to allow characters to arrive
    char c=Serial.read(); //read a character
    readString+=c;  //add it to a String
} 	//keep reading until there is nothing more to read
 
if(readString.length()>0){  //if something was actually read and added to the String
    Serial.println(readString); //print the String
	if (readString =="ON"){ //if the String is "ON"
     digitalWrite(led, HIGH); //make the led pin HIGH
    }
 
    readString="";  //reset the value of the String to nothing
 }

String displayMsg = "";
int stationCount = 0;
//Concatenazione
dispMsg = "Trovate " + (String)stationCount + " staz. ";
 
Serial.println(dispMsg);

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;