Edision Proton T265 LED - No Boot after Firmware update fail

[ElC (elc)]

Hallo
Ohne das es jetzt auf den Nägeln brennt.
Hier gibt es noch einen Edision Proton T265 LED DVB-T2 Receiver bei dem 
nach einem fehlgeschlagenem Firmware Update kein Booten mehr möglich 
ist. Das Gerät hängt einfach. Edision war nicht kooporativ... keinen 
Antwort auf meine Nachfrage.
Hilfreiche Hinweise sind willkommen.

MfG

elC

PS: Will jemand einen Tizzbird F20 Mediaplayer wiederbeleben kann ich 
helfen

[Karl-werner R. (kwriedel)]

Der hat ja einen 8 Pin Flash Winbond 25Q32FVSIG im SO8-Wide Gehäuse 
drauf. Da das Firmwarefile ja auch genau 4MByte hat, könnte es sein, 
dass es 1:1 zu brennen wäre.

[ElC (elc)]

Hallo
Danke für den Hinweis!
Mit dem Receiver hatte ich mich noch gar nicht beschäftigt, nur kurz 
geöffnet für eine Sichtprobe. Gerade habe ich das Winbond 25Q32FVSIG 
Datenblatt geladen und kurz überflogen. Bei den 3 Buchstaben SPI bin ich 
wach geworden und sofort kam die Idee für das Flashen meinen esp32 zu 
nutzen...

Auf den Boden zurückgekehrt ist das Flashen nicht so simpel. Kurz 
gegoogled wurde eine Library entdeckt, mit Beispielprogramm. Mal 
sehen...
Irgendwann in den nächsten Wochen werde ich das mal angehen.

Im Moment steht noch der Akkutausch meines Nokia 5 an. In 5 Jahren ca. 
50 mal genutzt (nur mp3 / GPS) und der Akku bläht sich auf.
LiPo Akkus fand ich schon immer seltsam.

Ob ich den Winbond zum Flashen auslöten muss/kann?
Ein neuer Chip kostet ~ 3Euro, das würde sich rechnen.

Nochmal Danke für den Wegweiser!

MfG

[Volker B. (Firma: L-E-A) (vobs)]

ElC schrieb:
> Winbond 25Q32FVSIG
(...)
> Auf den Boden zurückgekehrt ist das Flashen nicht so simpel.

Der TL866 unterstützt dieses Flash-ROM auch. So weit wie dieser 
Programmer verbreitet ist, findest Du vielleicht eine hilfreiche Person 
in Deiner Nähe? Für den Filder-Raum, südlich von Stuttgart, würde ich 
mich anbieten.

Grüßle,
Volker

[ElC (elc)]

Hallo
Aktuell sind andere Sachen wichtiger und es wird noch viele Wochen 
dauern bis das Gerät verarztet wird...
Deshalb nur kurz einige Infos.
Es ist tatsächlich ein Winbond 25Q32FVSIG verbaut.
Es sieht so aus als wenn die Pins auf Lötpads geführt sind, allerdings 
nicht nachgemessen.
Hilfreich erscheinen mir diese beiden Links:

http://www.technoblogy.com/show?2JMU

https://onecircuit.blogspot.com/2021/06/0000-0000-0110-0111.html

Es wird für mich kein Problem sein den Code an den esp32 anzupassen.

Ob es möglich sein wird zu flashen ohne den Chip auszulöten, z.B. mit 
Leitungen an den Lötpads? Ist das zu naiv gedacht?

MfG

[Dieter S. (ds1)]

ElC schrieb:
>
> Ob es möglich sein wird zu flashen ohne den Chip auszulöten, z.B. mit
> Leitungen an den Lötpads? Ist das zu naiv gedacht?

Kommt darauf an was der SoC/Mikrocontroller macht, wenn die Pins für den 
SPI Zugriff bereits als Ausgänge konfiguriert sind gibt es Probleme.

Abgesehen davon: hast Du schon geschaut ob es eine serielle 
Schnittstelle gibt? Die vier Pins an dem unbestückten Header links neben 
dem Kühlkörper wären ein Kandidat. Falls das eine serielle Schnittstelle 
ist kommt da eventuell noch etwas (z.B. vom Bootloader) und gibt 
Hinweise wo das Problem liegt.

[ElC (elc)]

