Restored Kar4oke post + Landis Gyr post

Author: housey2k

_posts/2025-07-20-kar4oke.md

@@ -1,21 +1,47 @@
 ---
 layout: post
-title: "[PT-BR] kar4oke.com - Explorando formas de ampliar o catálogo"
+title: "[PT-BR] kar4oke.com - Injetando URLs do YouTube no player embutido"
 date: 2025-07-20
 ---
 
-Recentemente assinei o serviço do site kar4oke.com para usar em uma festa entre amigos. A proposta do site é excelente e funciona muito bem, mas notei que a seleção de músicas disponíveis é bastante limitada, o que pode restringir a experiência em alguns contextos.
+Recentemente assinei o serviço do site kar4oke.com para usar em uma festa, porém percebi que a seleção de músicas é extremamente limitada.
 
-Curioso sobre como o sistema funcionava por trás dos panos, comecei a explorar com mais atenção a forma como os vídeos são carregados e reproduzidos na plataforma. Percebi que o serviço utiliza como base um player bem conhecido e consolidado do mercado, o que me levou a testar algumas formas de integração alternativa.
+Usando o site normalmente, é bem visível que o player deles não passa de um reprodutor do YouTube, inspecionando a página, percebi que existia uma tag iframe, sem pensar duas vezes, substitui a tag manualmente por uma com o src de outro vídeo, e incrivelmente funcionou.
 
-No começo, minhas tentativas de inserir conteúdos externos pareciam funcionar visualmente, mas logo notei que várias funcionalidades importantes, como a geração de nota e a sequência automática de faixas, não se comportavam como o esperado. Isso indicava que o sistema interno da plataforma era bem mais sofisticado do que parecia à primeira vista.
+Ou assim eu pensei, pois assim que o vídeo terminou, não gerou a nota aleatória nem passou para o próximo vídeo.
 
