OFDMReferenceDesign/Applications/Characterization: automated_client.tcl

package require Thread

##
#@file automated_client.tcl
#
#@author Richard Latimer
#
#@brief Includes functions for automation for sending warpnode structs and receiving structs with acks. 
#In addition this write stat structs to a file. The code connects with the dumb_server over port 9090


#Set Global Variables
set ackSeqNum 1
set SendAck 1
set WriteStat 2

#User Specified Global Variables
set filename "PacketData.m"
set NumNodes 2;
set dumbServerIP 10.0.0.6
set dumbServerPort 9090

##
#Sends data over socket, adding on the sequence number and number to specify it is a tcl string for
#the dumb_server. The function can confirm acks or stat packets which are formatted for matlab by 
#the dumb_server.
#
#@param chan, the socket ID
#
#@param data, the string to be sent over the socket
#
#@param {arg}, arguement for the type of feedback to receive. Default=0 request nothing, SendAck=1 request acks,  WriteStat=2 request Stats and write to a file
proc senddata {chan data {arg 0}} {

    #Specify global variables usd by the function
    global ackSeqNum
    global SendAck
    global WriteStat
    global NumNodes
    

    #Request and ack packet from dumb_server
    if {$arg == $SendAck} {
    
        #Package data to be transmitted to dumb_server
        set val "1 $ackSeqNum $data"
        
        #Send $val over socket $chan
        puts $chan $val
        puts "Sent: $val"
        
        #Sleep 1 millsecond to help aid the cleaning of the buffer
        after 1
    
        set attempts 1
        #Check for an ack handshake, otherwise retransmit
        while {[ackHandshake $chan]} {
            incr attempts
            puts "Attempted transmission: $attempts"
            
            #Number of times to retransmit data before giving up
            if {$attempts == 5} {
                puts "Could not get ack"
                close $chan
                exit
            }   
            
            #Resend $val over socket $chan
            puts $chan $val
            
            #Sleep 1 millsecond to help aid the cleaning of the buffer
            after 1
        }
        
        incr ackSeqNum
        
        #seqNum on server and Nodes is a char with a max value of 256
        if {$ackSeqNum==256} {
            set ackSeqNum 1
        }
        return
    }
    
    #Request statistics from dumb_server
    if {$arg == $WriteStat} {
        #Package data to be transmitted to dumb_server
        set val "1 0 $data"
        
        #Send $val over socket $chan
        puts $chan $val
        puts "Sent: $val"
        

        set attempts 1
        
        #Read statics and write to a file for the number of $NumNodes
        for {set i 0} { $i < $NumNodes } {incr i} {
            while {[statHandshake $chan]} {
                incr attempts
                puts "Attempted transmission: $attempts"
                
                #Number of times to retransmit data before giving up
                if {$attempts == 5} {
                    puts "Could not get stat"
                    close $chan
                    exit
                }
                
                #Resend $val over socket $chan
                puts $chan $val
                
                #Sleep 1 millsecond to help aid the cleaning of the buffer
                after 1

            }
        }
        return
  
    }
    
    #Default: Send data without expecting anything in return
    
    set val "1 0 $data"
    #Send $val over socket $chan
    puts $chan $val
    puts "Sent: $val"
    
    #Sleep 1 millsecond to help aid the cleaning of the buffer
    after 1
    
}

##
#Read data from socket.
#
#@param chan, the channel socket ID
#
#@return data from socket
proc receivedata {chan} {
    set received [gets $chan]                 ;# Send a string
    ;#puts "Received: $received"                
    after 1
    return $received
}