Interessanter Hinweis, allerdings wüsste ich so gar nicht wie ich da 
vorgehen könnte...
Ich gehe im Moment davon aus, dass der Chip auf jeden Fall geflasht 
werden muss. Ist auch eine angenehme Programmieraufgabe. Da sehe ich 
Licht am Ende des Tunnels.
Es sei denn das Flashen geht über die Schnittstelle, wenn es denn eine 
ist. Aber was ist das für eine, da fängt das Problem für mich schon an. 
Außer mit RS232 unter Win32asm besteht da null Erfahrung.

MfG

[Dieter S. (ds1)]

ElC schrieb:
> Interessanter Hinweis, allerdings wüsste ich so gar nicht wie ich da
> vorgehen könnte...

Hast Du ein Oszilloskop? Dann könntest Du schauen ob sich an einem der 
vier Pins nach dem Einschalten des Geräts etwas tut. Bei einer seriellen 
Schnittstelle wird wohl GND, Tx, Rx und Vcc (vermutlich 3.3 Volt) an den 
Pins anliegen.

Diese DVB Receiver haben sehr häufig eine interne serielle 
Schnittstelle, manchmal gibt es im Booloader Möglichkeiten die 
eigentliche Firmware einzuspielen.

[Dieter S. (ds1)]

Wenn man ein wenig im Netz sucht und in den Flash Dump des Edision 
Proton T265 schaut dann sieht es so aus als ob es Tools gibt die über 
die serielle Schnittstelle den Flash programmieren können ("Sunplus 
Loader"). Voraussetzung ist dass der Booloader im Flash noch intakt ist. 
Außederm scheinen je nach Version des Tools nur bstimmte Flash Typen 
unterstützt zu werden.

[Dieter S. (ds1)]

Nachtrag zu weiter oben: Mit diesem Tool scheint ein Programmieren des 
Flash auch dann noch über die serielle Schnittstelle zu funktionieren 
wenn der Bootloader im Flash defekt ist (scheinbar hat der DVB SoC auch 
noch einen ROM Bootloader):

https://dvbpro.ru/vosstanovlenie-pristavki-na-sunplus-sphe-posle-neudachnoj-proshivki/

Die Anleitung für "ConsoleDown" ist auf Englisch mit ein paar 
Screenshots. Der SoC im Edision Proton T265 sollte ein SPHE8600 sein 
(mit MIPS CPU).

[ElC (elc)]

Wow, danke für dein Engagement!
Erst mal alles runter geladen und der Google Übersetzer ist auch 
hifreich.
Hier gibt es noch zwei alte vollkommen isolierte Notebooks (98SE/XP3), 
beide mit RS232. Diverse Adapter sind auch in der Schublade, inclusive 
USB zu RS232...
Die Notebooks können beide auch schnell mit einem Image wieder neu 
aufgesetzt werden, wegen der Virengefahr bei Software aus unbekannter 
Quelle.
Auf jeden Fall genug Stoff für die Wiederbelebungsversuche, entweder 
flashen oder via RS232.

Heute hat erst mal das Nokia 5 einen neuen Akku bekommen, weiter gehts 
mit dem Breadboard Bedienpult... und dann kommt der Edison an die Reihe.

MfG

[Dieter S. (ds1)]

ElC schrieb:
>
> Die Notebooks können beide auch schnell mit einem Image wieder neu
> aufgesetzt werden, wegen der Virengefahr bei Software aus unbekannter
> Quelle.

Vieles spricht dafür dass es sich bei "ConsoleDown" (bzw. 
"UARTLOADER.zip") um ein Tool des DVB SoC Herstellers Sunplus handelt. 
Du musst halt noch herausfinden ob die serielle Schnittstelle an den 
vier Pins anliegt oder woanders. Ich gehe aber stark davon aus dass es 
sie auf jeden Fall als unbestückten Header bzw. Testpads geben wird.

Bei den vier Pins am unbestückten Header scheinen zwei Pins wohl GND zu 
sein, dann sind die beiden anderen Rx bzw. Tx (falls es die serielle 
Schnittstelle ist). Idealerweise noch die Spannung an den beiden Pins 
messen und dann einen geeigneten UART-USB Adapter (bzw. Pegelwandler bei 
echtem RS232 Port) auswählen.

[Dieter S. (ds1)]

Der Vollständigkeit halber: die vier Pins an dem unbestückten Header 
sind für die serielle Schnittstelle, siehe Bild.

Allerdings sind die UART Pegel von Rx und Tx invertiert, dafür sind die 
zwei Transistoren und die Widerstände zuständig (der Spannungspegel 
beträgt 5 Volt).

Es gibt USB-UART Interface Chips bei denen man Tx und Rx per 
Konfiguration im EEPROM invertieren kann, z.B. beim FT232RL.

[ElC (elc)]

Hallo
Ich bin erst jetzt dazu gekommen die Geschichte in Angriff zu nehmen.
Ist ja allgemein bekannt, dass wir Rentner keine Zeit haben... :-)
Der erste Versuch mit eingebautem Chip hat nicht funktioniert.
Das kann aber durchaus an meiner ersten fehlerhaften Software gelegen 
haben.
Die SPI Geschichte in David's code war mir erst so gar nicht klar.

