Eletrônica

Receptor FM de Conversão Direta

Este receptor eu montei a alguns anos e gostei muito de sua performance. Muito melhor que os famosos Super-Regenerativos com BF494 que se acha por ai aos montes. A recepção é muito boa, capta estações com boa potência, tem boa seletividade e fácil sintonia.

Eu fiz somente a parte de RF até o capacitor de 680nF. O amplificador de áudio eu usei um LM386 que já tinha montado.

Também tive que converter o circuito de transistores PNP para NPN (diferente do esquema abaixo).

Este circuito é uma aula de RF. Veja que L1 desvia para GND sinais de baixa frequência ( eu apenas enrolei algumas 10 espiras em um lápis) e o capacitor 68pF deixa somente os sinais de alta frequência passar.

O primeiro transistor é o pré-amplificador de sinal da antena. Os dois de baixo o oscilador minimalista que gera a frequência que será misturada. Alias a mistura é feita de forma que não costumo ver. Ainda não decidi se a mistura é feita no emissor do primeiro transistor ou na base do segundo.

fm-receiver-circuit-diagram

A imagem é deste site. Porém duvido que seja deles pois já vi este circuito em vários lugares e inclusive em algum deles tinha achado o autor dele que era um PY, mas não anotei.

 

Seleção de utilidades para o hobby eletrônico no AliExpress

Sabe aqueles vídeos ou fotos de pessoas que realizam diversas montagens nos protoboards com aqueles fios bonitinhos, usando aqueles módulos pequenos e úteis ou placas padrão? Então. Lembro-me que achava que nunca conseguiria ter tudo aquilo. Porém depois de descobrir o AliExpress lá atrás devagar fui comprando pequenas utilidades sem gastar mais que R$ 50,00 por entrega (já que algumas levam algumas semanas para chegar). Se eu tivesse comprado no Brasil estaria perdido, falido esta hora.

Então segue um lista que acho útil e talvez você não conseguiu achar por não saber os nomes.

 

male-to-male-color-breadboard-cable-jump-wire-font-b-jumper-b-font-for-font-b_220x220 free-shipping-straight-curve-font-b-tweezers-b-font-eyelash-extension-tool-eyelash-makeup-beauty-stainless_220x220 usb-font-b-logic-b-font-font-b-analyzer-b-font-100m-max-sample-rate-16channels_220x220

Três ferramentas de extrema utilidade. 40 Fios com terminais por U$ 2,40. Pinças de boa qualidade. E um analisador lógico indispensável para depurar saidas de MCUs. Checar 6 canais de PWM sem um destes é loucura…

2015-new-mb102-power-supply-module-3-3v-5v-breadboard-board-830-point-65pcs-font-b_220x220

Os pacotes se bem achados são muito econômicos. E esse é o grande diferencial do AliExpress. Isto tudo ai sai por somente U$ 5,60. O módulo de fonte pode ser alimentado por USB ou a fonte de 9V do Arduino. Tem LED, 3.3v/5v e chave liga-desliga. O módulo foi feito para se encaixar perfeitamente no protoboard.

with-the-bootloader-font-b-nano-b-font-3-0-controller-compatible-for-font-b-arduino_220x220

Por menos de U$ 3,00 você leva esse Arduino Nano e pode transformá-lo em gravador ISP e conectar direto na protoboard. Tem a mesma capacidade dos Arduinos normais porém menor e prático.

20pcs-5x7-4x6-3x7-2x8-cm-double-side-copper-prototype-font-b-pcb-b-font-font_220x2201 qfn-tqfp-font-b-lqfp-b-font-qfp-16-80-pin-0-5mm-pitch-to-dip_220x220

Uma hora um projeto tem que ficar definitivo. E estas placas ajudam muito. Feitas em fibras são ótimas. Também as adaptadoras de CIs SMDs são extremamente úteis.

1pcs-usb-to-font-b-ttl-b-font-uart-module-ch340g-ch340-3-3v-5v-font_220x220

Úteis para qualquer desenvolvedor para MCUs. Estes módulos de comunicação serial também servem para alimentação 3.3.V/5V baixa corrente. Ligue o terra o positivo e RX com TX e pronto você tem uma forma de debugar seus programas. Compre uns 5 desses porque qualquer besteira sua e adeus módulo.

