OpenCores
URL https://opencores.org/ocsvn/openmsp430/openmsp430/trunk

Subversion Repositories openmsp430

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openmsp430/trunk/tools/openmsp430-gdbproxy
    from Rev 124 to Rev 158
    ↔ Reverse comparison
  •

Rev 124 → Rev 158

/commands.tcl
48,36 → 48,36
set cmd_tail [string range $rsp_cmd 1 [string length $rsp_cmd]]
 
switch -exact -- [string index $rsp_cmd 0] {
"!" {set rsp_answer "OK"}
"?" {set rsp_answer [rsp_stop_reply $sock "?"]}
"A" {}
"b" {}
"c" {set rsp_answer [rsp_c $sock $cmd_tail]}
"C" {set rsp_answer [rsp_c $sock $cmd_tail]}
"D" {}
"F" {}
"g" {set rsp_answer [rsp_g]}
"G" {set rsp_answer [rsp_G $cmd_tail]}
"H" {set rsp_answer ""}
"i" {}
"I" {}
"k" {set rsp_answer [rsp_k $cmd_tail]}
"m" {set rsp_answer [rsp_m $cmd_tail]}
"M" {set rsp_answer [rsp_M $cmd_tail]}
"p" {}
"P" {}
"q" {set rsp_answer [rsp_q $sock $cmd_tail]}
"Q" {}
"R" {}
"s" {set rsp_answer [rsp_s $sock $cmd_tail]}
"S" {set rsp_answer [rsp_s $sock $cmd_tail]}
"t" {}
"T" {}
"v" {}
"X" {}
"z" {set rsp_answer [rsp_z $sock $cmd_tail]}
"Z" {set rsp_answer [rsp_Z $sock $cmd_tail]}
default {}
"!" {set rsp_answer "OK"}
"?" {set rsp_answer [rsp_stop_reply $sock "?"]}
"A" {}
"b" {}
"c" {set rsp_answer [rsp_c $sock $cmd_tail]}
"C" {set rsp_answer [rsp_c $sock $cmd_tail]}
"D" {}
"F" {}
"g" {set rsp_answer [rsp_g]}
"G" {set rsp_answer [rsp_G $cmd_tail]}
"H" {set rsp_answer ""}
"i" {}
"I" {}
"k" {set rsp_answer [rsp_k $cmd_tail]}
"m" {set rsp_answer [rsp_m $cmd_tail]}
"M" {set rsp_answer [rsp_M $cmd_tail]}
"p" {}
"P" {}
"q" {set rsp_answer [rsp_q $sock $cmd_tail]}
"Q" {}
"R" {}
"s" {set rsp_answer [rsp_s $sock $cmd_tail]}
"S" {set rsp_answer [rsp_s $sock $cmd_tail]}
"t" {}
"T" {}
"v" {}
"X" {}
"z" {set rsp_answer [rsp_z $sock $cmd_tail]}
"Z" {set rsp_answer [rsp_Z $sock $cmd_tail]}
default {}
}
 
 
96,15 → 96,17
#-----------------------------------------------------------------------------#
proc rsp_g {} {
global CpuNr
 
# Read register value
set reg_val [ReadRegAll]
set reg_val [ReadRegAll $CpuNr]
 
# Format answer
set rsp_answer ""
for {set i 0} {$i < [llength $reg_val]} {incr i} {
 
regexp {0x(..)(..)} [lindex $reg_val $i] match msb lsb
append rsp_answer "$lsb$msb"
regexp {0x(..)(..)} [lindex $reg_val $i] match msb lsb
append rsp_answer "$lsb$msb"
}
 
return $rsp_answer
115,6 → 117,8
#-----------------------------------------------------------------------------#
proc rsp_G {cmd} {
global CpuNr
 
# Format register value
set num_reg [expr [string length $cmd]/4]
 
121,13 → 125,13
set reg_val ""
for {set i 0} {$i < $num_reg} {incr i} {
 
set lsb "[string index $cmd [expr $i*4+0]][string index $cmd [expr $i*4+1]]"
set msb "[string index $cmd [expr $i*4+2]][string index $cmd [expr $i*4+3]]"
lappend reg_val "0x$msb$lsb"
set lsb "[string index $cmd [expr $i*4+0]][string index $cmd [expr $i*4+1]]"
set msb "[string index $cmd [expr $i*4+2]][string index $cmd [expr $i*4+3]]"
lappend reg_val "0x$msb$lsb"
}
 
# Write registers
WriteRegAll $reg_val
WriteRegAll $CpuNr $reg_val
 
return "OK"
}
137,8 → 141,10
#-----------------------------------------------------------------------------#
proc rsp_k {cmd} {
global CpuNr
 
# Reset & Stop CPU
ExecutePOR_Halt
ExecutePOR_Halt $CpuNr
return "-1"
}
149,6 → 155,7
proc rsp_M {cmd} {
global mem_breakpoint
global CpuNr
# Parse command
regexp {(.*),(.*):(.*)} $cmd match addr length data
158,26 → 165,26
# Format data
set mem_val ""
for {set i 0} {$i<$length} {incr i} {
lappend mem_val "0x[string range $data [expr $i*2] [expr $i*2+1]]"
lappend mem_val "0x[string range $data [expr $i*2] [expr $i*2+1]]"
}
 
# Write memory
if {$length==2} {
regexp {(..)(..)} $data match data_lo data_hi
WriteMem 0 "0x$addr" "0x${data_hi}${data_lo}"
regexp {(..)(..)} $data match data_lo data_hi
WriteMem $CpuNr 0 "0x$addr" "0x${data_hi}${data_lo}"
} else {
WriteMemQuick8 "0x$addr" $mem_val
WriteMemQuick8 $CpuNr "0x$addr" $mem_val
}
 
# Eventually re-set the software breakpoints in case they have been overwritten
set addr_start [format %d "0x$addr"]
foreach {brk_addr brk_val} [array get mem_breakpoint] {
set brk_addr_dec [format %d "0x$brk_addr"]
set brk_addr_offset [expr $brk_addr_dec-$addr_start]
if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
set mem_breakpoint($brk_addr) [lindex $mem_val $brk_addr_offset]
WriteMem 0 "0x$brk_addr" 0x4343
}
set brk_addr_dec [format %d "0x$brk_addr"]
set brk_addr_offset [expr $brk_addr_dec-$addr_start]
if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
set mem_breakpoint($brk_addr) [lindex $mem_val $brk_addr_offset]
WriteMem $CpuNr 0 "0x$brk_addr" 0x4343
}
}
 