##
#Reads the socket for the parameter that signifies an ack from server. 
#This function checks for one second if the socket has an ack and if 
#the ack contains the proper seqNum.
#
#@param chan, the socket ID
#
#@return 1 if the correct ack and seqNum ARE NOT received, 0 if they ARE received
proc ackHandshake {chan} {

    #Specify global variables usd by the function
    global ackSeqNum
    set i 0
    
    while {1} {
    
        #Read data from channel socket
        set data [receivedata $chan]
        #Split data by whitespaces into a list of values
        set dataList [regexp -inline -all -- {\S+} $data]
        
        #Check if the second to last value is "_ack"
        if {[lindex $dataList  end-1] == "_ack_"} {
            ;#puts "Received Ack with value: $data"
            ;#puts "Delay $i msec" ;#Delay between each command
            
            #Check if the last value, which is the seqNum, matches the $ackSeqNum
            if {[lindex $dataList end] == $ackSeqNum} {
                ;#puts "SeqNum Matches" ;#If we receive and ack and the SeqNum is the same
                return 0        
            }
            #If an _ack_ was received at precisely 1000 milliseconds, but contained the wrong seqNum
            if {$i==1000} {
                puts "SeqNum MisMatch: Expected $ackSeqNum but got [lindex $dataList end]"
                return 1    
            }
            
        }
        #If approximately 1000 millseconds pass without receiving an ack
        if {$i==1000} {
            puts "Didn't receive ACK"
            return 1
        }
        
        after 1
        incr i
    }
}

##
#Reads the socket for the string signifying statistics from the server. It then writes
#the data to the file specified globally as $filename
#
#@param chan, the socket ID
#
#@return 1 if the statistic data IS NOT received, 0 if IS received
proc statHandshake {chan} {
    set i 0
    while {1} {
    
        #Read data from channel socket
        set data [receivedata $chan]
        #Read only values that are relevant to statistics data
        set data2 [regexp -inline -all -- {Node.*_statAck_} $data]
        #Split data by whitespaces into a list of values
        set dataList [regexp -inline -all -- {\S+} [join $data2]]
        
        #Check if the last value of data list signifies statistic data
        if {[lindex $dataList  end] == "_statAck_"} {
            puts "Received/Writing StatAck with value: $data"
            puts "Delay $i"

            #Write statistic to file, while removing indicators that signify the data is statistic data
            writeStats [join [lreplace $dataList end end "\n"] " "] ;#Remove \n and _statAck_ from list, then make the list a string
                return 0        
        }
        
        #If approximately 1000 millseconds pass without receiving an ack
        if {$i==1000} {
            puts "Didn't receive Stat Packet"
            return 1
        }
        
        after 1
        incr i
    }
}

##
#Appends data to the file specified by the global variable $filename. Attaches a carriage return
#after writing data
#
#@param data, the data to be written to file $filename
proc write {data} {
    #Specify global variables usd by the function
    global filename
    set fileID [open $filename "a"]
    puts -nonewline $fileID $data
    puts -nonewline $fileID "\n"
    close $fileID
}

##
#Appends statistic data to the file specified by the global variable $filename.
#Attaches a carriage return after writing data. The prints to the command line the statistics
#
#@param data, the data to be written to file $filename
proc writeStats {data} {
    #Specify global variables usd by the function
    global filename
    set fileID [open $filename "a"]
    puts -nonewline $fileID $data
    puts -nonewline $fileID "\n"
    close $fileID
    
    printStats $data
}

##
#Prints to the command line the statistics data
#
#@param data, the statistics data to be printed
proc printStats {data} {
    set dataList [regexp -inline -all -- {\S+} $data]
    puts "\n"
    puts "Stat Struct Contents:"
    puts "\tNode: [lindex $dataList 0]"
    puts "\tSec: [lindex $dataList 2]"
    puts "\tUsec: [lindex $dataList 3]"
    puts "\tGoodPackets: [lindex $dataList 4]"
    puts "\tOtherBadPackets: [lindex $dataList 5]"
    puts "\tPartnerBadPackets: [lindex $dataList 6]"
    puts "\tRxBytes: [lindex $dataList 7]"
    puts "\tTxBytes: [lindex $dataList 8]"
    puts "\tTimeInterval: [lindex $dataList 9]"
    puts "\tThroughput: [lindex $dataList 10]\n"

}

###THREADED FUNCTIONS AND VALUES###

#Keyboard input value shared among threads
tsv::array set keyboardValue {0 0} ;#Arrays must have an even number of variables, The first argument states
                                   ;#Which value in the array is assigned, the next number is the stored value
