/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CARTE ARDUINO 328 MINI
//
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// NOTE GG :
// G.GIORDAN LE 22/09/2024
// Essai sur Wokwi
// ARDUINO 328 : lien : https://wokwi.com/projects/408681624091311105
//
//
//===================================================================================================
// LES DEFINES - INSTRUCTIONS POUR LE COMPILATEUR
//===================================================================================================
// fonction #ifdef, #ifndef et #endif
//---------------------------------------------------------------------------------------------------
// INSTRUCTION COMPILATEUR POUR LES INCLUDES+
//---------------------------------------------------------------------------------------------------
#if defined(ARDUINO_SAMD_MKRWIFI1010) || defined(ARDUINO_SAMD_NANO_33_IOT) || defined(ARDUINO_AVR_UNO_WIFI_REV2)
// #include <WiFiNINA.h>
#elif defined(ARDUINO_SAMD_MKR1000)
// #include <WiFi101.h>
#elif defined(ARDUINO_ARCH_ESP8266)
// #include <ESP8266WiFi.h>
#elif defined(ARDUINO_PORTENTA_H7_M7) || defined(ARDUINO_NICLA_VISION) || defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_GIGA) || defined(ARDUINO_OPTA)
// #include <WiFi.h>
#elif defined(ARDUINO_PORTENTA_C33)
// #include <WiFiC3.h>
#elif defined(ARDUINO_UNOR4_WIFI)
// #include <WiFiS3.h>
#endif
// #undef debug_print // pour annuler une definition
//************************* A METTRE HORS COMMENTAIRE POUR EXECUTION ********************************
// #define ex_led_clignote
// #define ex_analog_pin
// #define ex_serialprint
// #define ex_serialprintf
// #define ex_conversion
// #define ex_boucle
// #define ex_math
// #define ex_bits
// #define ex_char
// #define ex_tabchar
// #define ex_string1
#define ex_string2
// #define ex_receptserie
// #define ex_milliseconde
// #define ex_microseconde
// #define ex_pointeurs
// #define ex_progmem
// #define ex_interrupt
// #define ex_timer_interrupt_UNO_R3
// #define ex_fonction1
// #define ex_fonction2
// #define ex_fonction3
// #define ex_virtuino
#define fin_simple
// #define fin_boucle
#define DELAY_BOUCLE 500
//---------------------------------------------------------------------------------------------------
// DECLARATION POUR LA FONCTION SERIALPRINTF
//---------------------------------------------------------------------------------------------------
#if defined ex_serialprintf
// #include <stdarg.h> // declaration prealable pas necessaire
#define SERIAL_PRINTF_MAX_BUFF 256 // taille du buffer de traitement
#define F_PRECISION 3 // nombre de chiffres apres la virgule
// void serialPrintf(const char *fmt, ...); // declaration prealable pas necessaire
#endif
//---------------------------------------------------------------------------------------------------
//****************************************************************************************************
#define debug_print // definit le terme pour prise en compte des lignes ci-dessous (messages debug)
#if defined debug_print
#define debugp(x) Serial.print(x)
#define debugpln(x) Serial.println(x)
#else
#define debugp(x)
#define debugpln(x)
#endif
//===================================================================================================
// LES LIBRAIRIES
//===================================================================================================
//===================================================================================================
// DECLARATIONS GLOBALES DES VARIABLES ET CONSTANTES
//===================================================================================================
// Stockez les données dans la mémoire flash (programme) au lieu de la SRAM. Il existe une description
// des différents types de mémoire disponibles sur une carte Arduino.
// Le mot-clé PROGMEM est un modificateur de variable, il ne doit être utilisé qu'avec
// les types de données définis dans pgmspace.h. Il indique au compilateur de « mettre
//ces informations dans la mémoire flash », au lieu de la SRAM, où elles iraient normalement.
// const dataType variableName[] PROGMEM = {data0, data1, data3…};
// entiers non signés
const PROGMEM uint16_t ENTIER_LISTE[] = { 65000, 32796, 16843, 10, 11234};
// tableau de caracteres
const char CARACT_LISTE[] PROGMEM = {"BONJOUR"};
// tableau de string
const char STRING_0[] PROGMEM = "chaine 0";
const char STRING_1[] PROGMEM = "chaine 1";
// Then set up a table to refer to your strings.
const char *const STRING_TABLE[] PROGMEM = {STRING_0, STRING_1};
const boolean CONST_BOOL = true; // declaration d'une constante de 1 bit (false/true
const char CONST_CHAR = 1; // declaration d'une constante caractere (1 octet signe -128/127) (8bit)
const byte CONST_BYTE = 'A'; // declaration d'une constante (1 octet non signe 0/255) avec un caractere
const word CONT_WORD = 0b1111111111010011; // declaration d'une constante word (2 octets) = 65491
// const word CONT_WORD = 0xFFD3; // declaration d'une constante word (2 octets) = 65491
const int CONST_INT = 3; // declaration d'une constante entier (2 octets signe -32768/32767 )
const short CONST_SHORT = 3; // declaration d'une constante entier (2 octets signe -32768/32767 )
const unsigned int CONST_UINT = 0;// declaration d'une constante (2 octets non signe 0/65535)
const long CONST_LONG = 0; // declaration d'une constante (4 octets signe -2147483648/2147483647)
const unsigned long CONST_ULONG = 0; // declaration d'une constante (4 octets non signe 0/4294967295)
const float CONST_FLOAT = 0; // declaration d'une constante (4 octets signe -3.4028235E+38/3.4028235E+38)
const double CONST_DOUBLE = 0; // declaration d'une constante (4 octets signe -3.4028235E+38/3.4028235E+38)
char caracteres[] = {'A','B','C'}; // declaration d'un tableau de caracteres
boolean tab_bits [CONST_INT]; // declaration d'un tableau de bits (0/1)
int tab_integer [CONST_INT]; // declaration d'un tableau d'entiers
unsigned long millis_diff, millis_instant, millis_avant; // declaration de varibles non signees sur 4 octets
// declaration d'un tableau de pointeurs sur fonctions de type void fonction(void)
void (*ptfonctions[])(void) = { &fonction_1, &fonction_2 };
// void (*pfonction)(void); // declaration d'un pointeur sur fonction
// void (*ptfonction[5])(void); // declaration d'un tableua de pointeur sur fonction
String virtuino = "";
const byte TYPE_CARACTERE = 0; // type de variable : caractere = 0
const byte TYPE_NUMERIQUE = 1; // type de variable : numerique = 1
const byte TYPE_DATE = 2; // type de variable : date = 2
const byte TYPE_HEURE = 3; // type de variable : heure = 3
const byte TYPE_BIN = 4; // type de variable : binaire = 4
//===================================================================================================
// FONCTION SETUP
//===================================================================================================
void setup()
{
//---------------------------------------------------------------------------------------------------
// Initialisation du port serie pour le debug
//---------------------------------------------------------------------------------------------------
// Serial.begin(speed) ou Serial.begin(speed, config)
// port série : voir la liste des ports série disponibles pour chaque carte.
// speed : en bits par seconde (bauds). Types de données autorisés : long.
// config : définit les bits de données, de parité et d'arrêt. Les valeurs valides sont :
// SERIAL_5N1 SERIAL_6N1 SERIAL_7N1 SERIAL_8N1 (the default) SERIAL_5N2 SERIAL_6N2 SERIAL_7N2
// SERIAL_8N2 SERIAL_5E1 SERIAL_6E1 SERIAL_7E1 SERIAL_8E1 SERIAL_5E2 SERIAL_6E2 SERIAL_7E2
// SERIAL_8E2 SERIAL_5O1 SERIAL_6O1 SERIAL_7O1 SERIAL_8O1 SERIAL_5O2 SERIAL_6O2 SERIAL_7O2
// SERIAL_8O2
Serial.begin(9600); // Intialisation du port serie pour le Debug
while (!Serial) delay(1); // on attend que le port
// Désactive la communication série, permettant aux broches RX et TX d'être utilisées
//pour l'entrée et la sortie générales.
// Serial.end();
//---------------------------------------------------------------------------------------------------
// Initialisation des ports du microcontrolleur
//---------------------------------------------------------------------------------------------------
pinMode(LED_BUILTIN, OUTPUT); // initialisation de la broche en sortie (led sur la carte en D13)
pinMode(12, OUTPUT); // initialisation de la broche en sortie (la carte en D12)
pinMode(11, OUTPUT); // initialisation de la broche en sortie (la carte en D11)
pinMode(5, INPUT); // initialisation de la broche en entrée (broche D5)
pinMode(2, INPUT_PULLUP); // initialisation de la broche en entrée (broche D2) avec un R pullup
//---------------------------------------------------------------------------------------------------
// Gestion du timer sous interruption
//---------------------------------------------------------------------------------------------------
// ATmega328P est cadencé à 16 MHz, le comptage pourra aussi bien se faire à 16 MHz, tout comme à 8 MHz,
// 4 MHz, ou bien d’autres fréquences encore, en fonction du « prescaler
// Un prescaler (diviseur de fréquence « général »), permettant de diviser la fréquence du
// microcontrôleur par 1, 2, 4, 8, 16, 32, 64, 128, ou 256
// Et 3 prédiviseurs « secondaires » (un pour chaque timer), permettant de rediviser la fréquence
// issue du prescaler par :
// 1, 8, 64, 256, ou 1024 s’il s’agit du timer0
// 1, 8, 64, 256, ou 1024 s’il s’agit du timer1
// 1, 8, 32, 64, 128, 256, ou 1024 s’il s’agit du timer2
// – si la fréquence du microcontrôleur est de 16 MHz
// – si le prescaler est réglé sur 4
// – et si le prédiviseur du timer est réglé sur 32
// – Alors la fréquence arrivant au timer sera de 16MHz / 4 / 32, soit 125 kHz.
// – Le timer0 sert par exemple aux fonction delay(), micro(), millis(), ainsi qu’aux signaux PWM
// sortant sur les broches D5 et D6
// – Le timer1 sert en outre à la bibliothèque « Servo », permettant de contrôler des servomoteurs, ainsi
// qu’aux signaux PWM sortant sur les broches D9 et D10
// – Le timer2 sert entre autre à la fonction tone(), ainsi qu’aux signaux PWM sortant sur les broches D3 et D11
// Par ailleurs, il faudra vous assurer que les interruptions soient bien désactivées au moment de ce changement
// de rapport de fréquence, pour être certain que cette procédure se déroule bien, dans « le temps imparti »
// (qui, pour rappel, doit se faire sous 4 cycles d’horloge maximum, comme le précise le fabricant).
// modifier le rapport de division du prescaler (par défaut à 1) impactera directement tout un tas de systèmes,
// internes au microcontrôleur. Pour en citer une : la liaison série (UART).
// CLKPR = 0b1000 0000; // On indique au microcontrôleur qu’on souhaite changer de rapport de fréquence
// CLKPR = 0b0000 0101; // Puis on indique le rapport voulu (ici « 0101 » sur les 4 derniers bits, donc division par 32)
// alors que le prescaler ralentit « tout » le microcontrôleur, les prédiviseurs, quant à eux, ne ralentissent
// que les timers auxquels ils sont associés.
// Au niveau de l’ATmega328P, retrouve donc 3 prédiviseurs, puisqu’il y a 3 timer. Mais attention, car tous
// ces prédiviseurs ne sont pas identiques. En effet, leur rapport de division n’est pas forcément le même,
// suivant s’il s’agit du timer0, du timer1, ou timer2. Plus précisément :
// Timer0 et Timer1 permettent de diviser la fréquence par 1, 8, 64, 256, ou 1024
// Timer2 permet quant à lui de diviser la fréquence par 1, 8, 32, 64, 128, 256, ou 1024
// On indiquera dans le registre TCCR0B le rapport souhaité pour le timer0
// On indiquera dans le registre TCCR1B le rapport souhaité pour le timer1
// On indiquera dans le registre TCCR2B le rapport souhaité pour le timer2
// lien pour calculer la valeur des registre en fonction de la frequence voulue
// https://deepbluembedded.com/arduino-timer-calculator-code-generator/
// ci-dessous, utiisation de la methode COMPA
#if defined ex_timer_interrupt_UNO_R3
cli();//stop all interrupts
TCCR1A = 0; // Init Timer1A
TCCR1B = 0; // Init Timer1B
TCCR1B |= B00000001; // Prescaler = 1
OCR1A = 16000; // Timer Compare1A Register
TIMSK1 |= B00000010; // Enable Timer COMPA Interrupt
sei();// on autorise les interruptions
#endif
//---------------------------------------------------------------------------------------------------
// Initialisation des interruptions
//---------------------------------------------------------------------------------------------------
/* type de declenchement
LOW to trigger the interrupt whenever the pin is low,
CHANGE to trigger the interrupt whenever the pin changes value
RISING to trigger when the pin goes from low to high,
FALLING for when the pin goes from high to low.
*/
#if defined ex_interrupt
attachInterrupt(digitalPinToInterrupt(2),ITRoutine,RISING); // Interruption sur la pin D2, front montant
// noInterrupts(); // permet de bloquer les interruptions
// detachInterrupt(digitalPinToInterrupt(2)); // pour detacher la broche de l'interruption
#endif
//---------------------------------------------------------------------------------------------------
// Initialisation de la fonction random (astuce)
//---------------------------------------------------------------------------------------------------
randomSeed(analogRead(0)); // initialisation de la fonction random avec l'etat aleatoire d'une entree analogique
Serial.println("Demarrage du programme");
#if defined(ARDUINO_UNOR4_WIFI)
Serial.println("Carte valide\n");// #include <WiFiS3.h>
#endif
#if defined(AVR_UNO)
Serial.println("Carte valide\n");// #include <WiFiS3.h>
#endif
//---------------------------------------------------------------------------------------------------
}
//===================================================================================================
// BOUCLE PRINCIPALE
//===================================================================================================
void loop()
{
//------------------------ variables locales a la fonction loop -------------------------------------
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_led_clignote
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // on fait clignoter la led
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_analog_pin
int val = analogRead(A0); // lecture d'une valeur analogique sur la broche A0
Serial.print ("\nValeur analogique lue : "); Serial.print(val); // affichage
// Uno, Nano, Mini -> broches 3, 5, 6, 9, 10, 11, frequence 490 Hz (pins 5 and 6: 980 Hz)
analogWrite(11, 255 / 2); // PWM sur la broche 11 avec un rapport cyclique de 50%
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_math
Serial.print("\nvaleur absolue de -20 : "); Serial.print(abs(-20));
Serial.print("\nvaleur contrainte de 21, entre[1-20] : "); Serial.print(constrain(21, 1, 20));
Serial.print("\nremape 511 echelle[0-1023]->[0-255] : "); Serial.print(map(511, 0, 1023, 0, 255));
Serial.print("\nvaleur max 10 et 20 : "); Serial.print(max(10,20));
Serial.print("\nvaleur min 10 et 20 : "); Serial.print(min(10,20));
// Calcule la valeur d'un nombre élevé à une puissance.
// base : le nombre. Types de données autorisés : float.
// exposant : la puissance à laquelle la base est élevée. Types de données autorisés : float.
// Renvoie Le résultat de l'exponentiation. Type de données : double.
Serial.print("\ncalcul 2Exposant4 : "); Serial.print(pow(2,4));
Serial.print("\ncalcul de 2 puissance 2 : "); Serial.print(sq(2));
Serial.print("\ncalcul Racinecarree de 2 : "); Serial.print(sqrt(2));
// Calcule le cosinus d'un angle (en radians). Le résultat sera compris entre -1 et 1.
Serial.print("\ncalcul du cosinus de PI/4 : "); Serial.print(cos(3.14116/4));
Serial.print("\ncalcul du sinus de PI/4 : "); Serial.print(sin(3.14116/4));
Serial.print("\ncalcul de la tangente de PI/4 : "); Serial.print(tan(3.14116/4));
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_bits
// byte x = 0b00001111; // x=3
byte x = B00001111; // x=3
byte a = B00001111;
byte b = B00001010;
byte c = 0;
c = a & b;
Serial.print("\n0000 1111 et(logique) 00001010 : "); Serial.print(c,BIN);
c = a | b;
Serial.print("\n0000 1111 ou(logique) 00001010 : "); Serial.print(c,BIN);
c = a ^ b;
Serial.print("\n0000 1111 ou exclusif(logique) 00001010 : "); Serial.print(c,BIN);
c = ~a;
Serial.print("\n0000 1111 inverse : "); Serial.print(c,BIN);
c = 0;
c |= 1 << 7;
Serial.print("\n0000 0000 ou(logique) masque (1000 0000) : "); Serial.print(c,BIN);
c = 0;
c ^= 1 << 7;
Serial.print("\n0000 0000 ou exclusif(logique) masque (1000 0000) : "); Serial.print(c,BIN);
c = B11111111;
c &= 1 << 0 | 1 << 2 | 1 << 4;
Serial.print("\n1111 1111 et(logique) masque (0001 0101) : "); Serial.print(c,BIN);
// x = x >> 2; // decalage vers la droite 2 fois
x >>=2; // decalage vers la droite 2 fois
Serial.print("\ndecalage vers la droite 2 fois de 0000 1111 : "); Serial.print(x,BIN);
x <<=2; // decalage vers la gauche 2 fois
Serial.print("\ndecalage vers la gauche 2 fois de 0000 0011 : "); Serial.print(x,BIN);
Serial.print("\nnb de possibilites avec 8 bits : "); Serial.print(bit(8));
x = 0b00000011; // x=3
// Efface un bit, 0 pour le bit le moins significatif (le plus à droite).
Serial.print("\nmet a zero le bit1 de la valeur 0000 0011 : "); Serial.print(bitClear(x, 1),BIN);
Serial.print("\nlit le bit0 de la valeur 0000 0001 : "); Serial.print(bitRead(x, 0),BIN);
Serial.print("\nmet a 1 le bit1 de la valeur 0000 0001 : "); Serial.print(bitSet(x, 1),BIN);
Serial.print("\nmet a 1 le bit2 de la valeur 0000 0011 : "); Serial.print(bitWrite(x, 2, 1),BIN);
word y = 0b1111111111010011;
Serial.print("\nextrait le poids fort du word 1111 1111 1101 0011 : "); Serial.print(highByte(y),BIN);
Serial.print("\nextrait le poids faible du word 1111 1111 1101 0011 : "); Serial.print(lowByte(y),BIN);
x = 0b00000011; // x=3
Serial.print("\ntransforme un entier(3)(8bits) en chaine de caracteres : ");Serial.println (DecBin(x));
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_serialprint
Serial.print(".");
Serial.print(F("\nStokage en memoire flash")); // stokage de la chaine dans la memoire flash
Serial.print("\naffichage a la ligne - methode 1\n"); // affichage avec saut de ligne
Serial.println("affichage a la ligne - methode 2\n"); // affichage avec saut de ligne println
Serial.println("differents formats d'affichage : "); // affichage
Serial.print(78, BIN); // affiche : "1001110"
Serial.print("\t"); // affichage d'un tab
Serial.print(78, OCT); // affiche : "116"
Serial.print("\t"); // affichage d'un tab
Serial.print(78, DEC); // affiche : "78"
Serial.print("\t"); // affichage d'un tab
Serial.print(78, HEX); // affiche : "4E"
Serial.print("\t"); // affichage d'un tab
Serial.print(1.23456, 0); // affiche : "1"
Serial.print("\t"); // affichage d'un tab
Serial.print(1.23456, 2); // affiche : "1.23"
Serial.print("\t"); // affichage d'un tab
Serial.print(1.23456, 4); // affiche : "1.2346"
Serial.print("\n"); // affichage d'un saut de ligne
char buf[50]; int x=50; // declaration d'un tableau de caracteres et d'un entier
sprintf(buf, "x = %d", x); // mise en forme
Serial.println(buf); // affichage du tableau de caracteres
snprintf(buf , sizeof buf, "x = %04d", x); // construction de la syntaxe x = 000X
Serial.println(buf); // affichage
Serial.print("taille du tableau : "); // affichage
Serial.print(sizeof buf); // affichage la taille du tableau, soit 50
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_serialprintf
serialprintf( "Name: %s\nAge: %d\nHeight: %fm\nWeight: %fkg","Luka", 21, 2.01, 104.8);
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_conversion
int ic = 65;
float nombre = 24.4517;
char c;
char buf1[10];
char buf2[]="123.456";
c = char (ic);
Serial.print("\nconversion d'un entier en caractere : "); Serial.print(c); // affichage du caractere 'A'
Serial.print("\nautre affichage : "); // affichage
Serial.print(ic); // affichage de la valeur 65
Serial.print(" "); // affichage
Serial.print((char)ic); // affichage du caractere 'A'
itoa(ic, buf1, 10); // conversion d'un entier en un tableau de caracteres sur la base de 10
Serial.print("\nconversion d'un entier -> tableau de caracteres : "); Serial.print(buf1); // affichage
Serial.print("\nconversion d'un entier -> tableau de caracteres : " + String(buf1)); // affichage
// dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER);
/* la première est une variable de type double, que nous voulons convertir.
La seconde est une variable de type char utilisée pour définir la largeur de la variable de sortie ou le nombre de chiffres.
La troisième est une variable de type char utilisée pour définir le nombre de chiffres après la décimale.
La quatrième est une variable de type char dans laquelle la conversion sera stockée.
*/
dtostrf(nombre, 3, 3, buf1); // conversion d'un float en un tableau de caracteres (4 chiffres apres la ,)
Serial.print("\nconversion d'un float1 -> tableau de caracteres : "); Serial.print(buf1); // affichage
dtostrf(nombre, 6, 3, buf1);
Serial.print("\nconversion d'un float2 -> tableau de caracteres : "); Serial.print(buf1); // affichage
ic = atoi(buf1); // conversion d'un tableau de caracteres en un entier
ic++;
Serial.print("\nconversion d'un tableau de caracteres -> entier : "); Serial.print(ic); // affichage
nombre = atof(buf2); // conversion d'un tableau de caracteres en un float
Serial.print("\nconversion d'un tableau de caracteres -> reel : "); Serial.print(nombre); // affichage
strcpy(buf2,"07/02/1968");
ic = random(100);
isDigit(buf2[0]);
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_char
Serial.print("\nc'est un caractere alpha : " + String( isAlpha('a') ) );
Serial.print("\nc'est un caractere alphanumerique : " + String( isAlphaNumeric('1') ) );
Serial.print("\nc'est un caractere ascii : " + String( isAscii(255) ) );
Serial.print("\ncest un caractere control : " + String( isControl(13) ) );
Serial.print("\ncest un caractere digit : " + String( isDigit('1') ) );
Serial.print("\ncest un caractere graph : " + String( isGraph('A') ) );
Serial.print("\ncest un caractere hexa : " + String( isHexadecimalDigit('A') ) );
Serial.print("\ncest un caractere Lcase: " + String( isLowerCase('a') ) );
Serial.print("\ncest un caractere printable : " + String( isPrintable('a') ) );
Serial.print("\ncest un caractere punct : " + String( isPunct(',') ) );
Serial.print("\ncest un caractere space : " + String( isSpace(' ') ) ); // ' ' \n \t \r \f \v
Serial.print("\ncest un caractere Ucase : " + String( isUpperCase('A') ) );
Serial.print("\ncest un caractere whitespace : " + String( isWhitespace(' ') ) ); // ou tab \t
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_tabchar
int valeur;
char message0[]="tableau";
char message1[]="tableau";
char message2[]="caracteres";
char message4[20];
char message5[]="idem";
char message6[]="idem";
char message7[20][2];
String message8[2];
message8[0] = "Bonjour ";
message8[1] = "Gerard";
Serial.print("\n Concatenation de Strings : " + message8[0] + message8[1]);
message0[5]=0;
Serial.print("\nchaine raccourcie : "+String(message0));
String message3 = String(message1) + " de " + String(message2); // assemblage
Serial.print("\ntype : [" + String(message3)+"]"); // affichage du message complet
valeur = strlen(message1); // longueur du tableau de caracteres sans le caractere fin de chaine : 0
Serial.print("\nlongueur du tableau de caractere strlen 'tableau' : "); Serial.print(valeur); // affichage
valeur = sizeof(message1); // longueur du tableau de caracteres avec le caractere fin de chaine : 0
Serial.print("\nlongueur du tableau de caractere sizeof 'tableau' : "); Serial.print(valeur); // affichage
strcpy(message4, message1); // copie du message 1 dans le message 3
Serial.print("\ncopie du message 1 dans le message 4 : "); Serial.print(message4); // affichage
strcpy(message4, "tableau");
Serial.print("\ncopie du texte dans le message 4 : "); Serial.print(message4); // affichage
strcpy(&message7[0][0], "tableau");
Serial.print("\ncopie du texte dans tableau multiple : "); Serial.print(&message7[0][0]); // affichage
strcat(message4, " de caracteres"); // concatenation deux tableaux de caracteres
Serial.print("\nrajout d'un chaine de caracteres au message 4 : "); Serial.print(message4); // affichage
// message4 = message4 + " de caracteres"; // pas possible
char * ptrchar;
ptrchar = strcat(message4, " de caracteres"); // concatenation deux tableaux de caracteres; retour le pointeur sur message4
Serial.print("\nrajout d'un chaine de caracteres au message 4 : "); Serial.print(ptrchar); // affichage
// La fonction strchr() renvoie un pointeur vers la première occurrence de c qui est convertie en caractère dans chaîne.
// La fonction renvoie NULL si le caractère spécifié est introuvable.
char cherche='a';
ptrchar = strchr( message4, cherche );
Serial.print("\nrecherche du caractere 'a' dans message 4 : "); Serial.print(ptrchar); // affichage
// La fonction strcmp() compare string1 et string2. La fonction fonctionne sur des chaînes terminées par des valeurs indéfinies.
// 0 string1 identique à string2
// Les arguments de chaîne de la fonction doivent contenir un caractère null (\0) qui marque la fin de la chaîne.
valeur = strcmp( message5, message6 );
Serial.print("\ncomparaison de message1 et message 2 : "); Serial.print(valeur); // affichage
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_string1
String chaine1 = "Bonjour";
String chaine2 = " monsieur";
String chaine3 = "";
String chaine4 = "idem";
String chaine5 = "idem";
char tabcar1[] = "hello";
char tabcar2[8];
Serial.print("\naffichage d'une string : "+ chaine1);
Serial.print("\nlongueur de la string : "); Serial.print(chaine1.length()); // longueur de la chaîne
Serial.print("\nlongueur de la string : "); Serial.print(sizeof(chaine1)); // taille de la variable
chaine3 = chaine1 + chaine2; Serial.print("\nConcatenation de 2 strings : "+ chaine3);
chaine1.replace("jour"," appetit"); Serial.print("\nremplace dans la string : "); Serial.print(chaine1);
Serial.print("\ncomparaison de 2 string : "+String(chaine4==chaine5));
Serial.print("\nextraction dans une string : "+ chaine3.substring(0,7)); // extrait le String de l’index1 à l’index2
// myString.indexOf(val) ou myString.indexOf(val, from)
// Parameters : myString: a variable of type String.
// val: the value to search for. Allowed data types: char, String.
// from: the index to start the search from.
// The index of val within the String, or -1 if not found.
Serial.print("\nrecherche dans la chaine '"+ chaine2 +"' le caractere 'i' : "); Serial.print(chaine2.indexOf('i'));
Serial.print("\nrecherche dans la chaine '"+ chaine2 +"' la chaine 'si' : "); Serial.print(chaine2.indexOf("si"));
//Locates a character or String within another String. By default, searches from the end
Serial.print("\nrecherche dans la chaine '"+ chaine2 +"' la chaine 'eu' (back) : ");Serial.print(chaine2.lastIndexOf("eu"));
chaine3 = String(tabcar1); Serial.print("\nconversion de tabl de car en string : " + chaine3);
chaine3.toCharArray(tabcar2, 8); Serial.print("\nconversion d'une string en tabl de car : "); Serial.print(tabcar2);
// Lorsque le texte du String est assez long, vous pouvez soit:
// L’écrire sur une seule ligne en plaçant les caractères fin de ligne (« \n ») et retour charito (\r)
// Concaténer plusieurs chaines de caractère pour obtenir le texte que vous souhaitez
// Une méthode bien plus pratique qui vous permettra de mieux visualiser et modifier le texte existe.
// La balise R spécifie au compilateur de traiter ce qu’il y a entre les balise comme un texte.
String header1="HTTP/1.1 200 OK\n\rContent-Type: text/html\n\r\n\r";
String header2="HTTP/1.1 200 OK\n\r";
header2+="Content-Type: text/html\n\r";
header2+="\n\r";
String header3=R"=====(
HTTP/1.1 200 OK
Content-Type: text/html
)=====";
Serial.print("\nstring 'header1' : "+ header1);
Serial.print("\nstring 'header2' : "+ header2);
Serial.print("\nstring 'header3' : "+ header3);
String tempstring; // declaration d'une string
tempstring.reserve(60); // allocation en memoire de 60 octets
tempstring = String("{\""); // manimpulation de la string
Serial.print("\nChaine provisoire : " + tempstring); // affichage
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_string2
String stringA = "Bonjour";
String stringB = "Bonjour T";
String stringC = "Bon";
String stringD = "Bonjour";
String stringE = "Merci";
String stringF = "our";
Serial.print("\nOperations avec la string : " + stringA);
Serial.print("\n caractere 2 : "); Serial.print(stringA.charAt(2));
Serial.print("\n caractere 2 : " + String(stringA.charAt(2)));
Serial.print("\n Comparaison ("+stringA +" / "+ stringD + ") : ");
Serial.print(stringA.compareTo(stringD));
Serial.print("\n c_str() !!! :");Serial.print(stringA.c_str());
Serial.print("\n Endswith ("+stringA +" / "+ stringC + ") : ");
Serial.print(stringA.endsWith(stringC));
Serial.print("\n Endswith ("+stringA +" / "+ stringE + ") : ");
Serial.print(stringA.endsWith(stringE));
Serial.print("\n Endswith ("+stringA +" / "+ stringF + ") : ");
Serial.print(stringA.endsWith(stringF));
Serial.print("\n Equal ("+stringA +" / "+ stringD + ") : ");
Serial.print(stringA.equals(stringD));
Serial.print("\n EqualIgnoreCase ("+stringA +" / "+ stringD + ") : ");
Serial.print(stringA.equalsIgnoreCase(stringD));
char buffer[5];
stringA.getBytes(buffer,4);
Serial.print("\n getBytes (taille 4) ("+ stringA +") : "); Serial.print(buffer);
Serial.print("\n indexof ("+ stringA +" / "+ stringF + ") : "); Serial.print(stringA.indexOf(stringF));
Serial.print("\n indexof ("+ stringA +" / 'o' a partir de 2) : "); Serial.print(stringA.indexOf('o',2));
bool drapeau = true;
Serial.print("\n Affiche true : ");
Serial.println(drapeau);
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_boucle
Serial.print("\n Goto : ");
goto suite;
Serial.print(" avant");
suite:
Serial.print(" apres");
Serial.print("\n if : ");
int j=3;
if ( ( (j>0) && (j<5) ) || (j!=4) || ( j==6) ) { Serial.print(" "); Serial.print(j);}
Serial.print("\n if else : ");
j=3;
if ( j==2 ) {Serial.print(" OK : ");Serial.print(j);} else {Serial.print(" KO : ");Serial.print(j);}
Serial.print("\n if elseif : ");
j=3;
if ( j==2 ) {Serial.print(" J=2 : ");Serial.print(j);}
else if( j==4) {Serial.print(" j=4 : ");Serial.print(j);}
else {Serial.print(" j<>2 et j<>4 : ");Serial.print(j);}
Serial.print("\n boucle for : ");
for(int i=0; i<5; i++) { Serial.print(" "); Serial.print(i);}
Serial.print("\n boucle for (continue, on saute la valeur 3) : ");
for(int i=0; i<5; i++)
{ if(i==3) continue;
Serial.print(" "); Serial.print(i);
}
Serial.print("\n boucle for (break, on arrete a la valeur 2) : ");
for(int i=0; i<5; i++)
{ if(i==3) break;
Serial.print(" "); Serial.print(i);
}
int k=0;
Serial.print("\n boucle while : ");
while(k<5) { Serial.print(" "); Serial.print(k); k++;}
k=0;
Serial.print("\n boucle do while : ");
do
{ Serial.print(" "); Serial.print(k); k++;}
while(k<5);
k=0;
Serial.print("\n boucle do..while : ");
do { Serial.print(" "); Serial.print(k); k++;} while(k<5);
k=2;
Serial.print("\n switch case : ");
switch (k)
{ case 1:
Serial.print(" cas1 : "); Serial.print(k);
break;
case 2:
Serial.print(" cas2 : ");Serial.print(k);
break;
default:
Serial.print(" cas_autre : ");Serial.print(k);
break;
}
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_pointeurs
char *pointeur_char = NULL; // declaration d'un pointeur sur caractere
char tableau_ch[] = {'A','B'}; // declaration d'un tableau
pointeur_char = &tableau_ch[0]; // affectation du pointeur avec l'adresse du tableau
Serial.print("\ncaractere indique par le pointeur : "); Serial.print(char(*pointeur_char));
Serial.print("\ncaractere indique par le pointeur : "); Serial.print(char(*tableau_ch));
pointeur_char++; // on incremente l'adresse du pointeur pour la case suivante
Serial.print("\ncaractere indique par le pointeur : "); Serial.print(char(*pointeur_char));
*pointeur_char += 1; // on incremente la valeur pointee par le pointeur
Serial.print("\ncaractere indique par le pointeur : "); Serial.print(char(*pointeur_char));
int i=0; // declaration d'un variable entier
fonctionptr(&i); // on passe l'adresse de la variable à la fonction (qui va modifier sa valeur)
Serial.print("\nla fonction incremente la variable i : "); Serial.print(i);
int *tableau_entier; // declaration d'un pointeur sur interger
tableau_entier = new int[3]; // allocation dynamique d'un tableau affecte au pointeur
tableau_entier[0] = 10; // on initialise une valeur
Serial.print("\nvaleur du tableau dynamique : "); Serial.print(tableau_entier[0]);
delete[] tableau_entier; // on supprime l'allocation du tableau en memoire
tableau_entier = NULL; // on met un pointeur null dans la variable
int val = 123;
int *pVal = &val;
int **ppVal = &pVal;
int ***pppVal = &ppVal;
Serial.print("\nles valeurs : ");
Serial.print(val, DEC); Serial.print(" "); // Affiche 123
Serial.print(*pVal, DEC); Serial.print(" "); // Affiche 123 aussi !
Serial.print(**ppVal, DEC); Serial.print(" "); // Affiche 123 aussi !!
Serial.print(***pppVal, DEC); // Affiche 123 aussi !!!
ptfonctions[0](); // appele de la fonction avec le pointeur sur fonction
ptfonctions[1](); // appele de la fonction avec le pointeur sur fonction
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_progmem
unsigned int displayInt = pgm_read_word_near(ENTIER_LISTE + 1); // cherche donnee dans memoire flash (program)
Serial.print("\n variable entiere (PROGMEM ) : "); Serial.println(displayInt); // affiche
char mychar = pgm_read_byte_near(CARACT_LISTE + 2); // cherche donnee dans memoire flash (program)
Serial.print("\n variable caractere (PROGMEM ) : ");Serial.print(mychar); // affiche
char buff3[8];
strcpy_P(buff3, (char *)pgm_read_word(&(STRING_TABLE[0]))); // affectation et copie
Serial.print("\n variable string (PROGMEM ) : ");Serial.println(buff3);
Serial.print(F("Cette chaine de caracteres est stokee dans la memoire flash"));
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_receptserie
// Obtenez le nombre d'octets (caractères) disponibles pour l'écriture dans le tampon série
// sans bloquer l'opération d'écriture.
// Serial.print("\nnombre de caracteres libre en ecriture : "); Serial.print(Serial.availableForWrite());
while(Serial.available()> 0) // tant qu'il y a des caractères à lire
{ // variable local contenant le caractère à lire
char car = Serial.read(); // on lit le caractère
Serial.print(car); // puis on le renvoi à l’expéditeur tel quel
}
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
/* La valeur de retour de millis() est de type unsigned long, des erreurs logiques peuvent se produire
si un programmeur essaie de faire de l'arithmétique avec des types de données plus petits tels que int.
Même un long signé peut rencontrer des erreurs car sa valeur maximale est la moitié de celle de son
homologue non signé.
millis() est incrémenté (pour les puces AVR 16 MHz et certaines autres) toutes les 1,024 millisecondes,
puis incrémenté de 2 (au lieu de 1) toutes les 41 ou 42 ticks, pour le remettre en synchronisation;
ainsi, certaines valeurs millis() sont ignorées. Pour un timing précis sur de courts intervalles,
pensez à utiliser micros().
millis() reviendra à 0 après environ 49 jours (micros en environ 71 minutes).
La reconfiguration des temporisateurs du microcontrôleur peut entraîner des lectures millis() inexactes.
Les cœurs « Arduino AVR Boards » et « Arduino megaAVR Boards » utilisent Timer0 pour générer millis().
*/
#if defined ex_milliseconde
millis_avant = millis(); // donne le temps ecoule en ms depuis le demarrage du processeur (unsigned long)
delay (200); // pause en ms (unsigned int)
millis_instant = millis();
millis_diff = millis_instant - millis_avant;
Serial.print("\ntemps ecoule(ms) : "); Serial.print(millis_diff);
#endif
//---------------------------------------------------------------------------------------------------
/* Renvoie le nombre de microsecondes depuis que la carte Arduino a commencé à exécuter le programme en cours.
Ce nombre débordera (reviendra à zéro) après environ 70 minutes. Sur les cartes de la famille Arduino Portenta,
cette fonction a une résolution d'une microseconde sur tous les cœurs.
Sur les cartes Arduino 16 MHz (par exemple Duemilanove et Nano), cette fo
Sur les cartes Arduino 8 MHz (par exemple le LilyPad), cette fonction a une résolution de 8 microsecondes.
*/
#if defined ex_microseconde
millis_avant = micros(); // donne le temps ecoule en us depuis le demarrage du processeur (unsigned long)
delayMicroseconds(20000); // pause en us (unsigned int)
millis_instant = micros();
millis_diff = millis_instant - millis_avant;
Serial.print("\ntemps ecoule(us) : "); Serial.print(millis_diff);
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined ex_virtuino
// Reception d'une chaine virtuino : topic +"V"+
// Exemple : VGG1_V001
char car = 0;
bool dr = false;
char v[2][20];
char v2[20];
String vs[2];
const int DATE = 0;
int i = 0;
vs[DATE]="05/10/2024";
strcpy(&v[DATE][0], "05/10/2024");
Serial.print("\nVariable : ");
Serial.print(&v[i][0]);
strcp (v2, "Bonjour");
Serial.print("\n");
Serial.println(String(v2));
strcp (&v[0][1], "Bonjour");
Serial.print("\n");
Serial.println(String(&v[0][1]));
// String tempstring;
// tempstring.reserve(60);
// tempstring = String("{\"");
// Serial.print("\n Chaine provisoire : " + tempstring);
/*
while( dr != true)
{
while(Serial.available()> 0) // tant qu'il y a des caractères à lire
{ // variable local contenant le caractère à lire
car = Serial.read(); // on lit le caractère
Serial.print(car); // puis on le renvoi à l’expéditeur tel quel
virtuino = virtuino + String(car);
if (car == '$') break;
}
if (car == '$') { dr = true; }
}
Serial.print("\n Chaine virtuino final : " + virtuino);
*/
Serial.print("\n Fin virtuino");
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_fonction1
int a = 2;
int b = 0;
Serial.print("\n Fonction : appel simple : ");
fonction1(a);
Serial.print("\n Fonction : appel avec retour variable");
b = fonction2(a);
Serial.print(" resultat : ");Serial.print(b,DEC);
Serial.print("\n Fonction : appel avec pointeur char : ");
char table[4];
char* ptrchar;
ptrchar = fonction3(table);
Serial.print(ptrchar[0]); Serial.print(" ");
Serial.print(ptrchar);Serial.print(" ");
Serial.print(table);Serial.print(" ");
Serial.print(fonction3(table));
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_fonction2
char date []="21/01/24";
char heure[]="01:02:59";
char numero[]="123";
char binaire[]="1";
char caract[] = "Bonjour";
if (cformat(date,TYPE_DATE,0,0)== true) Serial.print("\nBon format date"); else Serial.print("\nMauvais format date");
if (cformat(heure,TYPE_HEURE,0,0)== true) Serial.print("\nBon format heure"); else Serial.print("\nMauvais format heure");
if (cformat(numero,TYPE_NUMERIQUE,0,123)== true) Serial.print("\nBon format num"); else Serial.print("\nMauvais format num");
if (cformat(binaire,TYPE_BIN,0,0)== true) Serial.print("\nBon format bin"); else Serial.print("\nMauvais format bin");
if (cformat(caract,TYPE_CARACTERE,0,0)== true) Serial.print("\nBon format car"); else Serial.print("\nMauvais format car");
#endif
//---------------------------------------------------------------------------------------------------
#if defined ex_fonction3
char mes[20];
char* ptrcar;
ptrcar = mes;
ptrcar = retourchar("BONJOUR?",'?');
Serial.print("\nRetour du tableau : "); Serial.print(mes);
Serial.print("\nPremier caractere : "); Serial.print(mes[0]);
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
#if defined fin_simple
while(1); // on bloque sur cette boucle
#endif
#if defined fin_boucle
delay(DELAY_BOUCLE); // delai dans la boucle principale
#endif
}
//===================================================================================================
//===================================================================================================
// DECLATATION DES FONTIONS
//===================================================================================================
//---------------------------------------------------------------------------------------------------
// FONCTION1 : fonction simple (sans retour)
//---------------------------------------------------------------------------------------------------
void fonction1(int parametre)
{ parametre = parametre + 3;
Serial.print(" Fonction simple");
}
//---------------------------------------------------------------------------------------------------
// FONCTION2 : fonction avec retour
//---------------------------------------------------------------------------------------------------
int fonction2(int parametre)
{
return parametre + 2;
}
//---------------------------------------------------------------------------------------------------
// FONCTION3 : fonction avec retour
//---------------------------------------------------------------------------------------------------
char* fonction3(char* variable)
{
variable[0]='A';
variable[1]='B';
variable[2]='C';
variable[3]= 0;
return variable;
}
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction modification d'un tableau de caracteres
//---------------------------------------------------------------------------------------------------
char* retourchar(char* chaine,char carfin)
{
char caract = 0;
char tab[20];
int i = 0;
Serial.print("\Debut chaine : "); Serial.println(chaine);
Serial.print("Caractere : ");
while(*(chaine+i) != carfin)
{ caract = *(chaine+i) + 32;
Serial.print(caract); Serial.print(" ");
tab[i]= caract;
i++;
}
tab[i] = 0;
Serial.print("\nTableau : "); Serial.println(tab);
return &tab[0];
}
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction copie de chaine de caracteres
//---------------------------------------------------------------------------------------------------
char* strcp (char* chaine1, char* chaine2)
{ int i=0;
Serial.print("\n Fonction copie : ");
while (chaine2[i] != 0)
{ chaine1[i] = chaine2[i];
Serial.print(char(chaine1[i])); Serial.print("-");
i++;
}
chaine1[i] = 0;
return chaine1;
}
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction appelee avec un pointeur sur integer
//---------------------------------------------------------------------------------------------------
void fonctionptr(int *i) { *i+=1; }
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction 1 pour demonstration des pointeurs sur fonction
//---------------------------------------------------------------------------------------------------
void fonction_1(void)
{
Serial.print("\n fonction 1"); // affichage sur le port serie
}
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction 2 pour demonstration des pointeurs sur fonction
//---------------------------------------------------------------------------------------------------
void fonction_2(void)
{
Serial.print("\n fonction 2 - debut"); // affichage sur le port serie
return; // instruction pour sortie de la fonction
Serial.print("\n fonction 2 - fin"); // affichage sur le port serie
}
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction déclenchee par le timer sous interruption
//---------------------------------------------------------------------------------------------------
#if defined ex_timer_interrupt_UNO_R3
ISR(TIMER1_COMPA_vect)
{
OCR1A += 16000; // Advance The COMPA Register
// Serial.print("\n-> Interruption");
digitalWrite(12, !digitalRead(12)); // on fait clignoter la broche D12
}
#endif
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction déclenchee par une interruption materiel
//---------------------------------------------------------------------------------------------------
void ITRoutine() // Routine sous IT
{
noInterrupts(); // Désactive l'interruption globale
// cli(); // Désactive l'interruption globale pas compatible avec UNO R4
Serial.print("\nInterruption"); // on affiche
interrupts(); // autorise les interruptions
// sei(); // autorise les interruptions pas compatible avec UNO R4
}
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : fonction pour convertir un entier sur 8 bits en binaire (chaine de caracteres)
//---------------------------------------------------------------------------------------------------
char *DecBin (int n)
{
static char bin[8];
int x;
for (x= 0 ; x<8; x++)
{
bin[x] = n & 0x80 ? '1' : '0'; // 0x8000 pour 16 bits
n <<= 1;
}
bin[x] ='\0';
return(bin);
}
//---------------------------------------------------------------------------------------------------
// FONCTION : serialprintf affichage avec une mise en forme
//---------------------------------------------------------------------------------------------------
/*
* --------------------------------------------------------------
* realise un affichage simple avec des donnees formatees
* Supporte les conversions suivantes : (conversion specifier)
* d, i signed int
* u unsigned int
* ld, li signed long
* lu unsigned long
* f double
* c char
* s string
* % '%'
* Usage: %[conversion specifier]
* Note: cette fonction ne supporte pas les "format specifiers" suivants:
* [flag][min width][precision][length modifier]
* --------------------------------------------------------------
*/
#if defined ex_serialprintf
void serialprintf(const char *fmt, ...)
{
/* buffer for storing the formatted data */
char buf[SERIAL_PRINTF_MAX_BUFF];
char *pbuf = buf; /* pointer to the variable arguments list */
va_list pargs;
/* Initialise pargs to point to the first optional argument */
va_start(pargs, fmt); /* Iterate through the formatted string to replace all
conversion specifiers with the respective values */
while(*fmt) {
if(*fmt == '%') {
switch(*(++fmt)) {
case 'd':
case 'i':
pbuf += sprintf(pbuf, "%d", va_arg(pargs, int));
break; case 'u':
pbuf += sprintf(pbuf, "%u", va_arg(pargs, unsigned int));
break; case 'l':
switch(*(++fmt)) {
case 'd':
case 'i':
pbuf += sprintf(pbuf, "%ld", va_arg(pargs, long));
break; case 'u':
pbuf += sprintf( pbuf, "%lu",
va_arg(pargs, unsigned long));
break;
}
break; case 'f':
pbuf += strlen(dtostrf( va_arg(pargs, double),
1, F_PRECISION, pbuf));
break;
case 'c':
*(pbuf++) = (char)va_arg(pargs, int);
break; case 's':
pbuf += sprintf(pbuf, "%s", va_arg(pargs, char *));
break; case '%':
*(pbuf++) = '%';
break; default:
break;
}
} else {
*(pbuf++) = *fmt;
}
fmt++;
}
*pbuf = '\0';
va_end(pargs);
Serial.print(buf);
}
#endif
//---------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------
// FONCTION : controle de formats
//---------------------------------------------------------------------------------------------------
bool cformat(char* ptrc, char format, int vmini, int vmax) // controle le format
{ if (format == TYPE_HEURE)
{ // char tabc[]="13:15:59";
// ptrc = tabc;
int heure = (ptrc[0]-'0')*10 + ptrc[1]-'0';
int minute = (ptrc[3]-'0')*10 + ptrc[4]-'0';
int seconde = (ptrc[6]-'0')*10 + ptrc[7]-'0';
// Serial.print(heure,DEC); Serial.print(minute,DEC); Serial.print(seconde,DEC);
// Serial.print(ptrc[8],DEC);
for(int i=0; i<8; i++)
{ if ((i==2 || i==5)) i++;
int num = ptrc[i]-'0';
if((num<0)||(num>9)) return false;
}
if ((heure<0) && (heure>24)) return false;
if ((minute<0) && (minute>59)) return false;
if ((seconde<0) && (seconde>59)) return false;
if ((ptrc[2]!=':') || (ptrc[5]!=':')) return false;
if (ptrc[8]!= 0) return false;
}
if(format == TYPE_DATE)
{ // char tabc[]="21/01/24";
// ptrc = tabc;
int jour = (ptrc[0]-'0')*10 + ptrc[1]-'0';
int mois = (ptrc[3]-'0')*10 + ptrc[4]-'0';
int annee = (ptrc[6]-'0')*10 + ptrc[7]-'0';
// Serial.print(jour,DEC); Serial.print(mois,DEC); Serial.print(annee,DEC);
// Serial.print(ptrc[8],DEC);
for(int i=0; i<8; i++)
{ if ((i==2 || i==5)) i++;
int num = ptrc[i]-'0';
if((num<0)||(num>9)) return false;
}
if ((jour<1 ) && (jour>31)) return false;
if ((mois<1 ) && (mois>12)) return false;
if ((annee<00) && (annee>99)) return false;
if ((ptrc[2]!='/') || (ptrc[5]!='/')) return false;
if (ptrc[8]!= 0) return false;
if (((mois==4)||(mois==6)||(mois==9)||(mois==11)) && (jour>30)) return false;
if ((((annee%4 == 0)&&(annee%100 != 0)&&(annee%4 == 0)) == false)&&(mois==2)&&(jour>28)) return false;
}
if(format == TYPE_BIN)
{ // char tabc[]="2";
// ptrc = tabc;
int binaire = (ptrc[0]-'0');
if ((binaire<0) ||(binaire>1)) return false;
if (ptrc[1]!=0) return false;
}
if(format == TYPE_NUMERIQUE)
{ // char tabc[]="124";
// ptrc = tabc;
for(int i=0; i<15; i++)
{ if (ptrc[i]==0) break;
if (((ptrc[i]-'0')<0) || ((ptrc[i]-'0')>9)) return false;
}
int nombre = atoi(ptrc);
if ((nombre<vmini) || (nombre>vmax)) return false;
}
if(format == TYPE_CARACTERE)
{ for(int i=0; i<20; i++)
{ if (ptrc[i]==0) break;
if ((ptrc[i]<' ') || (ptrc[i]>'~')) return false;
}
}
return true;
}
//===================================================================================================
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CARACTERISTIQUES DES CARTES ARDUINO
//
/////////////////////////////////////////////////////////////////////////////////////////////////////
//===================================================================================================
// CARTE UNO R4 WIFI
//===================================================================================================
/*
MEMORIES
--------
32 kB of SRAM
256 kB flash
8 kB data (EEPROM).
Pins
----
Pin to attachInterrupt() -> UNO R4 Minima, UNO R4 WiFi : 2, 3
The UNO R4 WiFi gives you access to many different pins and many of them have special features that
will be accounted for in the upcoming sections of this article. Keep reading to learn what you can do with them.
If you just need a quick overview of the pins functionality, this is a full table of all the IO pins on the UNO R4 WiFi.
Pin Type Function
D0 Digital UART Receive
D1 Digital UART Transmit
D2 Digital GPIO pin, Interrupt
D3 Digital GPIO pin, Interrupt, PWM
D4 Digital GPIO pin
D5 Digital GPIO pin, PWM
D6 Digital GPIO pin, PWM
D7 Digital GPIO pin
D8 Digital GPIO pin
D9 Digital GPIO pin, PWM
D10 Digital SPI (CS), GPIO pin, PWM
D11 Digital SPI (COPI), GPIO pin, PWM
D12 Digital SPI (CIPO), GPIO pin
D13 Digital SPI (SCK), GPIO pin, Built-in LED
A0 Analog Analog In, DAC OUT
A1 Analog in Analog In, OPAMP +
A2 Analog in Analog In, OPAMP -
A3 Analog Analog In, OPAMP OUT
A4 Analog in Analog In, SDA*
A5 Analog in Analog In, SCL*
*A4 and A5 pins are both connected to the same I2C bus.
Analog Pins
The UNO R4 WiFi has six analog input pins (A0-A5) that can be read by using the
analogRead()
function.
Pin Type Function
A0 Analog Analog In, DAC
A1 Analog Analog In, OPAMP +
A2 Analog Analog In, OPAMP -
A3 Analog Analog In, OPAMP OUT
A4 Analog Analog In, SDA*
A5 Analog Analog In, SCL*
*A4 and A5 pins are both connected to the same I2C bus.
*/