-Com um pouco mais de investigação e prototipagem, consegui desenvolver uma solução que mantém todas as funcionalidades essenciais da plataforma mesmo ao utilizar conteúdos externos — incluindo reprodução automática, avaliação e integração com a fila de músicas. Essa solução, que implementei como uma ferramenta experimental para uso pessoal, abre espaço para expandir a biblioteca disponível sem comprometer a lógica e a estrutura original do site.
+Após isso, fiz uma extensão [(disponível no meu GitHub)](https://github.com/housey2k/kar4oke.com-ForceYT) que automaticamente substitui o iframe, mesmo funcionando, o resultado foi o mesmo ao terminar o vídeo, sem nota nem autoplay.
 
-Além disso, observando o comportamento do sistema de adição de músicas por QR Code, percebi que existe um processo estruturado de seleção e controle de conteúdo, o que me leva a crer que existe uma preocupação legítima com a curadoria e a estabilidade do serviço. Mesmo assim, acredito que existem formas técnicas seguras de oferecer uma experiência mais flexível ao usuário final, sem comprometer os pilares do sistema.
+Depois de olhar o código e fazer um pouco de engenharia reversa, descobri que por algum motivo existe um iframe com todo o código HTML, como se fosse uma página isolada, e dentro desse frame, um segundo frame com o player, descobri também que posso enviar comandos diretamente usando uma função chamada `player.loadVideoById(string)`
 
-Essa experiência me mostrou como a combinação de curiosidade, respeito à arquitetura existente e criatividade pode resultar em soluções que agregam valor tanto para os usuários quanto para os desenvolvedores da plataforma. Caso a equipe do kar4oke.com tenha interesse, estou aberto para compartilhar ideias e colaborar com melhorias que tragam mais liberdade ao usuário, sem abrir mão da consistência e da qualidade da experiência oferecida.
+O código implementado na extensão está assim:
+```javascript
+function sendLoadVideoMessage(videoId) {
+  const iframe = document.querySelector('iframe[id^="youtube-"]');
+  if (!iframe) {
+    alert("Iframe do YouTube não encontrado.");
+    return;
+  }
 
-Se você me conhece, sabe que não gosto de ocultar detalhes, mas por enquanto esse post vai ficar assim, sem sequer uma informação valiosa, e o repositório no GitHub com o código da extensão estará privado, estou fazendo isso pois estarei oferecendo essa função à empresa, e quero evitar cópias
+  const message = JSON.stringify({
+    function: `player.loadVideoById("${videoId}")`
+  });
+
+  iframe.contentWindow.postMessage(message, "*");
+}
+```
+
+Com esse novo código enviando instruções diretamente ao player existente ao invés de o substituir, os problemas de autoplay e geração de nota foram resolvidos
+
+Se você olhar na constante iframe, pode perceber que usei um queryselector para a ID começando com "youtube-", isso foi feito pois percebi que em alguns momentos o iframe principal tinha ID "youtube-0", e em outros momentos "youtube-1", não sei exatamente como funciona, mas provavelmente existem mais IDs.
+Após alguns ajustes e implementação de drag&drop, disponibilizo essa extensão de navegador extremamente simples que permite injetar qualquer vídeo do youtube no site kar4oke.
+
+Uma outra descoberta é que olhando o tráfego de rede da página de adcionar músicas por QR Code, percebi que ao pesquisar, a API retorna uma lista de músicas, no JSON vem a thumbnail, nome da música, artistas, e um ID numérico da música, e ao clicar para adcionar a música à fila, ele envia uma solicitação com uma instrução de adcionar e o ID da música.
+
+Talvez exista algum motivo técnico, talvez seja apenas para controlar o conteúdo disponível no site, mas ao invés de implementar um banco de dados de IDs numéricos e links do youtube, eu implementaria a busca diretamente pelo youtube (por mais que isso crie a possibilidade de encontrar vídeos que não são karaokê).
+
+Essa experiência mostra como um pouco de curiosidade e engenharia reversa podem revelar o funcionamento interno de plataformas web modernas. Embora o site kar4oke.com limite a seleção de músicas disponíveis, descobri que é possível contornar essas limitações interagindo diretamente com o player do YouTube embutido, preservando funcionalidades como autoplay e geração de notas. Com isso, usuários mais avançados ganham a liberdade de personalizar sua experiência, enquanto mantêm o sistema original funcional. Ainda assim, essa abordagem levanta questões sobre o equilíbrio entre controle de conteúdo, experiência do usuário e liberdade de uso — algo que toda plataforma fechada precisa considerar ao definir suas limitações técnicas.
+
+Entrei em contato com a empresa perguntando se eles tinham interesse em implementar essa função, e me ignoraram. A extensão tá no meu GitHub pra vocês usarem a vontade.
 
 <video width="640" height="480" controls><source src="/post-vid/KAR4OKE.mp4" type="video/mp4">Your browser does not support the video tag.</video> 

_posts/2025-07-30-ld-tli-dump.md

@@ -0,0 +1,134 @@
+---
+layout: post
+title: "[WIP] Dumping the firmware of a Landis+Gyr reading terminal"
+date: 2025-07-30
+---
+
+![TLI Picutre](/post-img/LD-TLI.png "The target of this project")
+
+This whole project started as a curbside find: An abandoned power meter.
+Without much hesitation I picked it up.
+
+After getting home and doing some research I found it was part of a metering system called SGP+M (Sistema de Gerenciamento de Perdas + Medição/System for Management of Losses + Metering).
+After more googling, I could find a manual for that system ([read it here](/post-docs/SGPM-Manual.pdf)). It has many awesome stuff I'll probably never get to see, so let's just focus on the TLI.
+
+If I'm not mistaken, TLI stands for "Terminal de Leitura de Informações/Information Reading Terminal".
+
+The board has these 3 main ICs:
+* Z8 Encore! series microcontroller ([Z8F0421](/post-docs/Z8F0421-Datasheet.pdf)), equipped with 4KB of flash.
+* ATA5744N RF IC (RX Only, sadly).
+* CF8566T LCD Driver.
+
+There is a 6 pin debug header on the board. Here is the pinout:
+1 - DBG
+2 - VCC (capacitive dropper output)
+3 - 3.3V
+4 - NC
+5 - NC
+6 - GND
+
+The DBG pin is Zilog's authoral system for debugging their microcontrollers. It uses UART Half-Duplex for communication with automatic baud rate detection.
+
+I found a [post by Sean Young](https://www.mess.org/2018/02/10/Dumping-Z8-Encore-Z8F0811-Program-Memory/) sharing their work on dumping a different Z8 Encore microcontroller.
+On this post there is a piece of code I managed to badly modify (with the help of ChatGPT) to not only transmit, but also receive the response data. It's shown below, I flashed it on my STM32 Bluepill so I didn't need logic level shifters.
+```c
+#define pin PA0
+#define BIT_DELAY 10  // microseconds per bit (your original timing)
+
+// Your existing send_byte with small tweak
+void send_byte(int b)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);  // Start bit
+  delayMicroseconds(BIT_DELAY);
+
+  for (int i = 0; i < 8; i++) {
+    if (b & (1 << i))
+      digitalWrite(pin, HIGH);
+    else
+      digitalWrite(pin, LOW);
+    delayMicroseconds(BIT_DELAY);
+  }
+
+  digitalWrite(pin, HIGH);  // Stop bit
+  delayMicroseconds(BIT_DELAY);
+}
+
+// New bit-bang receiver matching that framing
+int read_byte() {
+  pinMode(pin, INPUT_PULLUP);
+
+  // Wait for start bit (line goes LOW)
+  while (digitalRead(pin) == HIGH);
+
+  // Align to middle of first data bit
+  delayMicroseconds(BIT_DELAY + BIT_DELAY / 2);
+
+  int value = 0;
+  for (int i = 0; i < 8; i++) {
+    if (digitalRead(pin))
+      value |= (1 << i);
+    delayMicroseconds(BIT_DELAY);
+  }
+
+  // Optionally wait for stop bit, but ignoring it here
+  delayMicroseconds(BIT_DELAY);
+
+  return value;
+}
+
+void setup() {
+  Serial.begin(115200);
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);  // Idle HIGH
+}
+
+
+void loop() {
+  Serial.println("Holding DBG LOW for manual power connection...");
+
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+  delay(10000);  // <-- 10 seconds for you to connect target power
+
+  Serial.println("Releasing DBG line...");
+  digitalWrite(pin, HIGH);
+  delay(1);
+
+  Serial.println("Starting communication sequence...");
+
+  // Your existing command sequence
+  send_byte(0x80);
+  send_byte(0x0B);
+  send_byte(0x00);
+  send_byte(0x00);
+  send_byte(0x20);
+  send_byte(0x00);
+
+  Serial.println("Switching to receive mode...");
+
+  pinMode(pin, INPUT_PULLUP);
+  delayMicroseconds(50);
+
+  for (int i = 0; i < 1024; i++) {
+    int b = read_byte();
+    Serial.print("RECV 0x");
+    Serial.println(b, HEX);
+  }
+
+  Serial.println("Done.");
+  while (1);
+}
+```
+
+Sadly all I got was 0xFF, which means the MCU has read protection enabled. Scrolling further on Sean's post, we can see they also got it, but that isn't the end of it.
+Zilog has an application note named [AN0117](/post-docs/an0117.pdf) that explains how to do gang programming on Z8 microcontrollers using something called the **BYPASS** mode.
+
+Sean developed software to dump their MCU using a raspberry pi, but they didn't release the full code.
+
+I love hardware, but I'm a terrible programmer, so I just explained all my situation to ChatGPT and managed to build a full STM32CubeIDE project with a bit of intervention by me.
+The code is avaiable on a [GitHub repository on my profile](github.com/housey2k/Z8F0421-Dump).
+
+Now the only thing left is buying a breakout board and connecting the STM32 to the Z8.
+
+I really hope it works, I'd be able to display custom stuff on the LCD (This time with vanilla hardware, differently from my MT1389 post where I tossed the original board and hooked the VFD to an arduino), decode smart meter signals maybe, and maybe contribute with [Hash](recessim.com)'s efforts on reverse engineering smart meters