Intel32 hexfile naar binary

Ik moet een Intel32 hexfile omzetten naar een binary file. Daar heb ik een utility hex2bin voor, maar die werkt helaas niet goed met extended adressen.
(werkt alleen goed met standaard Intel8 hexfiles)

Ik heb al diverse utilities gedownload, maar die werken allemaal niet of niet goed.
Ik zoek een simpele tool, waarmee je kunt omzetten, en niet geprogrammeerde geheugenplaatsen 0xFF kunt maken. (meestal iets als een -fill optie)

Enige programma wat (moeizaam) werkte is srec_cat. Maar daar werkt -fill weer onhandig, daar moet je begin en eindadres opgeven, wat ik niet weet.

Weet iemand een (wel) werkende utility?

Welke hex2bin heb je?

http://hex2bin.sourceforge.net/
"It can handle the extended Intel hex format"

Die heb ik geprobeerd, maar die heeft een visual C runtime debug dll nodig, die ik niet heb. En heel visual studio te installeren ben ik niet van plan... :)

Er staan 2 executables in de tar. Heb je ook die in de release directory geprobeerd?

Edit: Ik kan het zelf niet voor je proberen. Ik heb, sinds ik niet meer voor een Microsoft gekleurde organisatie werk, Linux op mijn laptop staan.

Zal ik eens proberen. Ik heb die uit de losse link gebruikt; in de zipfile zou alleen een 64 bit executable zitten, waar ik niets aan heb.

In een 8bit microcontroller kan je alle ongebruikte adressen nog wel op nul zetten. De4 adresruimte is 16 bits, maximaal iets van 64k.

Maar voor 32-bits wil je zonder het op te geven dat ie 4G aan 0xff vulling voor je aan gaat maken? Het lijkt me dat er te veel gokwerk nodig is om het "gokt meestal goed" te maken.

Is een pic24 micro met max 1024k geheugen. Alle niet gebruikte bits blijven inderdaad leeg (0xFF), omdat dit een 'nop' operatie is, en dus netjes doorloopt bij problemen.
Ik denk dat ik zelf maar even een tooltje maak, is toch simpeler als ik eerst dacht...

Maar, je moet een algemeen tooltje dan dus vertellen DAT je 1024k geheugen hebt, en waar dat begint als het op 0xff gezet moet worden. Een "gok" zou kunnen zijn: jij geeft op 1Mbyte vullen, dan beginnen we bij het hoogste adres wat in de input WEL gespecificeerd is. Dat gaat fout bij 8-bit Microchip processoren waar de option bytes ook in de intelhex staan op een "verzonnen" adres, numeriek voorbij de programma-flash...

Ik snap trouwens niet waarom je dit zou moeten doen. Als je perse 0xff in alle ongebruikte (flash-) locaties wil hebben, dan specificeer je toch dat bij het programmeren altijd eerst een erase gedaan moet worden. En ook dat is redundant bij alle devices die uit de fabriek komen.

Ik heb een STM32F405. Die heeft ook max 1Mb flash geheugen. Dat begint op 0x8000000. als je programma 129kbyte is, dus 0x20400 bytes lang is, dan vult dat 0x8000000 tot 0x8020400. Door 0x8020400 - 0x80fffff te vullen met 0xff loopt de CPU naar 0x8100000 en daar krijgt ie een illegal address fault.

Maar goed. Ja, zelf maken is relatief makkelijk.

[Bericht gewijzigd door rew op (16%)]

Voor geinteresseerden: de command-line tool. Starten met hextobin source.hex destination.bin
Maakt van een Intel hexfile een binary (.bin) file. Voor zover getest werkt alles goed. Ongebruikt geheugen wordt met 0xFF gevuld.

Wat is dit nu weer?

Geen open source :-)

Nu wel... :)


'==================================================================================================
' HEXTOBIN.BAS.    Creates a continuous binary file from an Intel hexfile
'==================================================================================================
#Compiler PBCC 5
#Compile Exe

Global dwAddr, dwTmp, dwSize, Ret As Dword
Global wPage, wOffset, wRecType, wRecLen, wLineLen As Word
Global sBuff, sData, sLine As String
Global bChksum, bFill As Byte