ac-100v-240v-converter-adapter-dc-9v-1a-font-b-power-b-font-font-b-supply_220x220 new-high-quality-5v-2a-v8-us-micro-usb-charger-charging-adapter-font-b-power-b_220x220

Seleção de fontes. A primeira de 9V para o Arduino e a ultima para o Raspberry Pi com 5V/2A.

free-shippin-5pcs-lot-font-b-atmega328p-b-font-pu-font-b-atmega328p-b-font-dip_220x220 the-original-5pcs-font-b-attiny85-b-font-20pu-font-b-attiny85-b-font-20pu-font_220x220 1pcs-stm32f103c8t6-arm-font-b-stm32-b-font-minimum-system-development-board-module-for-arduino_220x220

Quanto é um ATMEGA328P no Brasil? Que tal pelo mesmo preço comprar 5? E o Attiny85? E por ultimo os STM32 são uma boa pedida para começar a programar para ARM e arquiteturas 32 bits. Todos sem dúvida irão precisar de um gravador.  No caso dos Atmel o Arduino Nano já mostrado acima serve. Para o STM32 o STLINK pelo mesmo preço grava STM8 e STM32.

 

Bom espero que tenha sido útil. Montar uma bancada aos poucos com diversos CIs equipamentos vai lhe trazer um diferencial no desenvolvimento, aprendizado rico e economizar muita grana se tiver paciência e comprar na China. Agora o AliExpress aceita pagamentos por Boleto facilitando para os jovens sem conta em banco.

O meu carrinho vive cheio de coisas no site. É uma perdição.

 

A era de ouro das revistas de eletrônica

Quando era adolescente juntava todo mês algumas moedas para comprar revistas de eletrônica. Minhas preferidas eram a Aprendendo e Praticando Eletrônica e a incomparável e didática Bê a Bá da Eletrônica e as temáticas da editora Fittipaldi.

Se tenho alguma? Poucas. Muitas amarelaram. Quando veio a internet ficaram esquecidas e depois de muitas mudanças algumas se foram, porém os ensinamentos ficaram.

E aqui fica a dica deste post: Neste site o sujeito publica scans das revistas de 80 e 90 e faz um ótimo trabalho. Recomendo!

http://www.blogdopicco.blogspot.co.id/2014/11/revistas-be-ba-da-eletronica.html

 

Android Box reiniciando ou desligando sozinho

Comprei um desses Android Box da China. São versáteis para jogar, assistir Youtube, Netflix e outras atividades tipicas do Android.
Entretanto o que comprei veio com um problema: Ele desligava sozinho quando o WiFi era muito exigido ou a GPU era usada.

Usando de analogia com o Raspberry Pi que tem um problema de performance quando a tensão caia abaixo de 4.97V imaginei que era problema de alimentação.Testei várias fontes e as fontes fracas faziam o aparelho se comportar muito mal. Mas nunca tive uma boa resposta mesmo com uma fonte de 2A.

Eis a solução:

IMG_20160320_095131514

Sim! Um capacitor eletrolítico de 1000uF que achei em sucatas ligado ao positivo e negativo. O capacitor menor eu tirei porque não fechava a caixa. Não sugiro ligar nos fios da fonte pois a impedância (mesmo que pequena) dos fios talvez atrapalhe.

E funciona que é uma beleza!

Outras causas

Porém alguns já relataram que não funcionou. Outro motivo relatado por Tiel (Abaixo nos comentários) é o excessivo aquecimento. Então neste caso um cooler ou dissipador mini para Raspberry PI colado no chip principal deverá ajudar.

Outro motivo comum de qualquer aparelho Android é aplicativos ruins instalados que corrompem o sistema. Neste caso forçar um ‘reset’ as configurações de fábrica deve ajudar. Saiba que tudo será apagado e o aparelho voltará a ficar como veio de fábrica. Normalmente este comando fica em Settings->Personal->Backup&Reset.

Onde adquirir?

As vezes as pessoas param aqui porque querem comprar um. Eu comprei o meu no famoso DX.com mas isso foi a alguns anos. Hoje o Aliexpress é a melhor opção pois tem preços melhores e aceita pagamento por boleto para quem não tem cartão de crédito (e da tempo de se arrepender!).

Veja os exemplos abaixo. O primeiro tem preço muito bom.

