- Akku Tests und Balkonkraftwerk Speicher         
Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 17 von 17

Thema: RP6FlashWriter: Der Opensource RP6 Loader

  1. #11
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    21.04.2009
    Beiträge
    523
    Anzeige

    Praxistest und DIY Projekte
    Oha, Interesse für das Projekt Naja fast jedenfalls

    Wenn ich wieder zu Hause bin (heute abend oder morgen), werde ich dir den fehlenden Code zukommen lassen

  2. #12
    Neuer Benutzer Öfters hier
    Registriert seit
    12.02.2007
    Beiträge
    5
    Hallo Fabian!

    Danke für den Flashwriter!
    Ich nutze das Programm unter Ubuntu 10.04 und es funktioniert wunderbar.
    Der RP6Loader mit Klicki-Bunti ist unter Linux wirklich eine Gurke.
    Ist halt wie beim Asuro auch: Asuro-Flash sieht zwar nett aus, ist aber nicht zu gebrauchen!
    Das Programm asurocon ist zwar "nur" ein Konsolenprogramm, funktioniert aber bestens.

    Ich wollte Dir dies nur als Feedback geben und hoffe, daß Du die Linuxversion auch weiter pflegst.

    thx thomas

    p.s.: Hast Du einen Tip, wie man den Flashwriter in makefile einbindet? (Du erwähntest das in der Anleitung, glaub ich)

  3. #13
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    21.04.2009
    Beiträge
    523
    Ja, das ist nicht so ganz einfach...
    Im makefile gibt es bei den "bösen" Sachen am Ende einen Befehle "program".
    Der muss umgeschrieben werden.
    Unter Windows sieht es danach so aus:
    Code:
    # Program the device.
    program: $(TARGET).hex
           ..\..\Library\RP6FlashWriterC\RP6FlashWriterC.exe -f $(TARGET).hex
    RP6FlashWriterC ist einfach die Windows-Consolen-Version, hier musst du dann natürlich entsprechend den passenden Linux Befehl eingeben.

    Danach kannst du ein Script erstellen mit dem Inhalt
    Code:
    make program
    Das flashst dir den RP6 dann

    Du kannst natürlich auch make program noch zum build-script hinzufügen, wenn du das möchtest.

  4. #14
    Neuer Benutzer Avatar von redapple
    Registriert seit
    23.08.2014
    Ort
    Nordrhein-Westfalen
    Beiträge
    4
    Hi Florian und -Schumi-,
    als alter Linuxer und Konsolenfetischist hab mich sehr gefreut, die Kommandozeilenversion des FlashWriters gefunden zu haben!

    Ich hab das Projekt jetzt erstmal nur überflogen und habe noch nicht wirklich viel Erfahrung mit der Robotik,
    aber interessant fände ich noch, das RP6-M256-WIFI Modul über das WLAN flashen zu können.

    Ich sag jetzt einfach mal, dass die Erweiterung so kompliziert ja nicht sein kann, wenn man das Script
    von Schumi als Basis nimmt. Ich werde mich weiter informieren.

    Jedenfalls vielen Dank für das tolle Script!

    Liebe Grüße,
    Daniel

    [EDIT]
    Ich hab ein bisschen an einem WifiWriter Script gebastelt. Basiert auf dem FlashWriter-Script von Schumi.
    Funktioniert alles bis einschließlich INIT_FLASH(). Nur mit der FLASH() Funktion selber hab ich noch Probleme.

    Zum einen weiß ich nicht, wann genau ich das '[P]\n' senden muss, dass SlyD hier erwähnt.

    Zweitens müssen die CHECKBYTE() Aufrufe angepasst werden?!?

    Hier mal das Script soweit:
    Code:
    #!/usr/bin/env python
    
    import serial
    import time
    import sys
    import os
    import socket, select
    import re
    
    Hostname = ""           			    # *** Set default Hostname here
    Port = "2000"                                       # *** Set default Port here
    Hexfilename = ""	                	    # *** Set default hexfile here
    Debuglevel = 1					    # *** Set default Debuglevel here (0, 1, 2, 3)
    BufferSize = 1024                                   # size for socket.recv() buffer
    Timestart = time.time()
    
    Connection = None
    Hexfile = None
    
    def CONNECTION_READ():
        data = Connection.recv(BufferSize)
        if Debuglevel >= 3:
    	if data <> '':
                print("|I " + str(data))
        return data
    	
    def CONNECTION_WRITE(data):
        if Debuglevel >= 3:
    	if data <> '':
    	    print("|O " +str(data))
        Connection.send(data)
        return
    
    def CLOSE_ALL ():
    	if not (Connection is None):
    		Connection.close()
    	if not (Hexfile is None):
    		Hexfile.close()
    	return
    
    def ERROR (Message):
    	print
    	print ' ## ERROR: #########################################'
    	print ' # '+Message
    	print ' ###################################################'
    	print
    	CLOSE_ALL()
    	quit(1)
    
    def GET_BOARDINFO ():
        Boardinfo = -1
        CONNECTION_WRITE(chr(72))
        Infostring = ''
        Timeout = 0
        while len(Infostring) < 9:
    	Infostring = CONNECTION_READ()
    	Timeout = Timeout + 1
    	if Timeout > 1000:
    	    ERROR ('Got no boardinfo!')
        Boardnr = ord(Infostring[4])
        if (Boardnr == 8):
    	Boardinfo = 'M256-Board'
        return Boardinfo
    	
    def WAIT_FOR_BOOT ():
    	Readbuff = ''
    	Timeout = 0
    	while Readbuff <> '\n[WIFIBOOT]\n':
    		Readbuff = CONNECTION_READ()
    		Timeout = Timeout + 1
    		if Timeout > 1000:
    			ERROR ('No message "[WIFIBOOT]"!')
    	return
    	
    def WAIT_FOR_READY ():
    	Readbuff = ''
    	Timeout = 0
    	while Readbuff <> '\n[READY]\n':
    		Readbuff = CONNECTION_READ()
    		Timeout = Timeout + 1
    		if Timeout > 1000:
    			ERROR ('No message "[READY]"!')
    	return
    
    def RESET ():
            # Enter CMD mode
            CONNECTION_WRITE('$$$\r\n')
            response = CONNECTION_READ()
            if(re.search(r'CMD\r\n',response) == None):
                ERROR('Not expected response: ' + response)
            # set reset pin
            CONNECTION_WRITE('set sys output 0x0080 0x0080\r\n')
            response = CONNECTION_READ()
            if(re.search(r'set sys output 0x0080 0x0080\r\n', response) == None):
                ERROR('Not expected response: ' + response)
            response = CONNECTION_READ()
            if(re.search(r'\r\nAOK\r\n<.*> ', response) == None):
                ERROR('Not expected response: ' + response)
            # clear reset pin
            CONNECTION_WRITE('set sys output 0x0000 0x0080\r\n')
            response = CONNECTION_READ()
            if(re.search(r'set sys output 0x0000 0x0080\r\n', response) == None):
                ERROR('Not expected response: ' + response)
            response = CONNECTION_READ()
            if(re.search(r'\r\nAOK\r\n<.*> ', response) == None):
                ERROR('Not expected response: ' + response)
            # exit CMD mode
            CONNECTION_WRITE('exit\r\n')
            response = CONNECTION_READ()
            if(re.search(r'exit\r\n', response) == None):
                ERROR('Not expected response: ' + response)
    
    	return
    
    def HEX_ENCRYPT (Flashdata):
    	Bytecounter = 0
    	Linecounter = 1
    	for Line in Hexfile:
    		Line = Line[1:]
    		Checksum = 0
    		Charpos = 0
    		while Charpos < len(Line)-2:
    			Hexchar =  Line[Charpos:Charpos+2]
    			Checksum = Checksum + int(Hexchar, 16)
    			Charpos = Charpos + 2
    		Checksum = Checksum & 255
    		Checksum = 1 + ( ~Checksum)
    		if Checksum<>0:
    			ERROR("Checksum in Hexfile ("+str(Linecounter)+") false!")
    		else:
    			if Debuglevel >= 2:
    				print "Checksum in Line "+str(Linecounter)+" is OK"
    		Line = Line[8:]
    		Line = Line[:-4]
    		Charpos=0
    		while Charpos < len(Line):
    			Hexchar =  Line[Charpos:Charpos+2]
    			Hexwert = int(Hexchar, 16)
    			Flashdata = Flashdata + chr(Hexwert)
    			Charpos = Charpos + 2
    			Bytecounter = Bytecounter + 1
    			if Bytecounter==256:
    				Bytecounter = 0
    		Linecounter = Linecounter + 1
    	while Bytecounter<256:
    		Flashdata = Flashdata + chr(255)
    		Bytecounter = Bytecounter + 1
    	return Flashdata
    	
    def CHECKBYTE (databyte, errormessage):
    	Timeout = 0
    	while CONNECTION_READ()<>chr(databyte):
    		Timeout = Timeout + 1
    		if Timeout > 1000:
    			ERROR (errormessage)
    	return
    			
    def INIT_UPLOAD ():
    	CONNECTION_WRITE(chr(73))
    	Timeout = 0
    	while CONNECTION_READ()<>chr(103):
    		Timeout = Timeout + 1
    		if Timeout > 1000:
    			ERROR ('RP6 cancels upload-init!')
    	return
    	
    def INIT_FLASH ():
        CONNECTION_WRITE(chr(75))
        Timeout = 0
        while CONNECTION_READ()<>chr(91):
    	Timeout = Timeout + 1
    	if Timeout > 1000:
    	    ERROR ('RP6 cancels flash-init!')
        return
    		
    def CRC (Checksum, Databyte):
    	Tmp = (Databyte & 255) ^ (Checksum & 255)
    	Databyte = Tmp ^ (Tmp << 4)
    	Tmp1 = ((Databyte & 255) << 8 | Checksum >> 8 & 255)
    	Tmp2 = (Databyte & 255) >> 4
    	Tmp3 = (Databyte & 255) << 3
    	return Tmp1 ^ Tmp2 ^ Tmp3
    		
    def FLASH (Flashdata):
    	Blockcounter = 0
    	Bytecounter = 0
    	while Bytecounter < len(Flashdata):
                    CONNECTION_WRITE('[P]\n')
                    print(CONNECTION_READ())
    		Blockcounter = Blockcounter + 1
    		Checksum = 65535
    		CONNECTION_WRITE(chr(170))
    		CONNECTION_WRITE(chr(128))
    		CONNECTION_WRITE(chr(0))
    		CONNECTION_WRITE(chr(Blockcounter-1))
    		Checksum = CRC(Checksum, 170)
    		Checksum = CRC(Checksum, 128)
    		Checksum = CRC(Checksum, 0)
    		Checksum = CRC(Checksum, Blockcounter-1)
    		Blockbytenr = 0
    		while Blockbytenr < 256:
    			Blockbytenr = Blockbytenr + 1
    			Databyte = ord(Flashdata[Bytecounter])
    			CONNECTION_WRITE(chr(Databyte))
    			Checksum = CRC(Checksum, Databyte)
    			Bytecounter = Bytecounter + 1
    		CONNECTION_WRITE(chr(Checksum & 255))
    		CONNECTION_WRITE(chr((Checksum >> 8) & 255))
    		CONNECTION_WRITE(chr(170))
    		
    		if Debuglevel >= 1:
    			print " Block",
    			print Blockcounter,
    			print "DONE.	Bytes:",
    			print Bytecounter,		
    			print "	Checksum:",
    			print Checksum
    		if Boardinfo == 'Base-Board':
    			CHECKBYTE(66, 'RP6 cancels Block '+str(Blockcounter)+'!')
    			CHECKBYTE(93, 'RP6 cancels Block '+str(Blockcounter)+'!')
    			CHECKBYTE(91, 'RP6 cancels Block '+str(Blockcounter)+'!')
    		if Boardinfo == 'M32-Board':
    			CHECKBYTE(66, 'RP6 cancels Block '+str(Blockcounter)+'!')
    			CHECKBYTE(32, 'RP6 cancels Block '+str(Blockcounter)+'!')
    			CHECKBYTE(93, 'RP6 cancels Block '+str(Blockcounter)+'!')
    			CHECKBYTE(91, 'RP6 cancels Block '+str(Blockcounter)+'!')
                    if Boardinfo == 'M256-Board':
                            check = CONNECTION_READ()
                            print('# Check: ' + check)
                            print('# Check length: ' + str(len(check)))
                            
    	return
    	
    	
    
    Flashdata = ''
    
    print 
    print "  ###################################################"
    print "  #                                                 #"
    print "  #          ****** RP6 FlashWriter ******          #"
    print "  #                by Simon Schumann                #"
    print "  #                                                 #"
    print "  #              simon.schumann@web.de              #" 
    print "  #                                                 #"
    print "  ###################################################"
    print 
    
    print "DOING: Converting arguments"
    if((len(sys.argv) < 3) | len(sys.argv) > 4):
        print('Usage: WifiWriter.py <hexfilename> <host> [<port>]')
        sys.exit()
    Hexfilename = sys.argv[1]
    Host = sys.argv[2]
    if(len(sys.argv) == 4):
        Port = sys.argv[3]
    
    print " File:        ",
    print Hexfilename
    print " Host:        ",
    print Host
    print " Port:        ",
    print Port
    print " Debuglevel:  ",
    print Debuglevel
    print "                                                  DONE"
    
    print "DOING: Open hexfile                              ",
    if not os.path.isfile(Hexfilename):
    	ERROR("Open hexfile: No such file!")
    Hexfile = open(Hexfilename, "r")
    print "DONE"
    
    print "DOING: Parsing hexfile"
    Flashdata = HEX_ENCRYPT(Flashdata)
    print "                                                  DONE"
    
    print "DOING: Open connection to Robot                  ",
    Connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    Connection.settimeout(2)
    
    try:
        Connection.connect((Host,int(Port)))
    except:
        ERROR("NETWORK ERROR: Can't connect to " + Host + ":" + Port)
    
    print "DONE"
    
    print "DOING: Reset                                     ",
    RESET()
    print "DONE"
    
    print "DOING: Waiting for bootmessage                   ",
    WAIT_FOR_BOOT()
    print "DONE"
    
    print "DOING: [WIFIBOOT_START]                          ",
    CONNECTION_WRITE('[WIFIBOOT_START]\n')
    response = CONNECTION_READ()
    if(response != '[ACK]\n'):
        ERROR('No expected response: ' + response)
    print "DONE"
    
    print "DOING: Get boardinfo"
    Boardinfo = GET_BOARDINFO()
    if Boardinfo == -1:
    	ERROR("Connected board not known!")
    print "  ->",
    print Boardinfo
    print "                                                  DONE"
    
    print "DOING: Init upload                               ",
    INIT_UPLOAD()
    print "DONE"
    
    print "DOING: Init Flash                                ",
    INIT_FLASH()
    print "DONE"
    
    #print "DOING: Flashing                                  "
    #FLASH(Flashdata)
    #print "                                                  DONE"
    
    print "DOING: [E]                                       ",
    CONNECTION_WRITE('[E]\n')
    response = CONNECTION_READ()
    if(response != '\n[READY]\n'):
        ERROR('No expected response: ' + response)
    print "DONE"
    
    print "DOING: Reset                                     ",
    RESET()
    print "DONE"
    
    Timeend = time.time()
    
    print
    print '          ****** FLASHED SUCCESSFUL *******'
    print '                  in: '+str(round(Timeend-Timestart, 2))+' seconds'
    
    CLOSE_ALL()
    
    quit(0)
    Ist noch nicht besonders schön, aber wenn jemand wegen oben genannter Probleme mit der FLASH() Funktion Infos/Lösungen hat, wäre mir sehr geholfen.
    Geändert von redapple (26.03.2015 um 05:17 Uhr)

  5. #15
    Hallo,
    ich habe mich auch gefreut dieses Projekt gefunden zu haben.
    Leider sind die Links jedoch bereits alle tot.
    Kann jemand den RP6FlashWriter für Linux neu hochladen?

  6. #16
    Hallo,
    Da wäre ich auch interessiert sowohl die Linux als auch die Windows Version.
    Wäre wirklich super.

  7. #17
    Hi daMicha,
    schön zu sehen, dass es noch andere gibt welche Interesse daran haben.
    Habe eine gute Nachricht für dich. Ich habe einen komplett neuen Client geschrieben. Er ist aber noch nicht Release tauglich. Wegen Umzug habe ich gerade nicht die Kapazitäten den finalen Schliff zu geben. Kann also noch paar Wochen dauern.
    Ich schaue jedoch, dass ich bis nächste Woche eine Beta bereitstelle.

    Meine Zwischenlösung war eine Windows 7 VM auf welcher ich den mitgelieferten RP6Loader installieren konnte und das trotz Log4j im JAVA funktioniert hat.

    Ich habe es als Python Webclient geschrieben.
    Du kannst von dort aus dein Skript rein laden. Es bauen und direkt Flashen.
    UART Support ist auch da

Seite 2 von 2 ErsteErste 12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

Solar Speicher und Akkus Tests