Funzioni del personaggio in Arduino
Funzioni del personaggio in Arduino
Poiché ci sono diversi tipi di caratteri usati in Arduino, quindi per ogni tipo c'è una funzione del carattere per riconoscere quel tipo di carattere.Di seguito sono riportati gli undici tipi di funzioni di personaggio che sono brevemente spiegate in questo discorso:
- Funzioni di carattere ISupperCase () e IslowerCase ()
- ISDIGIT () Funzione del carattere
- Funzione del carattere Isspace ()
- funzione di carattere ispunct ()
- Funzione di carattere isxdigit ()
- funzione di carattere isalpha ()
- ISASCII () Funzione carattere
- funzione di carattere iscntrl ()
- ISPRINT () Funzione del carattere
- Funzione di carattere isalnum ()
- funzione di carattere isgraph ()
La spiegazione di ciascuna funzione è supportata dal rispettivo esempio.Gli esempi del programma Arduino forniti stanno usando l'operatore ternario. Questo operatore è ulteriormente diviso in tre parti. La prima parte è la condizione che deve essere controllata e poi arriva l'operatore e se il risultato è corretto, viene visualizzato il valore dato prima e se non il secondo valore verrà visualizzato. Questo può essere ulteriormente cancellato dalla sintassi dell'operatore ternario:
((funzione applicata) ? (valore da visualizzare se vero) :( valore da visualizzare se falso));
Funzioni di carattere ISupperCase () e IslowerCase ()
La funzione maiuscola viene utilizzata per verificare se il carattere utilizzato nella programmazione Arduino è in lettere maiuscole o no. Allo stesso modo, per determinare se il carattere è scritto in piccole lettere, viene utilizzato il minuscolo della funzione. Viene fornito il codice di esempio per entrambe le funzioni:
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione islower dice: \ r");
Seriale.Stampa (islower ('f') ? "f is": "f non è");
Seriale.println ("lettera minuscola \ r");
Seriale.print ("funzione islower dice: \ r");
Seriale.Stampa (islower ('f') ? "f is a": "f non è a");
Seriale.println ("lettera minuscola \ r");
Seriale.print ("funzione isupper dice: \ r");
Seriale.stampa (iSupper ('f') ? "F is": "f non è");
Seriale.println ("lettera maiuscola \ r");
Seriale.print ("funzione isupper dice: \ r");
Seriale.stampa (iSupper ('f') ? "F is a": "f non è a");
Seriale.println ("lettera maiuscola \ r");
void loop ()
Produzione
ISDIGIT () Funzione del carattere
Per verificare se il personaggio è un numero o una lettera isdigit () La funzione viene utilizzata nella programmazione Arduino. Il codice di esempio fornisce un'ulteriore chiara comprensione della funzione.
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione isdigit dice: \ r");
Seriale.Stampa (isdigit ('1') ? "1 is": "1 non è");
Seriale.println ("digit \ r");
Seriale.print ("funzione isdigit dice: \ r");
Seriale.stampa (isdigit ('a') ? "A is a": "a non è a");
Seriale.println ("digit \ r");
void loop ()
Produzione
Funzione del carattere Isspace ()
Per determinare se c'è uno spazio utilizzato nel programma Arduino la funzione del carattere Isspace () si usa. Gli spazi includono lo spazio della scheda sia orizzontale che verticale, spazio per nuova linea, forma di alimentazione, spazio di ritorno. Qui nel codice di esempio tutti i tipi di spazi vengono utilizzati e determinati utilizzando la funzione ISSPACE (). L'output del programma Arduino è in forma binaria. Se l'output è uno, allora significa vero e se il risultato è zero, significa falso.
char carattere1 = ";
char caratteri2 = '\ t';
char caratteri3 = 'c';
char carattere4 = '\ n';
char carattere5 = '\ f';
char caratteri6 = 'a';
char carattere7 = '\ v';
char carattere8 = '\ r';
void setup () // Metti qui il codice di configurazione, da eseguire una volta:
Seriale.Inizia (9600);
Seriale.println (Isspace (caratteri1));
Seriale.println (Isspace (caratteri2));
Seriale.println (Isspace (caratteri3));
Seriale.println (Isspace (caratteri4));
Seriale.println (Isspace (caratteri5));
Seriale.println (Isspace (caratteri6));
Seriale.println (Isspace (caratteri7));
Seriale.println (Isspace (caratteri8));
void loop ()
Produzione
funzione di carattere ispunct ()
Per identificare eventuali segni di punteggiatura nel codice la funzione ispunct () si usa. Nell'esempio vengono utilizzati quattro segni di punteggiatura e un carattere e un numero vengono anche utilizzati per dare un quadro chiaro del funzionamento della funzione.
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione ispunct dice: \ r");
Seriale.Stampa (ispunct ('!') ? "! è un": "! non è un");
Seriale.println ("punteggiatura mark \ r");
Seriale.print ("funzione ispunct dice: \ r");
Seriale.print (ispunct (':') ? ": è un": ": non è un");
Seriale.println ("punteggiatura mark \ r");
Seriale.print ("funzione ispunct dice: \ r");
Seriale.Stampa (ispunct ('0') ? "0 è un": "0 non è un");
Seriale.println ("punteggiatura mark \ r");
Seriale.print ("funzione ispunct dice: \ r");
Seriale.stampa (ispunct ('a') ? "A is a": "a non è a");
Seriale.println ("punteggiatura mark \ r");
Seriale.print ("funzione ispunct dice: \ r");
Seriale.print (ispunct (';') ? "; è a": "; non è un");
Seriale.println ("punteggiatura mark \ r");
Seriale.print ("funzione ispunct dice: \ r");
Seriale.Stampa (ispunct ('.') ? ". è un": ". non è un");
Seriale.println ("punteggiatura mark \ r");
void loop ()
Produzione
Funzione di carattere isxdigit ()
Nella programmazione Arduino per scegliere i numeri esadecimali il isxdigit () viene utilizzata la funzione del carattere. L'esadecimale contiene simboli da 0 a 9 e alcuni altri simboli alfabetici da a a f. Inoltre, può essere cancellato dal codice di esempio:
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione isxdigit dice: \ r");
Seriale.stampa (isxdigit ('a') ? "A is a": "a non è a");
Seriale.println ("hexadecimal digit \ r");
Seriale.print ("funzione isxdigit dice: \ r");
Seriale.Stampa (isxdigit ('10') ? "10 è un": "10 non è un");
Seriale.println ("hexadecimal digit \ r");
Seriale.print ("funzione isxdigit dice: \ r");
Seriale.stampa (isxdigit ('e') ? "e is a": "e non è a");
Seriale.println ("hexadecimal digit \ r");
Seriale.print ("funzione isxdigit dice: \ r");
Seriale.stampa (isxdigit ('y') ? "y is a": "y non è un");
Seriale.println ("hexadecimal digit \ r");
Seriale.print ("funzione isxdigit dice: \ r");
Seriale.Stampa (isxdigit ('2') ? "2 is a": "2 non è un");
Seriale.println ("hexadecimal digit \ r");
void loop ()
Produzione
funzione di carattere isalpha ()
IL isalpha () La funzione viene utilizzata per identificare le lettere nella programmazione Arduino. Controlla se un personaggio ha una lettera o un numero.
void setup ()
Seriale.Inizia (9600);
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.stampa (isalpha ('a') ? "A is a": "a non è a");
Seriale.println ("lettera \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.Stampa (isalpha ('10') ? "10 è un": "10 non è un");
Seriale.println ("lettera \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.stampa (isalpha ('e') ? "e is a": "e non è a");
Seriale.println ("lettera \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.Stampa (isalpha ('#') ? "# is a": "# non è un");
Seriale.println ("lettera \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.Stampa (isalpha ('d') ? "D is a": "d non è a");
Seriale.println ("lettera \ r");
void loop ()
Produzione
ISASCII () Funzione carattere
Se il numero ASCII di qualsiasi carattere viene utilizzato nel codice questo isascii () La funzione dice se il numero indicato è ascii di un carattere o no.
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione isascii dice: \ r");
Seriale.Stampa (isascii ('$') ? "$ è un": "$ non è un");
Seriale.println ("ascii \ r");
Seriale.print ("funzione isascii dice: \ r");
Seriale.stampa (isascii ('e') ? "E is a": "e non è a");
Seriale.println ("ascii \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.Stampa (isascii ('α') ? "α è un": "α non è un");
Seriale.println ("ascii \ r");
Seriale.stampa ("funzione isalpha dice: \ r");
Seriale.stampa (isascii ('ẟ') ? "ẟ is a": "ẟ non è un");
Seriale.println ("ascii \ r");
void loop ()
Produzione
funzione di carattere iscntrl ()
Per identificare i caratteri di controllo nel codice Arduino come Fine del testo (EOH), fine della trasmissione (EOT), riconoscimento (ACK), backspace (BS), inizio del testo (SOT), inizio di intestazione (SOH) e indagine (indagine (indagine (inchiesta (indagine (SOH (SOH) Enq) il isControl () viene utilizzata la funzione del carattere. Allo stesso modo ciascuno dei personaggi di controllo ha il proprio ASCII. Quindi qui viene utilizzato qui ASCII:
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione iscntrl dice: \ r");
Seriale.print (iscntrl ('\ n') ? "\\ n is a": "\\ n non è un");
Seriale.println ("funzione di controllo \ r");
Seriale.print ("funzione iscntrl dice: \ r");
Seriale.print (iscntrl ('\ t') ? "\\ t is a": "\\ t non è a");
Seriale.println ("funzione di controllo \ r");
Seriale.print ("funzione iscntrl dice: \ r");
Seriale.print (iscntrl ('\ f') ? "\\ f is a": "\\ f non è un");
Seriale.println ("funzione di controllo \ r");
Seriale.print ("funzione iscntrl dice: \ r");
Seriale.print (iscntrl ('\ s') ? "\\ s is a": "\\ s non è un");
Seriale.println ("funzione di controllo \ r");
void loop ()
Produzione
ISPRINT () Funzione del carattere
Nel programma Arduino ci sono alcuni caratteri che non vengono visualizzati sullo schermo o nell'output. Quindi per l'identificazione di tali caratteri isprint () La funzione del carattere viene utilizzata:
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione isprint dice: \ r");
Seriale.Stampa (isprint ('Ø') ? "Ø is a": "Ø non è un");
Seriale.println ("carattere di stampa \ r");
Seriale.print ("funzione isprint dice: \ r");
Seriale.print (isprint ('>') ? "> is a": "> non è un");
Seriale.println ("carattere di stampa \ r");
void loop ()
Produzione
funzione di carattere isalnum ()
Per l'identificazione di entrambe le lettere e numeri la funzione alfanumerica che è isalnum () viene utilizzato nella programmazione Arduino:
void setup ()
Seriale.Inizia (9600);
Seriale.print ("funzione isalnum dice: \ r");
Seriale.Stampa (isalnum ('@') ? "@ is a": "@ non è un");
Seriale.println ("è alpha numerico \ r");
Seriale.print ("funzione isalnum dice: \ r");
Seriale.Stampa (isalnum ('1') ? "'1' è un": "'1' non è un");
Seriale.println ("è alpha numerico \ r");
Seriale.print ("funzione isalnum dice: \ r");
Seriale.stampa (isalnum ('a') ? "A is a": "a non è a");
Seriale.println ("è alpha numerico \ r");
void loop ()
Produzione
funzione di carattere isgraph ()
Questa funzione del personaggio identifica i caratteri stampabili e hanno dei contenuti. Allo stesso modo, se il personaggio ha uno spazio ma non ha alcun contenuto allora il isgraph () La funzione non lo considererà.
char carattere1 = ";
char caratteri2 = 'd';
void setup ()
Seriale.Inizia (9600);
Seriale.println (isgraph (caratteri1));
Seriale.println (isgraph (caratteri2));
void loop ()
Produzione
Conclusione
Per archiviare i valori per i caratteri nella programmazione Arduino, viene utilizzato il tipo di dati dei caratteri. Allo stesso modo, i caratteri usati per eseguire diversi tipi di funzioni. Quindi, per identificare i tipi di caratteri in base alle loro proprietà vengono utilizzate diverse funzioni di carattere. Questo articolo spiega brevemente i diversi tipi di funzioni di carattere utilizzate in Arduino con l'aiuto di esempi.