return "OK"
190,6 → 197,7
proc rsp_m {cmd} {
global mem_breakpoint
global CpuNr
 
# Parse command
regexp {(.*),(.*)} $cmd match addr length
197,17 → 205,17
set length [format %d "0x$length"]
 
# Read memory
set data [ReadMemQuick8 "0x$addr" $length]
set data [ReadMemQuick8 $CpuNr "0x$addr" $length]
 
# Eventually replace read data by the original software breakpoint value
set addr_start [format %d "0x$addr"]
foreach {brk_addr brk_val} [array get mem_breakpoint] {
set brk_addr_dec [format %d "0x$brk_addr"]
set brk_addr_offset [expr $brk_addr_dec-$addr_start]
if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
set data [lreplace $data $brk_addr_offset $brk_addr_offset "0x$mem_breakpoint($brk_addr)"]
}
set brk_addr_dec [format %d "0x$brk_addr"]
set brk_addr_offset [expr $brk_addr_dec-$addr_start]
if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
set data [lreplace $data $brk_addr_offset $brk_addr_offset "0x$mem_breakpoint($brk_addr)"]
}
}
 
# Format data
224,6 → 232,7
proc rsp_Z {sock cmd} {
 
global mem_breakpoint
global CpuNr
 
# Parse command
regexp {(.),(.*),(.*)} $cmd match type addr length
230,41 → 239,41
set addr [format %04x "0x$addr"]
 
switch -exact -- $type {
"0" {# Memory breakpoint
set mem_breakpoint($addr) [ReadMem 0 "0x$addr"]
WriteMem 0 "0x$addr" 0x4343
return "OK"
"0" {# Memory breakpoint
set mem_breakpoint($addr) [ReadMem $CpuNr 0 "0x$addr"]
WriteMem $CpuNr 0 "0x$addr" 0x4343
return "OK"
}
 
"1" {# Hardware breakpoint
if {[SetHWBreak 1 [format "0x%04x" 0x$addr] 1 0]} {
return "OK"
}
return ""
"1" {# Hardware breakpoint
if {[SetHWBreak $CpuNr 1 [format "0x%04x" 0x$addr] 1 0]} {
return "OK"
}
return ""
}
 
"2" {# Write watchpoint
if {[SetHWBreak 0 [format "0x%04x" 0x$addr] 0 1]} {
return "OK"
}
return ""
"2" {# Write watchpoint
if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 0 1]} {
return "OK"
}
return ""
}
 
"3" {# Read watchpoint
if {[SetHWBreak 0 [format "0x%04x" 0x$addr] 1 0]} {
return "OK"
}
return ""
"3" {# Read watchpoint
if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 0]} {
return "OK"
}
return ""
}
 
"4" {# Access watchpoint
if {[SetHWBreak 0 [format "0x%04x" 0x$addr] 1 1]} {
return "OK"
}
return ""
"4" {# Access watchpoint
if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 1]} {
return "OK"
}
return ""
}
 
default {return ""}
default {return ""}
}
}
 