#Keyboard enable shared among threads
tsv::array set keyboardEnable {0 0}

#Create a thread
set threadID [thread::create {
    
    ##
    #Reads the keyboard if $keyboardEnable is 1, write the keyboard value to $keyboardValue, then
    #set $keyboardEnable to 0
     proc keyboardInputthread {} {
        global val
        while {1} {
        if {[eval tsv::get keyboardEnable 0]  == 1} {
            puts "Input Command: "
            tsv::set keyboardValue 0 [gets stdin]
            tsv::set keyboardEnable 0 0
            }
        }
    }
    
    #Keep thread alive
    ::thread::wait
}]

##
#Enable keyboard input and read keyboard input
#
#@return keyboardValue, the value inputted into the keyboard
proc keyboardInput {} {
    tsv::set keyboardEnable 0 1
    while {1} {
        if {[tsv::get keyboardEnable 0]  == 0} {
            return [eval tsv::get keyboardValue 0] ;#Returns keyboard input
        }
    }
}

#Evaluate thread
eval [subst {thread::send -async $threadID {keyboardInputthread } }]



### EXAMPLES OF STRUCTURES###

;# Observe Struct:  structType, nodeID, partnerID, Time sec, time usec, goodPackets, partnerBadPackets, rxBytes, txBytes, otherBadPackets, throughput
set ObserveStruct [list 49 0 2 30000 40000 50000 50000 50000 6000 700 10.3 ]

;# Control Struct: structType, nodeID, modOrder, txPower, coding, channel
set ControlStruct0 [list 50 0 4 63 3 9 ]
set ControlStruct1 [list 50 1 4 63 3 9 ]

;# Traffic Struct: structType, nodeID, trafficMode 0 = RECEIVE 1 = TRANSMIT , reserved0, txInterval, txPacketLen, reserved1 
set TrafficStruct0 [list 52 0 1 0 0 1470 0 ]
set TrafficStruct1 [list 52 1 1 0 0 1470 0 ]

;# structType, nodeID is only relevant for ack on stop, cmdID, cmdParam
set CommandStructStart [list 51 0 102 0 ]
set CommandStructStop [list 51 0 103 0 ]

;# structType, nodeID, cmdID, cmdParam
set CommandStructStats0 [list 51 0 104 0 ]
set CommandStructStats1 [list 51 1 104 0 ]
set CommandStructResetStats0 [list 51 0 97 0 ]
set CommandStructResetStats1 [list 51 1 97 0 ]


### MAIN PROGRAM ###

#Open a socket connection
set sock [socket $dumbServerIP $dumbServerPort] 

#Automate flushing of the socket
fconfigure $sock -buffering none -blocking 0

set TimeInterval 100
;#Create Blank File
set fileID [open $filename "w"] 

#for {set p 0} {$p < 50} {incr p} {
for {set power 0} {$power < 64} {incr power} {
    for {set mod 1} {$mod<3} {incr mod} { ;#set mod
    
#Send a Control Struct to node 0
senddata $sock [list 50 0 [expra  {$mod*2}] $power 3 9 ] $SendAck
#Send a Control Struct to node 1
senddata $sock [list 50 1 [expr {$mod*2}] $power 3 9 ] $SendAck

#Send a Traffic Struct to node 0
senddata $sock [list 52 0 1 0 0 1470 0 ] $SendAck
#Send a Traffic Struct to node 1
senddata $sock [list 52 1 1 0 0 1470 0 ] $SendAck

#Reset Statistics on nodes, sets everything to 0
senddata $sock $CommandStructResetStats0 $SendAck
senddata $sock $CommandStructResetStats1 $SendAck

#Begin data transmission over the air
senddata $sock $CommandStructStart
after $TimeInterval
#Stop data tranmission over the air
senddata $sock $CommandStructStop $SendAck

senddata $sock $CommandStructStats0 $WriteStat
senddata $sock $CommandStructStats1 $WriteStat
    
    }
}
#}
    

close $sock
exit