remote pinetime bot
With Semihosting Log
O Pinetime remoto não está mais em operação. Obrigado a todos por testarem o Pinetime remoto!
O remoto Pinetime é um relógio inteligente Pinetime em Cingapura que está configurado para permitir que qualquer pessoa do mundo pisque e teste o firmware remotamente.
O Bot Pinetime Remote (criado em Rust) observa um grupo de telegrama para comandos piscantes e pisca o firmware para o Pinetime.
A tela no Pinetime é transmitida ao vivo para o YouTube, para que você possa assistir ao seu firmware em execução ao vivo no meu Pinetime.
Para piscar seu próprio firmware e testar o Pinetime, junte -se ao grupo "Pinetime remoto": https://t.me/remotepinetime
O registro piscante (do Openocd) e o log de mensagens de depuração (do semi -host do ARM) serão mostrados no canal "Log Pinetime remoto" aqui: https://t.me/remotepineTimeLog
Assista ao vídeo de demonstração no YouTube
Para exibir um arquivo binário de firmware https://.../firmware.bin to pinetime no endereço 0x0 ...
/flash 0x0 https://.../firmware.bin
Isso funciona para qualquer URL que não seja protegido por login.
Não passe URLs para artefatos criados por ações do GitHub. Eles exigem login e o bot de telegrama será bloqueado.
Em vez disso, copie os artefatos e envie -os em "Lançamentos", que não são protegidos pelo login.
Alguns sabores do firmware do Pinetime requerem um carregador de inicialização, como McUBoot ou SoftDevice. Flash o carregador de inicialização para endereçar 0x0 primeiro e depois pisque o firmware.
O firmware compatível com McUBoot deve ser exibido para abordar 0x8000
Para Flash Breakout no Pinetime ...
/flash 0x0 http://tt-392.space/breakout.hex
Vídeo de demonstração de fuga no Pinetime
Para piscar o rosto de relógio desenhado à mão ...
/flash 0x0 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v5.0.4/mynewt.elf.bin
/flash 0x8000 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v7.0.1/my_sensor_app.img
Mais sobre o rosto de relógio desenhado à mão
Para exibir um firmware infinito "que soprou" modificado que nunca dorme ...
/flash 0x0 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v5.0.4/mynewt.elf.bin
/flash 0x8000 https://github.com/AntonMadness/Pinetime/releases/download/v0.1.1/pinetime-mcuboot-app-img.bin
Isso foi modificado editando src/DisplayApp/DisplayApp.cpp para remover todas as chamadas para case Messages::GoToSleep:
Flash Rust On MyNewt Firmware que emite mensagens de depuração semihosting ...
/flash 0x0 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v5.0.4/mynewt.elf.bin
/flash 0x8000 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v5.0.7/my_sensor_app.img
Para flash ferrugem no tumulto ...
/flash 0x0 https://github.com/lupyuen/pinetime-rust-riot/releases/download/v1.0.3/PineTime.bin
Para Flash McUBoot Bootloader 5.0.4 ...
/flash 0x0 https://github.com/lupyuen/pinetime-rust-mynewt/releases/download/v5.0.4/mynewt.elf.bin
Às vezes, o Pinetime fica trancado devido a erros de firmware. Plassing o McUBoot Booloader acima deve corrigir o bloqueio.
Para construir seu próprio firmware em um navegador da web (sem instalar nenhum IDE ou cadeia de ferramentas), confira os artigos ...
Construa firmware pinetime na nuvem com ações do GitHub
Visualize Pinetime Watch Faces em seu navegador da web com o WebAssembly
Como o pisca parece no telegrama ...
Assista ao vídeo de demonstração no YouTube
Tem perguntas no Pinetime? Converse com a comunidade Pinetime em Matrix / Discord / Telegram / IRC ...
https://wiki.pine64.org/index.php/pinetime#community
Confira meus artigos Pinetime
Porque é difícil e caro enviar hardware real em todo o mundo durante a pandemia ... e o teste remoto de firmware pode ser a solução.
O Pinetime remoto foi criado para permitir que as pessoas aprendam e experimentem a codificação do smartwatch sem ter um smartwatch real.
Confira minha apresentação em vídeo ...
Riot Summit 2020 - Programas mais seguros e mais simples com Rust on Riot
A semi-host do ARM permite que nosso firmware emite mensagens de depuração, invocando o bkpt da instrução ARM Cortex-M.
Confira esta implementação da semi-host do ARM do pinetime-rust-mynewt ...
/// Send an ARM Semihosting command to the debugger, e.g. to print a message.
/// To see the message you need to run opencd:
/// openocd -f interface/stlink-v2.cfg -f target/stm32f1x.cfg -f scripts/debug.ocd
static int __semihost ( int command , void * message ) {
// Warning: This code will trigger a breakpoint and hang unless a debugger is connected.
// That's how ARM Semihosting sends a command to the debugger to print a message.
// This code MUST be disabled on production devices.
__asm(
"mov r0, %[cmd] n"
"mov r1, %[msg] n"
"bkpt #0xAB n"
: // Output operand list: (nothing)
: // Input operand list:
[ cmd ] "r" ( command ),
[ msg ] "r" ( message )
: // Clobbered register list:
"r0" , "r1" , "memory"
);
return 0 ;
} Chamamos __semihost() como assim: semihosting_console.c
/// ARM Semihosting Command
#define SYS_WRITE (0x5)
/// Write "length" number of bytes from "buffer" to the debugger's file handle fh.
/// We set fh=2 to write to the debugger's stderr output.
static int semihost_write ( uint32_t fh , const unsigned char * buffer , unsigned int length ) {
// If debugger is not connected, quit.
if (! debugger_connected ()) { return 0 ; }
if ( length == 0 ) { return 0 ; }
uint32_t args [ 3 ];
args [ 0 ] = ( uint32_t ) fh ;
args [ 1 ] = ( uint32_t ) buffer ;
args [ 2 ] = ( uint32_t ) length ;
return __semihost ( SYS_WRITE , args );
}
/// Return non-zero if debugger is connected. From repos/apache-mynewt-core/hw/mcu/ambiq/apollo2/src/hal_system.c
static int debugger_connected ( void ) {
return CoreDebug -> DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk ;
}Quando chamamos ...
/// Write "hellon" (6 characters) to the debugger's stderr output.
#define SEMIHOST_HANDLE 2
semihost_write ( SEMIHOST_HANDLE , ( const unsigned char * ) "hellon" , 6 ); Veremos a mensagem hello aparecer no Openocd e no Log Pinetime remoto. (As mensagens devem terminar com uma nova linha ou não aparecerão)
A semi -host do ARM precisa ser ativada no Openocd. Veja como o Pinetime remoto permite o semi-host: flash-log.ocd
# Arm Semihosting is used to show debug console output and may only be enabled after the init event.
# We wait for the event and enable Arm Semihosting.
$_TARGETNAME configure -event reset-init {
echo "Enabled ARM Semihosting to show debug output"
arm semihosting enable
}
A semi -host do ARM pode ser lenta ... todo o microcontrolador congela enquanto a mensagem de depuração é transmitida pelo caractere por caractere para o Openocd através da porta SWD.
Recomendamos o uso de uma matriz estática para amortecer as mensagens de saída na memória.
Na implementação do semi pinetime-rust-mynewt host do ARM, usamos o MyNewt MBUFs para buffer as mensagens com eficiência.
Não use a semi -host do ARM quando o processamento do Bluetooth LE estiver em andamento ... as mensagens serão descartadas e os clientes do Bluetooth LE se desconectarão automaticamente.
A semi -host do ARM deve ser desativada no firmware de produção. Além disso, a semi -host do ARM pode pendurar quando um depurador Jlink está conectado. Para pinetime-rust-mynewt desabilitamos o semi-host com o GCC FLAG -DDISABLE_SEMIHOSTING em targets/nrf52_boot/pkg.yml (para o McUBoot Bootloader) e na Firmware de Application targets/nrf52_my_sensor/pkg.yml (para o aplicativo).
Para criar seu próprio Bot Telegram ...
Converse com Botfather, crie um bot chamado PineTime Bot
Digite /mybots , selecione PineTime Bot
Selecione Edit Commands , digite flash - flash 0x0 https://.../firmware.bin
Para executar seu próprio telegrama: clone este repositório e execute isso em um script de shell ...
# Set your Telegram Bot Token
export TELEGRAM_BOT_TOKEN= ???
# This is needed to fix the h2 / indexmap build error "ids: IndexMap<StreamId, SlabIndex> expected 3 type arguments"
export CARGO_FEATURE_STD=1
# Show Rust stack trace
export RUST_BACKTRACE=1
cd ~ /remote-pinetime-bot
for (( ; ; ))
do
git pull
pkill openocd
cargo run
echo " ---------ERROR-------- "
sleep 30
doneO Telegram Bot chama Pinetime Updater e Xpack Openocd para Flash Firmware para Pinetime via SWD.
Para baixar o xpack openocd (para Mac) ou o Openocd SPI (para Raspberry Pi), veja o pinetime-updater/run.sh
O Bot Telegram está atualmente em execução no Raspberry Pi com o XPACK Openocd (em vez do Openocd SPI). Xpack Openocd para Raspbian de 32 bits foi baixado daqui
O motorista USB para St-Link foi configurado em Raspbian como So ...
# For Linux Only: Install UDEV Rules according to https://xpack.github.io/openocd/install/#udev
sudo cp xpack-openocd/contrib/60-openocd.rules /etc/udev/rules.d/
sudo udevadm control --reload-rulesPara transmitir ao vivo sua câmera Raspberry Pi para o YouTube: execute isso em um script de shell ...
for (( ; ; ))
do
raspivid -n -o - -t 0 -vf -hf -fps 30 -b 6000000 |
ffmpeg -re -ar 44100 -ac 2
-acodec pcm_s16le -f s16le -ac 2
-i /dev/zero -f h264 -i - -vcodec copy -acodec aac -ab 128k -g 50 -strict experimental
-f flv rtmp://a.rtmp.youtube.com/live2/YOUR_YOUTUBE_STREAM_KEY
sleep 1
doneBaseado em https://www.makeuseof.com/tag/live-stream-youtube-rupberry-pi/
Use uma conexão de rede com fio em vez de Wi -Fi ... porque ativar o forno de microondas interromperá a rede Wi -Fi de 2,4 GHz e encerrará sua transmissão ao vivo do YouTube. (E seu URL ao vivo do YouTube mudará)
Aqui está a configuração de transmissão ao vivo com (esquerda para a direita) Raspberry Pi 4, módulo de câmera Raspberry Pi V2 (8 MP), dois copos de lupa, Pinetime com pinos de Pogo (ponta afiada) e ST-link V2 ...
Cubra com um gabinete de papel machê para bloquear a reflexão sobre os copos de lupa (como um telescópio) ...
Como fazer o gabinete Papier-Moché ...
Posicione o Raspberry Pi, o módulo de câmera, dois copos de lupa e o Pinetime
Construa um andaime descansando um envelope no Raspberry Pi, módulo de câmera e lupa
Complete o andaime colocando um pedaço dobrado de papel do tamanho A4
Pasta tiras de papel toalha no andaime, certifique -se de cobrir o Raspbery Pi. Criei a pasta misturando meia xícara de farinha com meia xícara de água.
Deixe o papier-maché secar durante a noite para formar a forma do recinto. Apare o papier-maché com tesoura. Microondas o papier-maché para secar.
Cole uma segunda camada de toalhas de papel, de maneira ordenada.
Microondas o papier-maché por um minuto, deixe esfriar. Use tigelas derrubadas para apoiar a estrutura. Repita 3 vezes até que o Papier-Moché esteja seco.
Apare o gabinete Papier-Moché com tesoura.
Existem problemas de segurança expondo um bot de telegrama ao mundo para piscando e testando?
Mitigamos os riscos de segurança o máximo possível ...
Nosso bot de telegrama é construído com ferrugem, uma linguagem de programação de sistemas seguros.
Confira o código -fonte da ferrugem em src/main.rs
Nenhum acesso remoto ao host é permitido. O BOT do Telegram apenas pesquisou comandos /flash e os executa.
Os arquivos temporários são excluídos automaticamente após o uso com a biblioteca tempfile . Por isso, reduzimos a exposição de arquivos com malware.
Mas há uma preocupação ... nosso Pinetime pode ser exibido com malware que ataca outros dispositivos Bluetooth nas proximidades.
Por uma questão de educação da IoT ... eu vou permitir! :-)
Estou plenamente ciente dos riscos quando operar esse serviço gratuito. E se você optar por operar seu próprio Pinetime remoto, também estará ciente dos riscos.
Há uma questão de segurança séria em relação ao suporte semi -host: a API semi -host suporta a leitura, a escrita e a execução de arquivos no host Openocd (Raspberry Pi).
Esse problema de segurança não foi resolvido. A solução alternativa é desativar o suporte semi -host no Openocd, o que também desativaria as mensagens de depuração.
Escreva o log de depuração semihosting para um canal de telegrama separado
Brechar o número de mensagens semi -host que serão registradas no canal do Telegram (agrega e transmite as mensagens como uma única solicitação de telegrama a cada 5 segundos)
Permita o log de depuração semihosting e o firmware piscando para coexistir (ambos usam o Openocd)
