Benvenuti!
Questo tutorial vi fornirà una panoramica sul funzionamento delle BOT API di Telegram e su come poter sfruttare il servizio di messaggistica istantanea stesso per controllare da remoto il vostro raspberry pi zero o zero w (qui trovate tutti i miei focus sui dispositivi).
Nota: il presente articolo contiene una infarinatura generale ed alcuni dettagli sono stati tralasciati. Se volete approfondire, non esitate a lasciare un commento o a contattarmi sui canali social.
Prima di addentrarci, vi riporto il video di supporto a questa guida che ho pubblicato sul mio canale YouTube:
Inoltre vi segnalo che nella pagina dedicata troverete tutti i tutorial da me pubblicati.
1. l'attrezzatura minima per iniziare
Per gestire un BOT Telegram o per sfruttarlo da remoto occorrono:
- un raspberry pi zero (o un qualsiasi altro single board computer o PC) + una microSD + un alimentatore (da almeno 2A)
- un PC o smartphone o tablet
- Raspbian OS
- una connessione ad internet + un router
Per quanto riguarda il primo punto non occorre altro: il raspberry pi zero sarà acceduto sempre da remoto e sarà autonomo nelle sue attività, quindi non sarà necessario utilizzare alcuna periferica collegata al pi. Sarà invece indispensabile avere un alimentatore che eroghi in uscita almeno 2A.
Per l'utilizzo finale sfrutteremo come detto il raspberry pi a mo' di server e ci fornirà servizi tramite la piattaforma Telegram a cui noi accederemo con client dedicati installati su PC, smartphone o tablet.
Serve commentare il quarto punto (=D)?
2. Telegram ed i BOT
Telegram è un sistema di messaggistica istantanea che offre diverse possibilità di utilizzo e permette di estendere le sue funzionalità base tramite i BOT. Un bot è -fondamentalmente- un programma in esecuzione su un computer remoto che può partecipare alle chat ed è capace di rispondere a determinati comandi richiamabili in modo diretto o indiretto.
La parte client di Telegram, poi, è aperta ed esistono una infinità di tool che permettono di collegarsi al sistema, tra cui quelli utilizzabili via linea di comando il che è interessante poiché ci dà la possibilità di fare alcune cosette sfiziose ed utili (e che vedremo nel prossimo paragrafo).
Creare un bot per Telegram non è una cosa complicata, la difficoltà è più che altro relativa a ciò che si vuole far fare allo stesso, quindi tutta quella parte di logica che va oltre al semplice accettare comandi e comunicare una risposta agli stessi. Telegram offre delle API ufficiali ben documentate che spiegano come far interagire correttamente il nostro software con gli altri utenti e come spedire indietro ad essi le informazioni desiderate. Dalla semplice gestione delle richieste a come costruire le interfacce di risposta e all'edit dei messaggi, dall'uso degli stickers ai pagamenti ed ai giochi, e quant'altro: tutto è documentato puntualmente.
Nota: Prima di continuare è bene sapere che esistono delle librerie di terze parti che integrano tutte le API e facilitano enormemente la creazione di bot, e ne esistono praticamente per ogni linguaggio: da Java a PHP, da node.js/JavaScript a python, eccetera. Lo scopo di questo tutorial, però, è quello di cercare di spiegare il funzionamento che c'è alla base di un bot, cosa occorre fare per svilupparne uno da zero e soprattutto capirne la logica generale. Una volta padroni dei vari concetti, creare un bot più complesso sarà gioco da ragazzi sia scrivendo tutto il codice necessario da zero sia integrando una delle tante librerie pronte all'uso, in base alle proprie esigenze.
Il primo passo fondamentale è quello di creare un nuovo bot sulla piattaforma Telegram. Per far ciò esiste un apposito tool chiamato BotFather che ha proprio lo scopo di instanziare nuovi bot e gestirne le impostazioni: è un bot a sua volta e si contatta direttamente via Telegram (il suo username è @botfather).
A questo punto potrete richiedere la creazione di un nuovo bot e dovrete decidere un nome ed uno username da associare alla vostra creatura. BotFather creerà per voi un token identificativo che è il fulcro di tutto visto che è indispensabile per autorizzare il bot stesso e soprattutto accedere alle API che permettono di animarlo. Una volta ottenuto il token, potrete iniziare a giocare con le API: potete contattare il vostro bot direttamente via Telegram, come un qualsiasi altro utente, ed anche invitarlo in chat di gruppo, basterà cercarlo tramite lo username da voi impostato.
Esistono due approcci per creare la logica che c'è dietro ad un bot: in modalità pull o in modalità push. La prima prevede la creazione di un'applicazione che, via "long polling", richieda tutti gli aggiornamenti intercorsi in un dato intervallo di tempo: i server Telegram risponderanno con tutto ciò che è accaduto in quell'arco temporale con un'unica grande struttura dati; la seconda modalità, al contrario, prevede la creazione di un servizio remoto che possa essere richiamato in automatico dai server Telegram ogni qualvolta ci sia una nuova richiesta per lui.
Ci sono pro e contro nello scegliere l'uno o l'altro approccio:
- il "long polling" (o come è chiamato sulle API di Telegram: getUpdates) permette di controllare il flusso di messaggi in entrata, i tempi di attività del nostro bot e quant'altro: saremo noi a decidere quando richiedere e cosa richiedere di volta in volta; ma ovviamente il nostro bot non potrà essere "immediato" nel fornire le risposte agli utenti
- l'approccio "push" (o come è chiamato sulle API: webhooks) al contrario, essendo automaticamente sollecitato dall'esterno non appena si verifichi un evento, è in grado di rispondere in modo più reattivo e non prevede continue richieste da parte della nostra applicazione per sapere se c'è qualcosa da analizzare per rispondere agli utenti; ovviamente per tirar su un sistema del genere è necessaria una configurazione molto più complessa e, per forza di cose, che essa sia necessariamente più performante: visto che il nostro bot sarà bombardato di richieste dai server Telegram, sarà necessario carrozzare l'architettura a dovere...
Nota: indipendentemente dalla scelta di uno o dell'altro metodo, i server Telegram permettono ai bot l'accesso a messaggi non più vecchi di 24 ore, e tutti gli scambi di dati tra utenti e bot stessi (e viceversa) avvengono solo via API ed in formato JSON.
ESEMPIO
Per capire come funzioni tutto il giro prendiamo in esame l'approccio del "long polling": il bot dovrà effettuare le sue richieste alla URL centralizzata https://api.telegram.org/bot seguito dal token di autorizzazione generato dal BotFather, / il nome del metodo che si vuole richiamare.
Ad esempio: https://api.telegram.org/bot«TOKEN»/getMe
Questo comando non fa molto altro se non farci ottenere alcune informazioni generiche sul bot stesso ed è sicuramente un ottimo modo per verificare che la comunicazione tra il nostro software ed i server Telegram funzioni correttamente.
Per facilità prendiamo in esempio del codice dimostrativo scritto in PHP il quale è facilmente richiamabile via browser o via riga di comando in esecuzione sul raspberry pi zero (per maggiori dettagli rimando al mio tutorial su come creare un server web su raspberry pi 3). I server Telegram accettano richieste in POST o in GET (come detto in formato JSON) e si potrà sfruttare cURL per eseguirle.
L'idea è quella di centralizzare la generazione delle nostre richieste e l'analisi delle risposte fornite dalle BOT API con due funzioni: esse si occuperanno di volta in volta di creare in modo corretto con tutti i parametri necessari per lo specifico metodo le nostre richieste ai server Telegram (e spedire il tutto via cURL alla URL delle BOT API), e di spacchettare ed analizzare quanto ottenuto in risposta.
Telegram risponderà con un messaggio a sua volta in formato JSON e strutturato così da avere sempre un response code, eventuali campi opzionali specifici per la data richiesta e, cosa ovviamente più importante di tutte, il risultato dell'operazione.
Di seguito il codice di esempio che invia richieste in GET ai server Telegram:
/**
* apiRequest
* esegue una richiesta API via GET
* @param $method
* @param $parameters
* @returns boolean
*/
function apiRequest($method, $parameters) {
if (!is_string($method)) {
error_log("Il nome del metodo deve essere una stringa\n");
return false;
}
if (!$parameters) {
$parameters = array();
} else if (!is_array($parameters)) {
error_log("I parametri devono essere in un array\n");
return false;
}
error_log("apiRequest: " . json_encode($parameters) . "\n");
// encoding to JSON array parameters, for example reply_markup
foreach ($parameters as $key => &$val) {
if (!is_numeric($val) && !is_string($val)) {
$val = json_encode($val);
}
}
$url = API_URL . $method . '?' . http_build_query($parameters);
error_log("apiRequest: " . $url . "\n");
// execute cURL
$handle = curl_init($url);
curl_setopt($handle, CURLOPT_PROXY, PROXY);
curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handle, CURLOPT_CONNECTTIMEOUT, 5);
curl_setopt($handle, CURLOPT_TIMEOUT, 60);
return exec_curl_request($handle);
}
In grassetto sono sottolineati i punti salienti: la codifica in formato JSON dei parametri da inviare, la costruzione della URL generica con in GET i parametri della data richiesta, ed infine l'inizializzazione della cURL.
Di seguito il codice di esempio che analizza la risposta fornita dai server Telegram:
/**
* exec_curl_request
* completa l'esecuzione della richiesta cURL e analizza la risposta
* @params cURL $handle ritornato dalla cURL init
* @returns {false} se la cURL fallisce oppure la json_decode della $response
*/
function exec_curl_request($handle) {
// execute cURL and verify response
$response = curl_exec($handle);
error_log("exec_curl_request: " . json_encode($response) . "\n");
if ($response === false) {
$errno = curl_errno($handle);
$error = curl_error($handle);
error_log("La cURL ha tornato l'errore $errno: $error\n");
curl_close($handle);
return false;
}
// retrieve http_code
$http_code = intval(curl_getinfo($handle, CURLINFO_HTTP_CODE));
curl_close($handle);
error_log("exec_curl_request: " . $http_code . "\n");
// check http_code
if ($http_code >= 500) {
// do not wat to DDOS server if something goes wrong
sleep(10);
return false;
} else if ($http_code != 200) {
$response = json_decode($response, true);
error_log("La richiesta e' fallita con l'errore " .
"{$response['error_code']}: {$response['description']}\n");
if ($http_code == 401) {
throw new Exception('Access token fornito non valido');
}
return false;
} else {
$response = json_decode($response, true);
if (!$response['ok']) {
error_log("La richiesta ha restituito l'errore " .
"{$response['error_code']} - {$response['description']}\n");
return false;
}
if (isset($response['description'])) {
error_log("Richiesta effettuata con successo: ".
"{$response['error_code']} - {$response['description']}\n");
}
$response = $response['result'];
}
error_log("exec_curl_request: " . json_encode($response) . "\n");
return $response;
}
In grassetto sono sottolineati i punti salienti: l'esecuzione del comando cURL e la ricezione della risposta dai server Telegram, il controllo sullo status relativo alla risposta, la decodifica dal formato JSON dei dati ottenuti che alla fine saranno contenuti nella chiave "result" del response array.
Nota: questo è il funzionamento generale per ogni richiesta che il nostro software farà e relativa risposta dai server Telegram. La chiave di tutto è il token che permette di identificare univocamente il nostro bot e tramite cui i server Telegram sono in grado di spedirci i comandi, i messaggi e quant'altro.
Quando configuriamo il nostro bot e le richieste che il nostro software fa verso i server di Telegram specificheremo anche la tipologia di messaggi e dati che vogliamo avere, i tempi di attesa e quanto essere "stressati" dalle richieste. Insomma c'è da bilanciare un po' di parametri per avere un funzionamento adeguato in base alle nostre esigenze.
Una volta ottenuta la risposta dai server Telegram, dovremo analizzare il contenuto di ogni messaggio ricevuto per decidere cosa fare. Di seguito il codice di esempio che analizza un singolo messaggio scritto in chat dall'utente, al quale il nostro bot risponderà coerentemente:
/**
* processMessage
* processa lo specifico messaggio
* @param $message
* @returns void
*/
function processMessage($message) {
// process incoming message
$message_id = $message['message_id'];
$chat_id = $message['chat']['id'];
error_log("processMessage: " . json_encode($message) . "\n");
if (isset($message['text'])) {
// incoming text message
$text = $message['text'];
error_log("processMessage: " . $text . "\n");
if (strpos($text, "/start") === 0) {
apiRequestJson("sendMessage", array(
'chat_id' => $chat_id,
"text" => 'Si inizia!',
'reply_markup' => array(
'keyboard' => array(
array(
'Ciao',
'Ehi!'
)
),
'one_time_keyboard' => true,
'resize_keyboard' => true
)
));
} else if ($text === "Ciao" || $text === "Ehi!") {
apiRequest("sendMessage", array(
'chat_id' => $chat_id,
"text" => 'Piacere di conoscerti!'
));
} else if (strpos($text, "/stop") === 0) {
apiRequest("sendMessage", array(
'chat_id' => $chat_id,
"text" => 'Alla prossima, ciao!'
));
} else {
/*apiRequestWebhook("sendMessage", array(
'chat_id' => $chat_id,
"reply_to_message_id" => $message_id,
"text" => 'Fico!'
));*/
apiRequest("sendMessage", array(
'chat_id' => $chat_id,
"text" => 'Fico!'
));
}
} else {
apiRequest("sendMessage", array(
'chat_id' => $chat_id,
"text" => 'Mi dispiace, capisco solo messaggi di testo...'
));
}
}
In grassetto sono sottolineati i punti salienti: il bot risponderà alla specifica chat e allo specifico messaggio, ma in questo caso lo farà soltanto se 1] il messaggio di richiesta ricevuto sia testuale (verranno scartati file, emoticon e quant'altro), 2] il testo scritto sia "/start", "Ciao, "Ehi!" o "/stop": qualsiasi altra parola o frase produrrà un generico messaggio di errore.
Da notare le due tipologie di invio di risposta: apiRequest e apiRequestJson. La prima è la funzione riportata poco sopra che sfrutta cURL via GET, la seconda è analoga (e riportata subito di seguito) che sfrutta cURL in POST. Da notare, inoltre, la possibilità di specificare del codice markup [reply_markup] di risposta (in questo caso utilizzato per impostare la keyboard, la tastiera, per l'utente: essa avrà già due bottoni pronti alla pressione con alcuni comandi preimpostati). Tutte le impostazioni relative alla personalizzazione delle risposte e varie possibilità di utilizzo sono ben riportate sulla documentazione ufficiale delle API.
/**
* apiRequestJson
* esegue una richiesta API via POST
* @param $method
* @param $parameters
* @returns boolean
*/
function apiRequestJson($method, $parameters) {
if (!is_string($method)) {
error_log("Il nome del metodo deve essere una stringa\n");
return false;
}
if (!$parameters) {
$parameters = array();
} else if (!is_array($parameters)) {
error_log("I parametri devono essere in un array\n");
return false;
}
$parameters["method"] = $method;
error_log("apiRequestJson: " . json_encode($parameters) . "\n");
// execute cURL
$handle = curl_init(API_URL);
curl_setopt($handle, CURLOPT_PROXY, PROXY);
curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handle, CURLOPT_CONNECTTIMEOUT, 5);
curl_setopt($handle, CURLOPT_TIMEOUT, 60);
curl_setopt($handle, CURLOPT_POSTFIELDS, json_encode($parameters));
curl_setopt($handle, CURLOPT_HTTPHEADER, array(
"Content-Type: application/json"
));
return exec_curl_request($handle);
}
Come detto in precedenza, i server Telegram accettano due modalità di interazione: pull e push. Il primo caso prevede che venga richiamato il metodo getUpdates che è il comando per ottenere tutti i messaggi scritti dagli utenti intercorsi in un certo intervallo di tempo. Se non si specifica alcun parametro si riceveranno tutti i messaggi delle ultime 24 ore in blocchi di massimo 100 alla volta. Tali messaggi andranno analizzati uno per uno così da andare a cercare informazioni sensibili di nostro interesse. Ad esempio il nostro bot controllerà la presenze della parole "/start", "Ciao", "Ehi!" o "/stop" e a tutto il resto risponderà con un generico messaggio, ignorando upload di files ed altre azioni che non siano messaggi testuali.
Di seguito il codice di esempio che scatena la ricerca di aggiornamenti (pull) o che risponde alle sollecitazioni dei server Telegram (push):
define('BOT_TOKEN', '«il TOKEN generato dal @BotFather»');
define('API_URL', 'https://api.telegram.org/bot' . BOT_TOKEN . '/');
define('WEBHOOK_URL', '«la URL su cui è presente il codice del vostro bot»');
define('PROXY', '«eventuale PROXY se necessario»');
/**
* EXECUTION via PULL (codice alternativo a quello PUSH)
*/
error_log("Analyzing..." . "\n");
if (($stream = apiRequest("getUpdates", array("timeout" => 30)))) {
analyze($stream);
}
/**
* EXECUTION via PUSH (codice alternativo a quello PULL)
*/
// if run from console, set or delete webhook
if (php_sapi_name() == 'cli') {
apiRequest('setWebhook', array('url'
=> isset($argv[1]) && $argv[1] == 'delete' ? '' : WEBHOOK_URL));
exit;
}
// if run from web
else {
while (true) {
error_log("Analyzing..." . "\n");
$content = file_get_contents("php://input");
$update = json_decode($content, true);
analyze($update);
}
}
/**
* analyze
* analizza gli update ricevuti
* @params $update
* @returns void
*/
function analyze($update) {
error_log("analyze: " . json_encode($update) . "\n");
if (!$update) {
// receive wrong update, must not happen
echo "Ricevuto un update non valido, non accade nulla";
}
else {
for ($i = 0; $i < sizeof($update); $i++) {
if (isset($update[$i]) && isset($update[$i]["message"])) {
// good udpate, check it
processMessage($update[$i]["message"]);
}
}
}
}
In grassetto sono sottolineati i punti salienti: la chiamata alla getUpdates nel caso della pull, oppure la registrazione della webhook (al primo avvio del bot via riga di comando) con l'analisi della richiesta ottenuta in automatico via push dai server Telegram. In ogni caso, una volta ottenuta risposta dai server Telegram si entra nello stesso giro di analisi dei messaggi ricevuti.
L'idea del "pull" è che l'utente scriva in una chat dove c'è anche il nostro bot; che ogni tot di tempo venga eseguito il comando getUpdates dal nostro software il quale intercetterà tutti i messaggi (ed è importante che il nostro software memorizzi il timestamp relativo all'ultimo messaggio ricevuto così da evitare di ricevere duplicati nelle chiamate successive); quindi che vengano analizzati uno per uno tutti i messaggi ricevuti dalla getUpdates, elaborati e spedite indietro le risposte. Tutto il giro avviene sempre tramite BOT API in JSON con chiamate GET o POST.
Per quanto riguarda l'approccio "push", invece, l'idea è che venga configurato un servizio ad-hoc, registrato sui server Telegram come webhook affinché essi possano richiamarlo all'occorrenza (con lo specifico comando setWebhook visto poc'anzi e ben documentato sulla documentazione ufficiale delle BOT API). La guida ufficiale completa spiega come configurare un servizio remoto per mettere in piedi un bot che risponda via push: sì, perché a differenza del "long polling / pull", che può essere scatenato da un qualsiasi software in esecuzione un po' dove vogliamo, il sistema "webhook" richiede che la nostra applicazione sia raggiungibile tramite una URL e che il server che risponda a quella URL accetti chiamate in entrata dai server Telegram. Insomma, ci sono un po' di configurazioni da fare ed inoltre se volete tenere il bot sul vostro raspberry pi dovrete essere sicuri che esso possa essere acceduto via URL dall'esterno, quindi che il vostro router redirezioni correttamente le richieste in entrata su di lui. Una volta configurato il tutto, il funzionamento tra pull e push è pressoché identico e l'unica differenza sarà che, anziché richiedere le informazioni manualmente via getUpdates, il bot verrà automaticamente richiamato dai server Telegram (e, nel caso del codice demo scritto in PHP, i dati saranno presenti nello stream "php://input" il quale dovrà essere decodificato essendo in JSON ed inserito nel giro di analisi descritto in precedenza).
3. Telegram e l'interfaccia a linea di comando
Le funzionalità di Telegram possono essere estese con i bot, ma è anche vero che di client per l'accesso al sistema ne esistono tantissimi, e ce ne è qualcuno che può essere lanciato da linea di comando, il che apre alcuni scenari molto interessanti.
Ad esempio, il client Telegram CLI (scaricabile da github) non solo permette di farci autenticare su Telegram via riga di comando e quindi usarlo in modalità testuale, ma soprattutto esso accetta in avvio script che permettono di estenderne le funzionalità: capirete quindi che sarà possibile far compiere azioni particolari al raspberry pi direttamente via chat!
I seguenti passi permetto di installare Telegram CLI sul raspberry pi zero:
- clonare il codice sorgente da github con il comando git clone --recursive https://github.com/vysheng/tg.git && cd tg
- installare le librerie di supporto dai repository di Raspbian OS, con il comando sudo apt-get install libreadline-dev libconfig-dev libssl-dev lua5.2 liblua5.2-dev libevent-dev libjansson-dev libpython-dev make
- compilare il tutto con i comandi ./configure e poi make, occhio ad eventuali errori di dipendenze durante il configure!
- pazientare per un po' di tempo (anche una mezz'ora) finché il gioco sarà fatto!
Una volta terminata la compilazione sarà possibile utilizzare Telegram CLI esattamente come un qualsiasi altro client Telegram via terminale: al primo avvio ci sarà richiesto il numero di telefono associato al nostro account Telegram a cui verrà spedito il codice di conferma, e a quel punto saremo autenticati e potremo utilizzare tutti i comandi tipici della piattaforma (basta premere due volte il tasto TAB per vedere la lista di tutti quelli a disposizione).
Ad esempio, digitando msg @<vostronickname> "messaggio di test!" e premendo invio dovreste riuscire ad auto inviarvi quello specifico messaggio!
Aldilà di ciò, comunque, la cosa molto interessante è -come anticipato- la possibilità di avviare uno script alla sua esecuzione. Il client accetta script in LUA, linguaggio di programmazione decisamente semplice da utilizzare. E quello qui di seguito riportato è un semplicissimo pezzo di codice d'esempio che non fa altro che controllare tutti i messaggi/comandi digitati in chat per poi eseguirli sul raspberry pi, restituendoci l'output:
function on_msg_receive (msg)
if started == 0 then
return
end
if (msg.from.phone==vostro numero di telefono) then
if msg.out then
return
end
if (msg.text~='') then
local handle = io.popen(msg.text)
local result = handle:read("*a")
handle:close()
send_msg (msg.from.print_name, result, ok_cb, false)
end
end
return
end
In grassetto sono sottolineati i punti salienti: visto che andremo a chattare con voi stessi, o comunque con l'utente con il quale vi siete autenticati sul raspberry pi, lo script dovrà verificare che i messaggi non siano quelli scritti in chat dal pi stesso e soprattutto di non accettare messaggi che non siano stati inviati da voi. Per il resto, lo script non farà altro che eseguire sul sistema quanto presente nel messaggio.
Per lanciare Telegram CLI con tanto di script lua, da terminale dalla cartella in cui avete installato telegram-cli stesso digitate il seguente comando bin/telegram-cli -k tg-server.pub -W -s script.lua, dove tg-sever.pub è la chiave pubblica associata all'utente e generata automaticamente dopo il primo login (quello in cui avete inserito il numero di telefono per autenticarvi), e script.lua è il file contenenete i comandi mostrati in precedenza.
L'idea è quindi quella di sfruttare un qualsiasi altro client Telegram (ad esempio dal telefonino, oppure via PC) per chattare con voi stessi (vi potete trovare semplicemente cercando il vostro username), digitando comandi ed ottenendo risposte ad essi dal raspberry pi.
Ad esempio: digitando ls ~ avrete un listato dei file presenti nella home del pi, oppure digitando un qualsiasi altro comando possa venirvi in mente ne vedrete l'output direttamente via messaggio su Telegram. Ovviamente tutto è relativo all'utente con il quale avete lanciato telegram-cli sul pi, quindi alcuni comandi potranno essere eseguiti oppure no in base ai permessi che l'utente stesso ha sul sistema.
A questo punto potrete controllare direttamente via Telegram il vostro raspberry pi e lanciare tool, programmi, controllare lo stato di determinati servizi e così via... Le possibilità sono infinite!
4. conclusioni e ultime note
Quelle descritte sono due possibilità per sfruttare Telegram a 360° sul raspberry pi zero, cioè creare un bot per interagire con i più disparati utenti in chat singole o di gruppo, oppure sfruttare telegram-cli per prendere il controllo del vostro single board computer da remoto. I due sistemi sono per molti versi sovrapponibili tra loro: il primo è il metodo ufficiale con tanto di API documentate e supporto, il secondo -forse- è un po' più "casereccio" ma altrettanto interessante.
I consumi ridotti dei single board computer della fondazione inglese, la possibilità di utilizzarli come hub per domotica ed IoT, e la loro versatilità fan sì che possa aver davvero senso impiegarli ed impiegare Telegram per costruire sistemi automatici che rispondano a semplici comandi inviati via messaggi istantanei.
Bene: come indicato ad inizio guida, alcuni aspetti sono stati appositamente lasciati in secondo piano, ma se siete interessati ad approfondirli non esitate a contattarmi nei commenti di questo tutorial o del video ad esso correlato, oppure sui canali social!
Spero che la guida vi sia stata utile. Al prossimo tutorial!
Nessun commento:
Posta un commento