274,6 → 283,7
proc rsp_z {sock cmd} {
 
global mem_breakpoint
global CpuNr
 
# Parse command
regexp {(.),(.*),(.*)} $cmd match type addr length
280,41 → 290,41
set addr [format %04x "0x$addr"]
 
switch -exact -- $type {
"0" {# Memory breakpoint
WriteMem 0 "0x$addr" $mem_breakpoint($addr)
unset mem_breakpoint($addr)
return "OK"
"0" {# Memory breakpoint
WriteMem $CpuNr 0 "0x$addr" $mem_breakpoint($addr)
unset mem_breakpoint($addr)
return "OK"
}
 
"1" {# Hardware breakpoint
if {[ClearHWBreak 1 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
"1" {# Hardware breakpoint
if {[ClearHWBreak $CpuNr 1 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
}
 
"2" {# Write watchpoint
if {[ClearHWBreak 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
"2" {# Write watchpoint
if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
}
 
"3" {# Read watchpoint
if {[ClearHWBreak 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
"3" {# Read watchpoint
if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
}
 
"4" {# Access watchpoint
if {[ClearHWBreak 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
"4" {# Access watchpoint
if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
return "OK"
}
return ""
}
 
default {return ""}
default {return ""}
}
}
 
323,17 → 333,19
#-----------------------------------------------------------------------------#
proc rsp_c {sock cmd} {
global CpuNr
 
# Set address if required
if {$cmd!=""} {
set cmd [format %04x "0x$cmd"]
SetPC "0x$cmd"
set cmd [format %04x "0x$cmd"]
SetPC $CpuNr "0x$cmd"
}
 
# Clear status
ClrStatus
ClrStatus $CpuNr
 
# Continue
ReleaseCPU
ReleaseCPU $CpuNr
 
 
return [rsp_stop_reply $sock "c"]
344,20 → 356,22
#-----------------------------------------------------------------------------#
proc rsp_s {sock cmd} {
global CpuNr
 
# Set address if required
if {$cmd!=""} {
set cmd [format %04x "0x$cmd"]
SetPC "0x$cmd"
set cmd [format %04x "0x$cmd"]
SetPC $CpuNr "0x$cmd"
}
 
# Clear status
ClrStatus
ClrStatus $CpuNr
 
# Read current PC value
set pc [ReadReg 0]
set pc [ReadReg $CpuNr 0]
 
# Incremental step
StepCPU
StepCPU $CpuNr
 
return [rsp_stop_reply $sock "s" $pc]
}
370,40 → 384,42
#-----------------------------------------------------------------------------#
proc rsp_stop_reply {sock cmd {opt_val "0"}} {
 
global CpuNr
 
# Wait until halted
while {![IsHalted]} {
while {![IsHalted $CpuNr]} {
 
# Wait a few milliseconds to prevent the gui from freezing
after 100 {set end 1}
vwait end
# Wait a few milliseconds to prevent the gui from freezing
after 100 {set end 1}
vwait end
 
# Check if we are interrupted by GDB
fconfigure $sock -blocking 0
set break_char [read -nonewline $sock]
fconfigure $sock -blocking 1
binary scan $break_char H* break_char
if {$break_char=="03"} {
putsVerbose "--> BREAK"
HaltCPU
}
# Check if we are interrupted by GDB
fconfigure $sock -blocking 0
set break_char [read -nonewline $sock]
fconfigure $sock -blocking 1
binary scan $break_char H* break_char
if {$break_char=="03"} {
putsVerbose "--> BREAK"
HaltCPU $CpuNr
}
}
 
# Read some important registers
set pc [ReadReg 0]
set pc [ReadReg $CpuNr 0]
regexp {0x(..)(..)} $pc match pc_hi pc_lo
set r4 [ReadReg 4]
set r4 [ReadReg $CpuNr 4]
regexp {0x(..)(..)} $r4 match r4_hi r4_lo
 
# In case of a single step command, make sure that the PC
# value changes. If not, return an error otherwise GDB will
# end-up in an infinite loop.
if {$cmd == "s"} {
if {$opt_val == $pc} {
return "E05"
}
}
#return "S05"
return "T0500:$pc_lo$pc_hi;04:$r4_lo$r4_hi;"
# In case of a single step command, make sure that the PC
# value changes. If not, return an error otherwise GDB will
# end-up in an infinite loop.
if {$cmd == "s"} {
if {$opt_val == $pc} {
return "E05"
}
}
#return "S05"
return "T0500:$pc_lo$pc_hi;04:$r4_lo$r4_hi;"
}
 
 
414,10 → 430,10
switch -regexp -- $cmd {
 
"C" {set rsp_answer ""}
"Offsets" {set rsp_answer "Text=0;Data=0;Bss=0"}
"Rcmd,.+" {set rsp_answer [rsp_qRcmd $sock $cmd]}
default {set rsp_answer ""}
"C" {set rsp_answer ""}
"Offsets" {set rsp_answer "Text=0;Data=0;Bss=0"}
"Rcmd,.+" {set rsp_answer [rsp_qRcmd $sock $cmd]}
default {set rsp_answer ""}
}
return $rsp_answer
}
433,20 → 449,22
#-----------------------------------------------------------------------------#
proc rsp_qRcmd {sock cmd} {
 
global CpuNr
 
regsub {^Rcmd,} $cmd {} cmd
set cmd [binary format H* $cmd]; # Convert hex to ascii
 
switch -exact -- $cmd {
"erase all" {;# Convert ascii to hex
binary scan "Erasing target program memory..." H* text1
binary scan " Erased OK\n" H* text2
;# Execute erase command
sendRSPpacket $sock "O$text1"
EraseROM
sendRSPpacket $sock "O$text2"
set rsp_answer "OK"
"erase all" {;# Convert ascii to hex
binary scan "Erasing target program memory..." H* text1
binary scan " Erased OK\n" H* text2
;# Execute erase command
sendRSPpacket $sock "O$text1"
EraseROM $CpuNr
sendRSPpacket $sock "O$text2"
set rsp_answer "OK"
}
default {set rsp_answer "OK"}
default {set rsp_answer "OK"}
}
 
return $rsp_answer
/server.tcl
48,38 → 48,40
 
global server
if {![info exists server(socket)]} {
putsLog "Open socket on port $server(port) ... " 1
if {[catch {socket -server clientAccept $server(port)} server(socket)]} {
putsLog "failed"
putsLog "ERROR: $server(socket)."
unset server(socket)
return 0
}
putsLog "done"
putsLog "INFO: Waiting on TCP port $server(port)"
putsLog "Open socket on port $server(port) ... " 1
if {[catch {socket -server clientAccept $server(port)} server(socket)]} {
putsLog "failed"
putsLog "ERROR: $server(socket)."
unset server(socket)
return 0
}
putsLog "done"
putsLog "INFO: Waiting on TCP port $server(port)"
} else {
putsLog "Server is already up."
putsLog "Server is already up."
}
return 1
}
 
proc stopServer { } {
global serial_status
global omsp_info
global server
global CpuNr
 
if {[info exists server(socket)]} {
set port [lindex [fconfigure $server(socket) -sockname] 2]
putsLog "Stop server (port $port)"
close $server(socket)
unset server(socket)
set port [lindex [fconfigure $server(socket) -sockname] 2]
putsLog "Stop server (port $port)"
close $server(socket)
unset server(socket)
}
if {$serial_status} {
ReleaseDevice 0xfffe
if {$omsp_info($CpuNr,connected)} {
ReleaseDevice $CpuNr 0xfffe
}
}
 
proc clientAccept {sock addr port} {
global clients
global CpuNr
 
putsLog "Accept client: $addr ($port)\n"
 
87,57 → 89,57
fconfigure $sock -buffering none
fileevent $sock readable [list receiveRSPpacket $sock]
 
InitBreakUnits
InitBreakUnits $CpuNr
}
 
proc startServerGUI { } {
global serial_device
global hw_break
global omsp_conf
global omsp_info
global CpuNr
 
# Connect to device
if {![GetDevice]} {
.info.cpu.con configure -text "Connection problem" -fg red
putsLog "ERROR: Could not open \"$serial_device\""
putsLog ""
putsLog " -------------------------------------------------------------"
putsLog " !!!! Please consider the following options: !!!!"
putsLog " !!!! !!!!"
putsLog " !!!! - check the physical connection to the board. !!!!"
putsLog " !!!! - adjust the serial connection baudrate. !!!!"
putsLog " !!!! - don't forget to reset the serial debug interface !!!!"
putsLog " !!!! between each attempt. !!!!"
putsLog " -------------------------------------------------------------"
putsLog ""
return 0
if {![GetDevice $CpuNr]} {
.info.cpu.con configure -text "Connection problem" -fg red
putsLog "ERROR: Could not open \"$omsp_conf(device)\""
putsLog ""
putsLog " -------------------------------------------------------------"
putsLog " !!!! Please consider the following options: !!!!"
putsLog " !!!! !!!!"
putsLog " !!!! - check the physical connection to the board. !!!!"
putsLog " !!!! - adjust the serial connection baudrate. !!!!"
putsLog " !!!! - don't forget to reset the serial debug interface !!!!"
putsLog " !!!! between each attempt. !!!!"
putsLog " -------------------------------------------------------------"
putsLog ""
return 0
}
 
if {$omsp_info(alias)==""} {
.info.cpu.con configure -text "Connected" -fg "\#00ae00"
if {$omsp_info($CpuNr,alias)==""} {
.info.cpu.con configure -text "Connected" -fg "\#00ae00"
} else {
.info.cpu.con configure -text "Connected to $omsp_info(alias)" -fg "\#00ae00"
.info.cpu.con configure -text "Connected to $omsp_info($CpuNr,alias)" -fg "\#00ae00"
}
 
# Display info
putsLog "INFO: Sucessfully connected with the openMSP430 target."
set sizes [GetCPU_ID_SIZE]
if {$omsp_info(asic)} {
putsLog "INFO: CPU Version - $omsp_info(cpu_ver) / ASIC"
set sizes [GetCPU_ID_SIZE $CpuNr]
if {$omsp_info($CpuNr,asic)} {
putsLog "INFO: CPU Version - $omsp_info($CpuNr,cpu_ver) / ASIC"
} else {
putsLog "INFO: CPU Version - $omsp_info(cpu_ver) / FPGA"
putsLog "INFO: CPU Version - $omsp_info($CpuNr,cpu_ver) / FPGA"
}
putsLog "INFO: User Version - $omsp_info(user_ver)"
if {$omsp_info(cpu_ver)==1} {
putsLog "INFO: Hardware Multiplier - --"
} elseif {$omsp_info(mpy)} {
putsLog "INFO: Hardware Multiplier - Yes"
putsLog "INFO: User Version - $omsp_info($CpuNr,user_ver)"
if {$omsp_info($CpuNr,cpu_ver)==1} {
putsLog "INFO: Hardware Multiplier - --"
} elseif {$omsp_info($CpuNr,mpy)} {
putsLog "INFO: Hardware Multiplier - Yes"
} else {
putsLog "INFO: Hardware Multiplier - No"
putsLog "INFO: Hardware Multiplier - No"
}
putsLog "INFO: Program Memory Size - $omsp_info(pmem_size) B"
putsLog "INFO: Data Memory Size - $omsp_info(dmem_size) B"
putsLog "INFO: Peripheral Address Space - $omsp_info(per_size) B"
putsLog "INFO: $hw_break(num) Hardware Break/Watch-point unit(s) detected"
putsLog "INFO: Program Memory Size - $omsp_info($CpuNr,pmem_size) B"
putsLog "INFO: Data Memory Size - $omsp_info($CpuNr,dmem_size) B"
putsLog "INFO: Peripheral Address Space - $omsp_info($CpuNr,per_size) B"
putsLog "INFO: $omsp_info($CpuNr,hw_break) Hardware Break/Watch-point unit(s) detected"
putsLog ""
 
# Activate Load TCL script section
150,20 → 152,29
.info.cpu.more configure -state normal
 
# Reset & Stop CPU
ExecutePOR_Halt
ExecutePOR_Halt $CpuNr
 
# Start server for GDB
if {![startServer]} {
.info.server.con configure -text "Connection problem" -fg red
return 0
.info.server.con configure -text "Connection problem" -fg red
return 0
}
.info.server.con configure -text "Running" -fg "\#00ae00"
 
# Disable gui entries
.connect.config.serial_port.p1 configure -state disabled
.connect.config.serial_baudrate.p2 configure -state disabled
.connect.config.server_port.p configure -state disabled
.connect.start.but configure -state disabled
.connect.cfg.if.config1.adapter.p1 configure -state disabled
.connect.cfg.if.config2.adapter.p2 configure -state disabled
.connect.cfg.if.config1.serial_port.p1 configure -state disabled
.connect.cfg.if.config2.serial_port.p2 configure -state disabled
.connect.cfg.ad.server_port.p0 configure -state disabled
.connect.cfg.ad.server_port.p1 configure -state disabled
.connect.cfg.ad.server_port.p2 configure -state disabled
.connect.cfg.ad.server_port.p3 configure -state disabled
.connect.cfg.ad.i2c_addr.s0 configure -state disabled
.connect.cfg.ad.i2c_addr.s1 configure -state disabled
.connect.cfg.ad.i2c_addr.s2 configure -state disabled
.connect.cfg.ad.i2c_addr.s3 configure -state disabled
.connect.cfg.ad.i2c_nr.s configure -state disabled
}
 
###############################################################################
174,6 → 185,8
 
proc receiveRSPpacket {sock} {
 
global CpuNr
 
# Get client info
set ip [lindex [fconfigure $sock -peername] 0]
set port [lindex [fconfigure $sock -peername] 2]
183,47 → 196,47
set rsp_cmd [getDebugChar $sock]
set rsp_sum ""
if {[string eq $rsp_cmd "\$"]} {
set rx_packet 1
set rsp_cmd ""
set rx_packet 1
set rsp_cmd ""
} else {
binary scan $rsp_cmd H* rsp_cmd
if {$rsp_cmd=="03"} {
putsVerbose "--> BREAK"
HaltCPU
}
binary scan $rsp_cmd H* rsp_cmd
if {$rsp_cmd=="03"} {
putsVerbose "--> BREAK"
HaltCPU $CpuNr
}
}
# Receive packet
while {$rx_packet} {
set char [getDebugChar $sock]
if {$char==-1} {
set rx_packet 0
} elseif {[string eq $char "\#"]} {
set rx_packet 0
set rsp_sum [getDebugChar $sock]
append rsp_sum [getDebugChar $sock]
set char [getDebugChar $sock]
if {$char==-1} {
set rx_packet 0
} elseif {[string eq $char "\#"]} {
set rx_packet 0
set rsp_sum [getDebugChar $sock]
append rsp_sum [getDebugChar $sock]
# Re-calculate the checksum
set tmp_sum [RSPcheckSum $rsp_cmd]
# Re-calculate the checksum
set tmp_sum [RSPcheckSum $rsp_cmd]
 
# Acknowledge and analyse the packet
if {[string eq $rsp_sum $tmp_sum]} {
putDebugChar $sock "+"
# Acknowledge and analyse the packet
if {[string eq $rsp_sum $tmp_sum]} {
putDebugChar $sock "+"
 
# Remove escape characters
set rsp_cmd [removeEscapeChar $rsp_cmd]
putsVerbose "+ w $rsp_cmd"
# Remove escape characters
set rsp_cmd [removeEscapeChar $rsp_cmd]
putsVerbose "+ w $rsp_cmd"
 
# Parse packet and send back the answer
set rsp_answer [rspParse $sock $rsp_cmd]
if {$rsp_answer != "-1"} {
sendRSPpacket $sock $rsp_answer
}
} else {
putDebugChar $sock "-"
}
} else {
append rsp_cmd $char
}
# Parse packet and send back the answer
set rsp_answer [rspParse $sock $rsp_cmd]
if {$rsp_answer != "-1"} {
sendRSPpacket $sock $rsp_answer
}
} else {
putDebugChar $sock "-"
}
} else {
append rsp_cmd $char
}
}
}
 
242,16 → 255,16
# Send the packet until the "+" aknowledge is received
set send_ok 0
while {!$send_ok} {
putDebugChar $sock "$rsp_packet"
set char [getDebugChar $sock]
putDebugChar $sock "$rsp_packet"
set char [getDebugChar $sock]
 
putsVerbose "$char r $rsp_cmd"
putsVerbose "$char r $rsp_cmd"
 
if {$char==-1} {
set send_ok 1
} elseif {[string eq $char "+"]} {
set send_ok 1
}
if {$char==-1} {
set send_ok 1
} elseif {[string eq $char "+"]} {
set send_ok 1
}
}
}
 
266,8 → 279,8
 
set rsp_sum 0
for {set i 0} {$i<[string length $rsp_cmd]} {incr i} {
scan [string index $rsp_cmd $i] "%c" char_val
set rsp_sum [expr $rsp_sum+$char_val]
scan [string index $rsp_cmd $i] "%c" char_val
set rsp_sum [expr $rsp_sum+$char_val]
}
set rsp_sum [format %02x [expr $rsp_sum%256]]
 
311,13 → 324,13
set port [lindex [fconfigure $sock -peername] 2]
 
if {[eof $sock] || [catch {set char [read $sock 1]}]} {
# end of file or abnormal connection drop
close $sock
putsLog "Connection closed: $ip ($port)\n"
unset clients(addr,$sock)
return -1
# end of file or abnormal connection drop
close $sock
putsLog "Connection closed: $ip ($port)\n"
unset clients(addr,$sock)
return -1
} else {
return $char
return $char
}
}
 
338,7 → 351,7
 
# Destroy windows if already existing
if {[lsearch -exact [winfo children .] .omsp_extra_info]!=-1} {
destroy .omsp_extra_info
destroy .omsp_extra_info
}
 
# Create master window
349,8 → 362,8
 
# Title
set title "openMSP430"
if {$omsp_info(alias)!=""} {
set title $omsp_info(alias)
if {$omsp_info($CpuNr,alias)!=""} {
set title $omsp_info($CpuNr,alias)
}
label .omsp_extra_info.title -text "$title" -anchor center -fg "\#00ae00" -font {-weight bold -size 16}
pack .omsp_extra_info.title -side top -padx {20 20} -pady {20 10}
371,45 → 384,45
# Fill the text widget will configuration info
.omsp_extra_info.extra.text tag configure bold -font {-family TkFixedFont -weight bold}
.omsp_extra_info.extra.text insert end "Configuration\n\n" bold
.omsp_extra_info.extra.text insert end [format "CPU Version : %5s\n" $omsp_info(cpu_ver)]
.omsp_extra_info.extra.text insert end [format "User Version : %5s\n" $omsp_info(user_ver)]
if {$omsp_info(cpu_ver)==1} {
.omsp_extra_info.extra.text insert end [format "CPU Version : %5s\n" $omsp_info($CpuNr,cpu_ver)]
.omsp_extra_info.extra.text insert end [format "User Version : %5s\n" $omsp_info($CpuNr,user_ver)]
if {$omsp_info($CpuNr,cpu_ver)==1} {
.omsp_extra_info.extra.text insert end [format "Implementation : %5s\n" --]
} elseif {$omsp_info(asic)==0} {
} elseif {$omsp_info($CpuNr,asic)==0} {
.omsp_extra_info.extra.text insert end [format "Implementation : %5s\n" FPGA]
} elseif {$omsp_info(asic)==1} {
} elseif {$omsp_info($CpuNr,asic)==1} {
.omsp_extra_info.extra.text insert end [format "Implementation : %5s\n" ASIC]
}
if {$omsp_info(mpy)==1} {
if {$omsp_info($CpuNr,mpy)==1} {
.omsp_extra_info.extra.text insert end [format "Hardware Multiplier support: %5s\n" Yes]
} elseif {$omsp_info(mpy)==0} {
} elseif {$omsp_info($CpuNr,mpy)==0} {
.omsp_extra_info.extra.text insert end [format "Hardware Multiplier support: %5s\n" No]
} else {
.omsp_extra_info.extra.text insert end [format "Hardware Multiplier support: %5s\n" --]
}
.omsp_extra_info.extra.text insert end [format "Program memory size : %5s B\n" $omsp_info(pmem_size)]
.omsp_extra_info.extra.text insert end [format "Data memory size : %5s B\n" $omsp_info(dmem_size)]
.omsp_extra_info.extra.text insert end [format "Peripheral address space : %5s B\n" $omsp_info(per_size)]
if {$omsp_info(alias)==""} {
.omsp_extra_info.extra.text insert end [format "Program memory size : %5s B\n" $omsp_info($CpuNr,pmem_size)]
.omsp_extra_info.extra.text insert end [format "Data memory size : %5s B\n" $omsp_info($CpuNr,dmem_size)]
.omsp_extra_info.extra.text insert end [format "Peripheral address space : %5s B\n" $omsp_info($CpuNr,per_size)]
if {$omsp_info($CpuNr,alias)==""} {
.omsp_extra_info.extra.text insert end [format "Alias : %5s\n\n\n" None]
} else {
.omsp_extra_info.extra.text insert end [format "Alias : %5s\n\n\n" $omsp_info(alias)]
.omsp_extra_info.extra.text insert end [format "Alias : %5s\n\n\n" $omsp_info($CpuNr,alias)]
}
 
.omsp_extra_info.extra.text insert end "Extra Info\n\n" bold
 
if {$omsp_info(alias)!=""} {
if {$omsp_info($CpuNr,alias)!=""} {
 
set aliasEXTRA [lsort -increasing [array names omsp_info -glob "extra,*"]]
if {[llength $aliasEXTRA]} {
set aliasEXTRA [lsort -increasing [array names omsp_info -glob "extra,*"]]
if {[llength $aliasEXTRA]} {
 
foreach currentEXTRA $aliasEXTRA {
regexp {^.+,.+,(.+)$} $currentEXTRA whole_match extraATTR
.omsp_extra_info.extra.text insert end [format "%-15s: %s\n" $extraATTR $omsp_info($currentEXTRA)]
}
.omsp_extra_info.extra.text insert end "\n\n"
}
foreach currentEXTRA $aliasEXTRA {
regexp {^.+,.+,(.+)$} $currentEXTRA whole_match extraATTR
.omsp_extra_info.extra.text insert end [format "%-15s: %s\n" $extraATTR $omsp_info($CpuNr,$currentEXTRA)]
}
.omsp_extra_info.extra.text insert end "\n\n"
}
} else {
.omsp_extra_info.extra.text insert end "No alias found in 'omsp_alias.xml' file"
.omsp_extra_info.extra.text insert end "No alias found in 'omsp_alias.xml' file"
}
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.