HENRY

Esta página documenta a máquina impressora de cheques HENRY, encontrada no lixo da Estação de Metareciclagem Samambaia.

Modelo da PCB: HENRY PINHAIS/PR REV.1

componentes

• CPU: 8031
• RAM: UM62256B (32k bytes ?)
• EEPROM 27C512 (64k bytes) Marcada com um adesivo escrito "PROT V19 Henry Equipamentos e Sistemas LTDA"
• diversos chips TTL da família 74

esquemático

Está sendo levantado o esquemático desta placa (rev1) no repositório https://github.com/GaroaHC/HENRY

ligações

display

Display LCD de 2 linhas de caracteres compatível com HITACHI HD44780. Extremamente comum.

• Pino 1 = marrom -> ligado ao pino 1 do display
• pino 2 = não usado
• pino 3 = vermelho
• e assim por diante

Os pinos 15 e 16 do display não estão ligados a nada. Apesar de se pular o pino 2 no conector, a ligação dos pinos do display é sequencial, ou seja, pino 1 = marrom, pino 2 = vermelho, etc...

teclado

• pino 1 = marrom -> botão preto de cima
• pino 2 não usado
• pino 3 = vermelho -> botão preto de baixo
• pino 4 = laranja -> botão azul
• pino 5 = amarelo -> comum a todos os botões

motores

• pino 1 = amarelo
• pino 2 não usado
• pino 3 = laranja
• pino 4 não usado

impressora

• pino 1 não usado
• pino 2 = amarelo
• pino 11 = roxo

jumper 1

Botão liga-desliga ? Aparentemente não tem polaridade.

Olhando para o silk da placa com o texto JP1 de pé:

• pino da esquerda = marrom
• pino da direita = vermelho

sensores

• pino 1 não usado (o conector nem encaixa nesse pino)
• pino 2 = marrom (parece ser o terra?) pino 0 dum sensor optico (de leitura da presenção de um cheque?)
• pino 3 não usado
• pino 4 = vermelho -> pino 1 do opto do encoder
• pino 5 = laranja -> pino 3 do opto do encoder
• pino 6 = amarelo -> pino 1 do fim de curso
• pino 7 = verde -> pino 3 do fim de curso
• pino 8 = azul -> pino 1 do sensor de cheque
• pino 9 = roxo -> pino 3 do sensor de cheque

Os pino 2 tanto do sensor do cheque e do fim de curso não é usado.

borne CN7

Olhando o silk com o texto GND, VAC, etc de pé:

• GND -> BAT - da placa da fonte
• VAC da esquerda -> BAT + da placa da fonte
• VAC da direita -> não está ligado em nada
• BAT + -> fio vermelho do soleníde
• BAT - -> aterramento (na carcaça e na fiação da tomada)

borne CN8

• C -> ligado em nada
• NA -> fio preto do solenóide

dump da EEPROM

codigo de arduino para fazer o dump

Rodamos esse código 4 vezes (uma para cada par de bits) e o resultado foram 4 arquivos de dump lidos na porta serial.

#define dado0 A0
#define dado1 A1
#define Addr0 2
#define Addr1 3
#define Addr2 4
#define Addr3 5
#define Addr4 6
#define Addr5 7
#define Addr6 8
#define Addr7 9
#define Addr8 10
#define Addr9 11
#define Addr10 12
#define Addr11 13
#define Addr12 A2
#define Addr13 A3
#define Addr14 A4
#define Addr15 A5

int endereco;

void setup(){
  endereco = 0;
  Serial.begin(9600);
  pinMode(Addr0, OUTPUT);
  pinMode(Addr1, OUTPUT);
  pinMode(Addr2, OUTPUT);
  pinMode(Addr3, OUTPUT);
  pinMode(Addr4, OUTPUT);
  pinMode(Addr5, OUTPUT);
  pinMode(Addr6, OUTPUT);
  pinMode(Addr7, OUTPUT);
  pinMode(Addr8, OUTPUT);
  pinMode(Addr9, OUTPUT);
  pinMode(Addr10, OUTPUT);
  pinMode(Addr11, OUTPUT);
  pinMode(Addr12, OUTPUT);
  pinMode(Addr13, OUTPUT);
  pinMode(Addr14, OUTPUT);
  pinMode(Addr15, OUTPUT);
  
  pinMode(dado0, INPUT);
  pinMode(dado1, INPUT);
}