Also den chip ausgelötet und mittels selbst gebautem Adapter mit dem 
esp32 verbunden.
Alles etwas abenteuerlich, da kein professioneller Adapter vorhanden.

Inzwischen wurde der Winbond 25Q32FVSIG erfolgreich geflasht.
Schätze ich habe nur eine Chance den Chip wieder einzulöten.
Ein nochmaliges Auslöten/Einlöten wird die Hardware nicht überstehen.

Bevor ich jetzt weiter mache würde mich eure Meinung interessieren.
Wurde meinerseits etwas übersehen oder bin ich auf einem ganz falschen 
Pfad?
Reicht es wirklich nur den Winbond neu zu flashen?

Wie auch immer es weitergeht. Das flashen scheint zu funktionieren.

Anbei einige Fotos und der Arduino code.
Dank geht an David Johnson-Davies - www.technoblogy.com für den 
DataFlash code!

MfG

PS: Schon klar, ich soll keine langen source codes einfügen... zip im 
Anhang

// **************************************************************************************
// el Comandante                                                    guerilla.bplaced.net
// --------------------------------------------------------------------------------------
// Information:
// VSPI sd-card interface, Custom VSPI Pins, flash Winbond W25Q32FVSIG chip (4 MB)
// Read datas from a file on sd-card and flash datas to Winbond 25Q32FVSIG chip (4 MB)
// Written for the esp32 device, should work with any other mcu with SPI- Interface
// Status:
// Bricked Edision Proton T265 LED DVB-T receiver after firmware flash failure
// Goal:
// Bring the Edision Proton T265 LED DVB-T receiver back on stage
// --------------------------------------------------------------------------------------
// Firmware download:
// https://www.edision.gr/de/detail/proton-t265-led
// --------------------------------------------------------------------------------------
// Details:
// - Download the firmware
// - Copy the firmware file (renamed to: flashdat.bin) to a FAT32 formatted sd-card
// - Connect a sd-card breakout modul to the esp32 device
// - Insert the sd-card with the firmware file
// - Connect the Winbond W25Q32FVSIG chip (4 MB) to the esp32 device using the adapter
// - Start the Arduino IDE and load this ino file
// - Upload the file to the esp32 device
// - Be patient, flashing and verifying could take a few minutes
// **************************************************************************************

#include <SPI.h>
#include <SD.h>

// ######################################################################################
// Change values in this area to match your envoirement and desires
// --------------------------------------------------------------------------------------
// Winbond DataFlash commands
#define PAGEPROG      0x02
#define READSTATUS    0x05
#define READDATA      0x03
#define WRITEENABLE   0x06
#define CHIPERASE     0x60
#define READID        0x90 

// Custom VSPI Pins for the SD-Card breakout board and the flash ram - must match the wired hardware
#define sck   27
#define miso  32
#define mosi  33
#define cs    2                                           // chip select sd-card breakout board

// Custom Pins for the flash chip - must match the wired hardware
#define sckF  21
#define misoF 22
#define mosiF 23
#define csF   4                                           // chip select flash ram chip
// ######################################################################################

// Vars
uint32_t  errors;
uint8_t   errorSDCard;
uint8_t   errorFlash;
uint8_t   filedata;
uint8_t   flashdata;
uint32_t  filesize;
uint32_t  i;
uint32_t  vspiBusFrequency  = 2000000;                    // >= 4000000 sd-card mount could fail
File      file;                                           // file object
String    szFilepath = "/flashdat.bin";                   // file to load

// Create a new SPI class on HSPI or VSPI 
SPIClass vspi = SPIClass(VSPI);


// ======================================================================================
// Simple DataFlash - see http://www.technoblogy.com/show?2JMU
//
// David Johnson-Davies - www.technoblogy.com - 17th July 2019
//
// CC BY 4.0 Licensed under a Creative Commons Attribution 4.0 International license: 
// http://creativecommons.org/licenses/by/4.0/
// --------------------------------------------------------------------------------------
// Adapter circuit modified (without diodes):
// https://onecircuit.blogspot.com/2021/06/0000-0000-0110-0111.html
// --------------------------------------------------------------------------------------