'==================================================================================================
Sub TextOut(pTxt As String, pColor As Byte)
'==================================================================================================
  Color 15,0
  Print: Print "HextoBin converter 1.01 - Arcovox Systems"
  Color pColor,0
  Print pTxt
  Color 7,0
End Sub

'==================================================================================================
Function CreateBinFromHex() As Long                             'Checks if file OK and gets length
'==================================================================================================
  Local lhFile, lCnt, lLoop As Long
  '------------------------------------------------------------------------------------------------
  bFill = &hFF                                                      'Fill character
  For lLoop = 0 To 1                                                'Loop pass counter
    lhFile = FreeFile                                               'Open file if exists
    If IsFile(Command$(1)) Then                                     '
      wPage = 0                                                     '
      Open Command$(1) For Input As #lhFile                         '
      While Not Eof(#lhFile)                                        'Process all lines
        Line Input #lhFile, sLine                                   '
        If Left$(sLine,1) <> ":" Then                               'If no start ":" end
          TextOut("Error: Illegal character(s) in file", 12)        '
          Exit Function                                             '
        Else                                                        '
          wRecType = Val("&h" & Mid$(sLine,8,2))                    '
          wRecLen  = Val("&h" & Mid$(sLine,2,2))                    '
          wLineLen = Len(sLine)                                     '
          Select Case wRecType                                      '------------------------------
            Case 0                                                  'Recordtype #0, process data
              wOffset = Val("&h" & Mid$(sLine, 4,4))                '
              dwTmp   = Mak(Dword, wOffset, wPage)                  '
              sData = ""                                            '
              For lCnt = 10 To (wRecLen * 2) + 9 Step 2             '
                sData = sData + Chr$(Val("&h" & Mid$(sLine,lCnt,2)))'
              Next                                                  '
              If (lLoop) And (wRecLen) Then                         '
                Mid$(sBuff, dwTmp+1, Len(sData)) = sData            '
              Else                                                  '
                If dwTmp > dwAddr Then                              '
                  dwAddr = dwtmp                                    '
                  dwSize = dwAddr + wRecLen                         '
                End If                                              '------------------------------
              End If                                                '
            Case 1                                                  'Recordtype #1, end of file
            Case 2,3                                                'Recordtype 2,3 not supported
              TextOut("Error: Segmented address unsupported", 12)   '
              Exit Function                                         '
            Case 4                                                  '------------------------------
              wPage = Val ("&h" & Mid$(sLine,10,4))                 'Recordtype #4, get linear page
          End Select                                                'address
          bChksum = 0                                               '------------------------------
          For lCnt = 2 To wLineLen-1 Step 2                         'Test if checksum valid
            bChkSum = bChksum + Val("&h" & Mid$(sLine, lCnt, 2))    'If not, end with errormsg
          Next                                                      '
          If bChksum <> 0 Then                                      '
            TextOut("Checksum error on hex file",12)                '
            Exit Function                                           '
          End If                                                    '
        End If                                                      '
      Wend                                                          '
      Close #lhFile                                                 '
      Function = 1                                                  '
    Else                                                            '
      TextOut("Error: File '" & Command$(1) & "' not found",12)     'File doesn't exist, end
      Exit Function                                                 '
    End If                                                          'with errormsg
    If lLoop = 0 Then sBuff = String$(dwSize, bFill)                '
  Next lLoop                                                        '
  If IsFile(Command$(2)) Then Kill Command$(2)                      '
  lhFile = FreeFile                                                 '
  Open Command$(2) For Binary As #lhFile                            '
  Put$ #lhFile, sBuff                                               '
  Close #lhFile
End Function                                                        '


'==================================================================================================
Function PBMain()
'==================================================================================================
  Local lBuffer As String, lRet, lError, lhFile As Dword
  '------------------------------------------------------------------------------------------------
  If (Command$(1) = "") Or (Command$(2) = "") Then
    TextOut("Command line error, usage: hextobin <source.hex> <destination.bin>",14)
  Else
    If CreateBinFromHex Then
      TextOut("Succesfully created file: " & Command$(2) & " (size " & Format$(dwSize) & " bytes)",14)
    End If
  End If
End Function

[Bericht gewijzigd door Arco op (100%)]