AliExpress.com Product – 2GB RAM+16GB ROM NEXBOX A95X Smart TV Box Amlogic S905X Quad core 64 Bit Android 6.0 4Kx2K 2.4GHz WiFi Media Player Set Top Box
AliExpress.com Product – GOTiT S805 TVBox+Royal IPTV 1950 Arabic African French Europe IPTV Channels Quad Core Smart 1G/8G Android KODI TV Set Top Box
AliExpress.com Product – KII Pro DVB-T2 + DVB-S2 Android 5.1 TV Box 2GB/16GB Amlogic S905 Quad-core Kodi 17.0 4K*2K 2.4G&5G Dual Wifi Bluetooth KIIpro

Este ai que comprei tem WiFi, Ethernet, GPU, entrada de MicroSD e saída HDMI e Video Composto e é esta saída que uso atualmente em uma TV analógica de tubo antiga. Outra boa aplicação é quando se viaja para algum lugar e você quer levar o Netflix junto.

sku_426763_6

Vídeo de válvula Termiônica feita a mão

Um célebre vídeo do francês Claude Paillard fazendo uma válvula do vidro à curva de teste no medidor de curvas. Para quem não sabe válvulas estão ai ainda como saídas de transmissores, radares e para alguns audiófilos. As válvulas tem uma curva de resposta que acrescentam harmônicas pares ao som tornando ele mais ‘rico’ e gostoso de se ouvir. Um Mosfet tem curva semelhante …. mas não vou entrar em polêmicas!

É de invejar tantos equipamentos e tanta habilidade.

Curta!

 

Orvibo Allone Versus Geeklink Thinker

Esqueça o Orvibo Allone. Comprei o aparelho para não somente usar nos aparelhos de casa como também para acender luzes e abrir portões. Não funciona. Ele não tem modo RF Learning Code.

Até que achei o maravilhoso: 

Universal GeekLink Thinker

Sim. Muito melhor. Ele realmente automatiza uma casa. Este aparelho tem um modo RF Learning que permite acender luzes e controlar portões que tenham a tecnologia Learning Code (código fixo).

E não é só isso ele embute muitas funções:

  • WiFi Router com Linux OpenWrt;
  • Conecta à internet com PPOE;
  • Tem dois Ethernet e um USB;
  • Modo de aprender códigos RF em 433Mhz/315Mhz 
  • Clonagem de controles remotos infravermelhos
  • IFTTT que significa IF This Then That (QBASIC!!?). O sistema de programação de regras
  • Monitoração remota pelo smartphone.
  • Ponte das cameras IP.

Achei um comprador no AliExpress com promoção que vem com o aparelho e uma camera IP por U$68,00. Bom preço.

Este aparelho nasceu do site de financiamento público Kickstarter e muitos outros estão nascendo por lá.

d298f63ee94925aa3f106c07b01e6660_original

E pensando bem eu tinha comprado o VoCore por lá (um micro linux com WiFi, USB e Ethernet e algumas GPIOS) e ele parado aqui pode fazer tudo isto que o GeekLink faz. Basta ligar os fios, conectores, e programá-lo … que trabalho!

STM32 no Linux

Programar Kits ou microcontroladores STM32 no Linux é perfeitamente possível graças ao GNU ARM Toolchain para tanto é necessário instalar este e outros pacotes primos como veremos neste post. Será mostrado aqui a instalação destes pacotes e um simples programa blink sem bibliotecas de suporte.

Há vários toolchains disponíveis para uC ARMs alguns que se utilizam das syscall de algum SO como o Linux e outros que não esperam nenhum Sistema Operacional por trás, programar assim é chamado comumente como ‘baremetal’.

Para debugar e gravar um STM32 será utilizado o ST-Util e o OpenOCD.

Instalando os pacotes

GCC + GDB + OpenOCD

Eu utilizo o ArchLinux mas não poderia discriminar o Ubuntu.
Para o Ubuntu:

sudo add-apt-repository ppa:terry.guo/gcc-arm-embedded
sudo apt-get update
sudo apt-get install gcc-arm-none-eabi
sudo apt-get install gdb-arm-none-eabi
sudo apt-get install openocd

ArchLinux users:

sudo pacman -S arm-none-eabi-binutils arm-none-eabi-gcc arm-none-eabi-gdb arm-none-eabi-newlib openocd stlink

Se tudo ocorreu corretamente teste a instalação abrindo um shell e digitando arm-none <TAB> isso fará o bash autocompletar a sequência e mostrar os executáveis instalados como nesta saída tipica:

arm-none-eabi-addr2line arm-none-eabi-gcc-4.7.4 arm-none-eabi-ld.bfd
arm-none-eabi-ar arm-none-eabi-gcc-ar arm-none-eabi-nm
arm-none-eabi-as arm-none-eabi-gcc-nm arm-none-eabi-objcopy
arm-none-eabi-c++ arm-none-eabi-gcc-ranlib arm-none-eabi-objdump
arm-none-eabi-c++filt arm-none-eabi-gcov arm-none-eabi-ranlib
arm-none-eabi-cpp arm-none-eabi-gdb arm-none-eabi-readelf
arm-none-eabi-elfedit arm-none-eabi-gdbtui arm-none-eabi-size
arm-none-eabi-g++ arm-none-eabi-gprof arm-none-eabi-strings
arm-none-eabi-gcc arm-none-eabi-ld arm-none-eabi-strip

Primeiro Programa

Antes de tudo vamos iniciar a configuração do vetor de interrupções, a routina de reset e alguns Defines para alguns registradores que iremos usar. Este programa foi feito para o kit STM32 Discovery F0. Com poucas modificações e entendendo o processo a migração para outros (M3/M4) será fácil.

O primeiro arquivo boot.h contém alguns typedefs e Defines para registradores de clock e GPIOs, declaração de váriaveis externas do arquivo de link, prototypes de funções e o vetor de interrupções (que neste caso só cobrirá as interrupções ARM). Também o Reset e SystemInit bem como as funções de tratamento de interrupções serão declaradas.

boot.h

// boot.h
#define uint32_t unsigned int
#define IO_Uint32 volatile unsigned int
typedef struct
{
IO_Uint32 ACR;
IO_Uint32 KEYR;
IO_Uint32 OPTKEYR;
IO_Uint32 SR;
IO_Uint32 CR;
IO_Uint32 AR;
IO_Uint32 RESERVED;
IO_Uint32 OBR;
IO_Uint32 WRPR;
} _FLASH;

typedef struct
{
IO_Uint32 CR;
IO_Uint32 CFGR;
IO_Uint32 CIR;
IO_Uint32 APB2RSTR;
IO_Uint32 APB1RSTR;
IO_Uint32 AHBENR;
IO_Uint32 APB2ENR;
IO_Uint32 APB1ENR;
IO_Uint32 BDCR;
IO_Uint32 CSR;
IO_Uint32 AHBRSTR;
IO_Uint32 CFGR2;
IO_Uint32 CFGR3;
IO_Uint32 CR2;
} _RCC;

typedef struct {
IO_Uint32 MODER;
IO_Uint32 OTYPER;
IO_Uint32 OSPEEDR;
IO_Uint32 PUPDR;
IO_Uint32 IDR;
IO_Uint32 ODR;
IO_Uint32 BSRR;
IO_Uint32 LCKR;
IO_Uint32 AFRL[2];
IO_Uint32 BRR;
} _GPIO ;

#define GPIOC ((_GPIO *) 0x48000800)
#define RCC ((_RCC *) 0x40021000)
#define FLASH ((_FLASH *) 0x40022000)

// Globais do arquivo do linker
extern void *_estack;
extern unsigned char _sidata;
extern unsigned char _sdata;
extern unsigned char _edata;
extern unsigned char _sbss;
extern unsigned char _ebss;
extern void main (void);

// Entry Point
void Reset (void);
// Default Interrupt Handler
void Default_Handler(void) __attribute__( ( interrupt ) );
static void HardFault_Handler( void )/* __attribute__( ( naked ) )*/;

__attribute__ ((section(".isr_vector")))
void (* const Vectors[])(void) = {
(void(*)(void)) &amp;_estack,
Reset,
Default_Handler, //NMI_Handler,
HardFault_Handler, //FaultHandler,
0,
0,
0,
0,
0,
0,
0,
Default_Handler, //SVC_Handler,
0,
0,
Default_Handler, //PendSV_Handler,
Default_Handler, //SysTick_Handler,
};

static void HardFault_Handler( void ){
__asm__("BKPT");
while (1);
}

#pragma weak _exit = Default_Handler
void Default_Handler(void) {
__asm__("BKPT");
while (1);
}