class DF {
  public:
    boolean Setup();
    void BeginRead(unsigned long addr);
    void BeginWrite(void);
    uint8_t ReadByte(void);
    void WriteByte(uint8_t data);
    void EndRead(void);
    void EndWrite(void);
  private:
    unsigned long addr;
    uint8_t Read(void);
    void Write(uint8_t);
    void Busy(void);
    void WriteEnable(void);
};

boolean DF::Setup () {
  uint8_t manID, devID;
  //pinMode(power, OUTPUT); digitalWrite(power, HIGH);
  digitalWrite(csF, HIGH); pinMode(csF, OUTPUT); 
  pinMode(sckF, OUTPUT);
  pinMode(mosiF, OUTPUT);
  pinMode(misoF, INPUT);
  digitalWrite(sckF, LOW); digitalWrite(mosiF, HIGH);
  delay(1);
  digitalWrite(csF, LOW);
  delay(100);
  Write(READID); Write(0);Write(0);Write(0);
  manID = Read();
  devID = Read();
  digitalWrite(csF, HIGH);
  return (devID == 0x15);                                 // Found correct device
}

void DF::Write (uint8_t data) {
  shiftOut(mosiF, sckF, MSBFIRST, data);
}

void DF::Busy () {
  digitalWrite(csF, 0);
  Write(READSTATUS);
  while (Read() & 1 != 0);
  digitalWrite(csF, 1);
}

void DF::WriteEnable () {
  digitalWrite(csF, 0);
  Write(WRITEENABLE);
  digitalWrite(csF, 1);
}

void DF::BeginRead (unsigned long start) {
  addr = start;
  Busy();
  digitalWrite(csF, 0);
  Write(READDATA);
  Write(addr>>16);
  Write(addr>>8);
  Write(addr);
}

uint8_t DF::Read () {
  return shiftIn(misoF, sckF, MSBFIRST);
}

void DF::EndRead(void) {
  digitalWrite(csF, 1);
}

void DF::BeginWrite () {
  addr = 0;
  Busy();
  // Erase DataFlash
  WriteEnable();
  digitalWrite(csF, 0);
  Write(CHIPERASE);
  digitalWrite(csF, 1);
  Busy();
}

uint8_t DF::ReadByte () {
  return Read();
}

void DF::WriteByte (uint8_t data) {
  // New page
  if ((addr & 0xFF) == 0) {
    digitalWrite(csF, 1);
    Busy();
    WriteEnable();
    digitalWrite(csF, 0);
    Write(PAGEPROG);
    Write(addr>>16);
    Write(addr>>8);
    Write(0);
  }
  Write(data);
  addr++;
}

void DF::EndWrite (void) {
  digitalWrite(csF, 1);
}

DF DataFlash; 