void le_dado(int address){
  digitalWrite(Addr0, address & (1 << 0) ? HIGH : LOW);
  digitalWrite(Addr1, address & (1 << 1) ? HIGH : LOW);
  digitalWrite(Addr2, address & (1 << 2) ? HIGH : LOW);
  digitalWrite(Addr3, address & (1 << 3) ? HIGH : LOW);
  digitalWrite(Addr4, address & (1 << 4) ? HIGH : LOW);
  digitalWrite(Addr5, address & (1 << 5) ? HIGH : LOW);
  digitalWrite(Addr6, address & (1 << 6) ? HIGH : LOW);
  digitalWrite(Addr7, address & (1 << 7) ? HIGH : LOW);
  digitalWrite(Addr8, address & (1 << 8) ? HIGH : LOW);
  digitalWrite(Addr9, address & (1 << 9) ? HIGH : LOW);
  digitalWrite(Addr10, address & (1 << 10) ? HIGH : LOW);
  digitalWrite(Addr11, address & (1 << 11) ? HIGH : LOW);
  digitalWrite(Addr12, address & (1 << 12) ? HIGH : LOW);
  digitalWrite(Addr13, address & (1 << 13) ? HIGH : LOW);
  digitalWrite(Addr14, address & (1 << 14) ? HIGH : LOW);
  digitalWrite(Addr15, address & (1 << 15) ? HIGH : LOW);

//  delay(1);
  
  Serial.write(digitalRead(dado1) ? "1" : "0");
  Serial.write(digitalRead(dado0) ? "1" : "0");
}

void loop(){
  if (endereco<65536){
    Serial.print((endereco >> 8) & 0xff, HEX);
    Serial.print(endereco & 0xff, HEX);
    Serial.write(":");
    le_dado(endereco);
    Serial.write("\n");
    endereco++;
  }
}

script python para gerar a imagem

Depois de executar o comando

cut -d: -f2 dump0.txt > bits0.txt
cut -d: -f2 dump1.txt > bits1.txt
cut -d: -f2 dump2.txt > bits2.txt
cut -d: -f2 dump3.txt > bits3.txt

Usamos o script python abaixo para unir os dumps de pares de bits em uma única imagem dump.bin de 64kbytes:

b0 = open("bits0.txt").readlines()
b1 = open("bits1.txt").readlines()
b2 = open("bits2.txt").readlines()
b3 = open("bits3.txt").readlines()

dump = open("dump2.bin", "wb")

for i in range(0x100, 65536):
  valor = b3[i].strip() + b2[i].strip() + b1[i].strip() + b0[i].strip()
  print valor
  print int(valor, 2)
  dump.write(chr(int(valor,2)))

script para desembaralhar endereços

As 4 vias menos significativas do barramento de endereços estão embaralhadas.

Para gerar uma ROM desembaralhada, usamos o seguinte script:

b0 = open("bits0.txt").readlines()
b1 = open("bits1.txt").readlines()
b2 = open("bits2.txt").readlines()
b3 = open("bits3.txt").readlines()

dump = open("henry_protv19.bin", "wb")
desobfuscado = open("henry_protv19_desobfuscado.bin", "wb")

swap_rule = [7, 6, 5, 4, 0, 1, 2, 3]

for addr in range(65536):
  i = addr
  value_str = b3[i].strip() + b2[i].strip() + b1[i].strip() + b0[i].strip()
  value = int(value_str, 2)
  dump.write(chr(value))

  swapped_addr = addr & 0xff00
  for i in range(8):
    swapped_addr |= ((addr>>i) & 1) << swap_rule[i]

  i = swapped_addr
  value_str = b3[i].strip() + b2[i].strip() + b1[i].strip() + b0[i].strip()
  value = int(value_str, 2)
  desobfuscado.write(chr(value))

dump.close()
desobfuscado.close()