void SystemInit(void)
{
/* Reseta o RCC clock para  o padrão ------------*/
/* Set HSION bit */
RCC-&gt;CR |= (uint32_t)0x00000001;

/* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
RCC-&gt;CFGR &amp;= (uint32_t)0x08FFB80C;

/* Reset HSEON, CSSON and PLLON bits */
RCC-&gt;CR &amp;= (uint32_t)0xFEF6FFFF;

/* Reset HSEBYP bit */
RCC-&gt;CR &amp;= (uint32_t)0xFFFBFFFF;

/* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
RCC-&gt;CFGR &amp;= (uint32_t)0xFFC0FFFF;

/* Reset PREDIV[3:0] bits */
RCC-&gt;CFGR2 &amp;= (uint32_t)0xFFFFFFF0;

/* Reset USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits */
RCC-&gt;CFGR3 &amp;= (uint32_t)0xFFFFFE2C;

/* Reset HSI14 bit */
RCC-&gt;CR2 &amp;= (uint32_t)0xFFFFFFFE;

/* Desabilita todas as interrupções*/
RCC-&gt;CIR = 0x00000000;

FLASH-&gt;ACR = 0x00000011;

}
// O começo de tudo antes de main
__attribute__( ( naked ) ) void Reset (void) {

register unsigned char *src, *dst;

// Copia os dados da flash para a ram (const, static initialized variables)
src = &amp;_sidata;
dst = &amp;_sdata;
while(dst &lt; &amp;_edata) *dst++ = *src++;

// Inicializa o bss (C static variables non initialized)
dst = &amp;_sbss;
while(dst &lt; &amp;_ebss) *dst++ = 0;

SystemInit();
//__libc_init_array();
// ... and finally call main saving sp
__asm__("b main");

}

A função Reset inicializa a variáveis estáticas com zero, chama SystemInit e finalmente chama a função Main com um brunch para economizar RAM na pilha.

main.h

O segundo arquivo é o fluxo principal do programa onde esta a função Main. Este programa irá piscar os LEDs do kit nas portas PC9 e PC8. O tipo GPIO foi declarado anteriormente em boot.h.

#include "boot.h"

__attribute__( ( naked ) ) void main (void){

RCC-&gt;AHBENR |= ((unsigned int) 0x00080000); // Enable GPIOC otherwise a hardfault
GPIOC-&gt;MODER = 0x55555555; // Output mode for all PORTC

volatile register int i;

while (1) {

GPIOC-&gt;BSRR = 0x0000ffff;
for (i = 0; i &lt; 50000; i++); GPIOC-&gt;BSRR = 0xffff0000;
for (i = 0; i &lt; 50000; i++);

};

__asm__("b .");
};

Makefile e Link Script

Acabou? Não  Ainda faltam dois arquivos o MakeFile e o Script do Linker.

Este MakeFile é completo o que compilará, mostrará o tamanho do código, converterá ELF para BIN, irá gerar uma listagem em assembly e finalmente grava na flash o programa. Simplesmente execute o make no terminal de onde estão estes arquivos.

all:
arm-none-eabi-gcc -mcpu=cortex-m0 -gdwarf-2 -mthumb -nostdlib -mlittle-endian -Tlink.ld main.c -o main
arm-none-eabi-size main
arm-none-eabi-nm -S main
arm-none-eabi-objdump -d -M intel -S main &gt; bin.asm
arm-none-eabi-objcopy -O binary main main.bin
st-flash erase
st-flash --reset write main.bin 0x08000000
debug:
arm-none-eabi-gdb main -tui --eval-command="target extended-remote :4242"

E por fim o link  script. Lugar onde as posições de memória são definidos, o Entry Point e algumas globais usadas pelo Reset para inicializar a variáveis estaticas e constantes.

/* Entry Point */
ENTRY(Reset)

/* Highest address of the user mode stack */
_estack = 0x20001FFF; /* end of RAM */

/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0; /* Only usefull if you use alloc, malloc */
_Min_Stack_Size = 0x800;

MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 64K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 8K
}

/* Define output sections */
SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} &gt;FLASH

/* The program code and other data goes into FLASH */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)

KEEP (*(.init))
KEEP (*(.fini))

. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} &gt;FLASH

/* Constant data goes into FLASH */
.rodata :
{
. = ALIGN(4);
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} &gt;FLASH

.ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } &gt;FLASH
.ARM : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} &gt;FLASH

.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} &gt;FLASH
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} &gt;FLASH
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} &gt;FLASH