// Setup
void setup()
{
  // serial monitor - init
  Serial.begin(115200);
  //while (!Serial);
  delay (2000);
  Serial.println("-----------------------------------------------------------");
  Serial.println("Testing");
  Serial.println("-----------------------------------------------------------");
  Serial.println("Serial Monitor: Okay");

  Serial.println("-----------------------------------------------------------");
  Serial.println("Test SD-Card");
  Serial.println("-----------------------------------------------------------");
  // sd-card - vspi init
  digitalWrite(cs, HIGH);                                 // slave select pin csSD (sd-card)
  vspi.begin(sck, miso, mosi, cs);                        // init sd-card spi communication protocol
  Serial.println("SD-Card VSPI: Okay");
  
  // sd-card - mount
  errorSDCard = 0;
  if (!SD.begin(cs, vspi, vspiBusFrequency))
  {Serial.println("SD-Card Mount: Error"); errorSDCard++;}
  else
  {Serial.println("SD-Card Mount: Okay");}
  
  // sd-card - check
  if(SD.cardType() == CARD_NONE)
  {Serial.println("SD-Card Type: None"); errorSDCard++;}
  else
  {Serial.println("SD-Card Type: Okay");}

  // sd-card - open file and read filesize
  file = SD.open(szFilepath, FILE_READ);
  if (file)
  {Serial.print("File Open: "); Serial.println(szFilepath); filesize = file.size(); Serial.print("File Size: "); Serial.println(filesize);}
  else
  {Serial.print("File Open: Error "); errorSDCard++;}

  filedata = file.read();
  Serial.print("File Byte 0: "); Serial.println(filedata, HEX);
  filedata = file.read();
  Serial.print("File Byte 1: "); Serial.println(filedata, HEX);
  file.seek(filesize);
  filedata = file.read();
  Serial.print("File Byte "); Serial.print(filesize, DEC); Serial.print(": "); Serial.println(filedata, HEX);
  file.seek(0);
  filedata = file.read();
  Serial.print("File Byte 0: "); Serial.println(filedata, HEX);

  Serial.println("-----------------------------------------------------------");
  Serial.println("Test Flash");
  Serial.println("-----------------------------------------------------------");
  // flash ram - setup
  errorFlash = 0;
  if (!DataFlash.Setup())
  {Serial.println("Flash chip: Not found"); errorFlash++;}
  else
  {Serial.println("Flash chip: Found");}

  // flash write test
  filedata = 0x4B;
  Serial.print("Flash Write Test: "); Serial.println(filedata, HEX);
  DataFlash.BeginWrite();
  DataFlash.WriteByte(filedata);
  DataFlash.EndWrite();

  // flash read test
  DataFlash.BeginRead(0);
  filedata = 0;
  filedata = DataFlash.ReadByte();
  Serial.print("Flash Read Test: "); Serial.println(filedata, HEX);
  DataFlash.EndRead();

  Serial.println("-----------------------------------------------------------");
  Serial.println("Test Result");
  Serial.println("-----------------------------------------------------------");
  if (errorSDCard == 0 && errorFlash == 0)
  {Serial.println("Okay");}
  else
  {Serial.println("Error"); return;}

  Serial.println("");

  Serial.println("-----------------------------------------------------------");
  Serial.println("Flashing...");
  Serial.println("-----------------------------------------------------------");
  delay (1000);

  // file pointer
  file.seek(0);

  // flash write begin
  DataFlash.BeginWrite();
  // flash write loop
  for (i = 0; i < filesize; i++)
  {
  filedata = file.read();                                   // read byte from file
  DataFlash.WriteByte(filedata);                            // write byte to flash
  }
  // flash write end
  DataFlash.EndWrite();

  // empty line
  Serial.println("");

  Serial.println("-----------------------------------------------------------");
  Serial.println("Verifying...");
  Serial.println("-----------------------------------------------------------");
  delay (1000);

  // file pointer
  file.seek(0);

  // flash read begin
  DataFlash.BeginRead(0);

  // flash read loop
  errors = 0;
  for (i = 0; i < filesize; i++)
  {
    filedata = file.read();
    flashdata = DataFlash.ReadByte();
    //Serial.print("Verify: "); Serial.print("File = "); Serial.print(filedata, HEX); Serial.print(" --- Flash = "); Serial.println(flashdata, HEX);
    if (flashdata != filedata)
    {errors++;}
  }

  // flash read end
  DataFlash.EndRead();

  // empty line
  Serial.println("");

  Serial.println("-----------------------------------------------------------");
  Serial.println("End of program");
  Serial.println("-----------------------------------------------------------");
  // file close
  file.close();
  Serial.print("Errors: "); Serial.println(errors);
}



// Loop
void loop()
{
// notting to do
}

[ElC (elc)]

Hallo
Ich bin erst jetzt dazu gekommen die Geschichte in Angriff zu nehmen.
Ist ja allgemein bekannt, dass wir Rentner keine Zeit haben... :-)

Der erste Versuch mit eingebautem Chip hat nicht funktioniert.
Das kann aber durchaus an meiner ersten fehlerhaften Software gelegen 
haben. Die SPI Geschichte in David's code war mir erst so gar nicht 
klar.

Also den chip ausgelötet und mittels selbst gebautem Adapter mit dem 
esp32 verbunden. Alles etwas abenteuerlich, da kein professioneller 
Adapter vorhanden.

Inzwischen wurde der Winbond 25Q32FVSIG erfolgreich geflasht.
Nach dem Einbau des Winbond 25Q32FVSIG ist der Edision Proton T265 LED 
back on stage.
Yeah!

Im Anhang das aktualisierte Arduino Flash Programm und einige Bilder der 
ganzen Aktion.
Das Arduino Flash Programm ist mit dem Adapter natürlich universell 
einsetzbar, nicht nur für den Edision Proton T265 LED.

Achtet bitte auf die passende Spannung, der Winbond will 3V3!
Der esp32 liefert 3V3, andere mcu's arbeiten mit 5V.

Dank geht an David Johnson-Davies - www.technoblogy.com für den 
DataFlash code!

Dieser Post wurde aktualisiert und auf den neuesten Stand gebracht.

MfG