/* used by the startup to initialize data */
_sidata = LOADADDR(.data);

/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */

. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} &gt;RAM AT&gt; FLASH

/* Uninitialized data section */
. = ALIGN(4);
.bss :
{
_sbss = .; /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)

. = ALIGN(4);
_ebss = .; /* define a global symbol at bss end */
__bss_end__ = _ebss;
} &gt;RAM

._user_heap_stack :
{
. = ALIGN(4);
PROVIDE ( end = . ); /* Necessary for newlibc */
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(4);
} &gt;RAM

/* Remove information from the standard libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
}

.ARM.attributes 0 : { *(.ARM.attributes) }
}

Foi apresentado aqui como programar microcontroladores STM32 no Linux utilizando as ferramentas gratuitas disponíveis. Não utilizei o conjunto de bibliotecas oficiais da ST chamado Cube para demonstrar também como é um programar um uC sem este suporte.

Como evolução o leitor irá integrar o Cube e utilizar o CubeMX para facilmente inicializar o uC e partir para a programação em si.

Eu programo microcontroladores STM32 no Linux profissionalmente com estas ferramentas e integro tudo no Code:Blocks que é uma ótima alternativa aos ambientes caros como IAR e Keil. Eu não me adaptei muito aos derivados gratuitos do Eclipse porque não gosto de programas que demoram para inicializar …

EDIT: O WordPress vive mudando meu código postado transformando caracteres especiais em formato HTML Entity e não sei como mudar isso. Se alguém ai souber me ajude por favor porque se você copiar e colar os códigos daqui será necessário corrigir muita pontuação.

ARM – SysTick fácil.

SysTick é um timer decrescente presente na maioria dos processadores ARM Cortex ligado diretamente ao Core Clock com registrador de 24 Bits.

O SysTick gera interrupção a cada estouro do contador, ou seja, quando chega em 0. Para configurar usando os registradores diretamente segue exemplo:

SysTick->CTRL = 0; // Desliga o SysTick
SysTick->LOAD = 1000; // Conta de 1000 até 0
SysTick->VAL = 0; // Valor inicial, e também valor da contagem atual
SysTick->CTRL = 0x7; // Liga o SysTick

Ou para quem tiver disponível os arquivos CMSIS (muito provavelmente) este pode ser inicializado diretamente:

Neste caso estabelecemos um estouro a cada 1ms

SysTick_Config(SystemCoreClock / 1000) ;

Neste o loop while trava se um valor impossível for inicializado.

while (SysTick_Config(48000000 / 2) != 0);  // 48Mhz / 2 = 24Mhz

Ótima opção para iniciar no mundo ARM.

Lembre-se que o tamanho máximo do contador é de 24 bits o que representa um valor decimal de 16777216. Assim dividir o 48Mhz por 2 retorna uma valor maior que o máximo possível. Deu para perceber que conseguir 1 Segundo de estouro só é possível em clocks mais baixo.

Para que as interrupções ocorram não esqueça de definir uma função (Handler) que deve estar adicionada na Vector Table:

void (* const g_pfnVectors[])(void) = {
&_estack,
Reset_Handler,
NMI_Handler,
FaultHandler,
0,
0,
0,
0,
0,
0,
0,
SVC_Handler,
0,
0,
PendSV_Handler,
SysTickIsr, //Função SysTickIsr que será chamada a cada estouro
};

Orvibo Allone Wiwo – Central de automação residencial

20140228175300833

O mercado de automação residencial poderia-se dividir em três grandes basicamente: Os padrões americanos, os padrões europeus e os nascentes chineses.

Orvibo Wiwo-R1 é provavelmente um dos grandes representantes dessa crescente inovação chinesa. Este aparelho faz maravilhas reunidos em um só. Com ele você poderá programar todos seus controles remotos infra-vermelhos do Home Theater, da TV, do Som e tantos outros e usando um aplicativo Android no smartphone operar todos eles. Essa possibilidade se faz através da conexão wifi da casa.

Também como diferencial ele incorpora um transmissor 433mhz adicionando também o controle dos portões, alarmes e luzes.

O melhor de tudo: é barato para os recursos encontrados nele. Custa aprox $32,00 muito abaixo dos obsoletos X-10.

O que gosto neste aparelho é que não é exatamente um aparelho inovador para um conhecedor da eletrônica. Nada que uma reunião de um STM32 e alguns periféricos não façam, entretanto é interessante de se ver como eles conseguem implementar uma idéia e lançar para o mundo.

Aonde comprar?

Eu comprei no Alliepress como nos links abaixo:

Mas se você pode torrar dinheiro no Mercado Livre também vende.

Pessoalmente recomendo pelo preço imbatível, o frete gratuito e os recursos inimagináveis em uma linha americana com este preço.

Manual: http://www.gotake.cn/dl/manual/AllOne_manual.pdf

Veja este video sobre o aparelho para ter uma idéia:

Como funcionam os controles Rolling Codes/Hopping Code

No princípio a inocência

Houve uma época em que acionar o alarme de um carro era feito através do envio de um código de tamanho e forma fixa. O famoso e muito utilizado HT6P20-B da Holtek transmite  28 bits imutáveis a cada aperto do botão do controle.
O receptor era então sincronizado com este código e toda vez que este recebesse o código ele efetuava uma ação como travar/destravar o alarme, abrir e fechar o portão ou ligar uma lampada.

E os ladrões viraram nerds …

Enfim, um código fixo imutável poderia ser facilmente copiado e retransmitido por qualquer outro transmissor que o receptor nem saberia de quem se tratava. Mais conhecido como Clonagem ou Replay Attack.

Assim é o funcionamento do controle Learning Code.

Criptografia rolante

Uma forma de mudar isto era obviamente criptografar a informação – o ID do controle – . Mas se você pegar um código que nunca muda e criptografa-lo o resultado sera somente outro código fixo.

Para isso é necessário que se mude o código transmitido a cada aperto do botão ou tempo programado de forma que um possível intruso (homem do meio) não consiga prever qual o próximo código a ser gerado.

Para que o código varie constantemente normalmente é usado um contador interno que é  incrementado a cada aperto do botão. Assim monta-se uma bloco contendo o contador e algumas outras informações como o botão apertado e o nível da bateria do controle e criptografa-se este bloco com algum algoritmo criptográfico.

Como o contador constantemente varia o bloco transmitido será sempre diferente. Assim somente o receptor com a chave para descriptografar conseguirá ler o conteúdo.

E aqui fica o pulo do gato. Mesmo que um ladrão pegue uma transmissão legítima e reenvie ao receptor este verá que o contador desta transmissão já foi aceito antes, então ignora a transmissão. O receptor só ira aceitar uma transmissão válida se este bloco conter um contador inédito.

Veja que uma forma de ataque é poluir o espectro RF para que sua transmissão não chegue ao receptor – portão, carro – e o atacante consiga pegar esta transmissão e reenviar posteriormente ao receptor para efetuar a ação. Como o contador não foi recebido o receptor aceitará a transmissão. Por isso é bom certificar-se que o carro ‘travou’ o alarme do que simplesmente apertar o botão e nem dar bola.

Keeloq

Keeloq é um algoritmo proprietário da Microchip que criptografa um bloco de 32 bits com uma chave de 64 bits. Os chips mais famosos no Brasil atualmente utilizando ele são os HCS200 e HCS301 que pré-programados com a chave transmitem um código que sempre varia devido a um contador que é incrementado a cada aperto do botão.

As empresas tem uma chave única para todos os controles (ou segmentos de produtos, região). Se você descobrir a chave você clona qualquer carro ou portão do mesmo alarme.

AES128

Alguns estão começando a implementar um sistema rolling code com o AES128. A tendência é utilizar a mudança do contador de forma temporal ( a cada 1ms por exemplo).

A ideia é simples e de fácil implementação em um Arduino, para testar dois Arduinos e um par TX-RX são necessários. Um envia o código criptografado e o outro descriptografa, verifica e aciona:

Seja:
uint32 Contador
uint24 ID
uint4 Botão
Faça a cada 1ms:
Incremente o contador (ou outra forma de variação)
Se o botão for apertador faça:
Monte um bloco de 128 bits  contendo o contador, o botão e se quiser o ID.
Criptografe este bloco com a chave
Some a este bloco o ID (logo será um bloco de 24+128bits) e transmita

Clonagem

Se você pretende clonar algum controle Keeloq boa sorte. Há uma técnica utilizando o ataque de sub-channel onde é observado o consumo de energia de um receptor implementado em PIC e conhecidos os consumos específicos de cada instrução é possível estimar a chave. Porém é uma técnica avançada.

Para saber mais (todos em inglês) …