#!/usr/bin/env python
#Transmission and reception, one ata a time on the same antena

from gnuradio import gr, gru, modulation_utils
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option
from optparse import OptionParser
from numpy import random
import random, time, struct, sys, math
from datetime import datetime

# from current dir
from transmit_path import transmit_path
from receive_path import receive_path

global sync_status,mode,ch,traffic_flag,n_rcvd, n_right
sync_status = False
#Defining modes of operation
# sync: the two nodes are trying to rendezvous on a common channel
# traffic: the two node are communicating information to each other
mode = "sync" #Default mode is sync
traffic_flag = False
class my_top_block(gr.top_block):

    	def __init__(self, mod_class, demod_class,
                 rx_callback, options_tx,options_rx):

        	gr.top_block.__init__(self)
        	self.rxpath = receive_path(demod_class, rx_callback, options_rx)
		self.txpath = transmit_path(mod_class, options_tx)
		self.connect(self.txpath);
		self.connect(self.rxpath);


def main():

   	global n_rcvd, n_right,sync_status,mode,ch,traffic_flag,n_attempts,return_flag
    	n_rcvd = 0
    	n_right = 0
	n_attempts = 5
	return_flag = 0

    	def send_pkt(self, payload='', eof=False):
        	return self.txpath.send_pkt(payload, eof)
	
	def get_freq(hop_freq,probe_level,absent_time):

		channel = int(random.choice([1,7,8,14]))
	    	if channel < 8:
			hop_freq = float(1e6 * (462.5625+(channel-1)*0.025))#setting the centre freq frequency for sending packets
	 	else:
			hop_freq = float(1e6 * (467.5625+(channel-8)*0.025))#setting the centre freq frequency for sending packets	

		return channel,hop_freq #returning the channel number and hop frequency
	

	def rx_callback(ok, payload):
		
		global n_rcvd, n_right,sync_status,mode,ch,traffic_flag
    		########################## sync ####################################
		if mode == "sync":
			if ok:
        			(pktno,) = struct.unpack('!H', payload[0:2])
       				(sync_signal,) = struct.unpack('!s', payload[2]) 
        			(data_channel,) = struct.unpack('!H', payload[3:5])
        							  
        			if str(sync_signal) == 'o' and str(data_channel) == str(ch):
        				
					sync_status = True
					#tb.stop()
					                   		
				if str(sync_signal) == 's' and str(data_channel) == str(ch): 
					
					sync_status = True
					data = 'o'
               				pktno=0
	       				ack_payload = struct.pack('!HsH', pktno & 0xffff,data,ch & 0xffff) #+ data
		      			send_pkt(tb,ack_payload) #sending back the acknowledgement
			#else:
			#	print "sync packet not ok\n"
		###################################################################
    		
		######################### traffic #################################
		if mode == "traffic":
			if ok: 
				(data_header,) = struct.unpack('!s', payload[0])
				if data_header == 'd':
					traffic_flag = True
					comm = struct.unpack('!14s', payload[1:15])
					data = 'dI am fine.....' #Sending this message
					payload = struct.pack('!15s', data)
					send_pkt(tb,payload)
				
			#else:
			#	print "data packet not ok\n"
		##############################################################

       		n_rcvd += 1
        	if ok:
            		n_right += 1

        	#print "ok = %5s  pktno = %4d  n_rcvd = %4d  n_right = %4d" % (
        	#    ok, pktno, n_rcvd, n_right)
		

    	mods = modulation_utils.type_1_mods()
    	demods = modulation_utils.type_1_demods()

    	#setting up the tx options parser

    	parser_tx = OptionParser(option_class=eng_option, conflict_handler="resolve")
    	expert_grp_tx = parser_tx.add_option_group("Expert_tx")

    	parser_tx.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
                      	default='gmsk',
                      	help="Select modulation from: %s [default=%%default]"
                            	% (', '.join(mods.keys()),))

    	parser_tx.add_option("-s", "--size", type="eng_float", default=1500,
                      	help="set packet size [default=%default]")
    	parser_tx.add_option("-M", "--megabytes", type="eng_float", default=1.0,
                      	help="set megabytes to transmit [default=%default]")
    	parser_tx.add_option("","--discontinuous", action="store_true", default=False,
                      	help="enable discontinous transmission (bursts of 5 packets)")
    	parser_tx.add_option("","--from-file", default=None,
                      	help="use file for packet contents")
    	
    	transmit_path.add_options(parser_tx, expert_grp_tx)

    	for mod in mods.values():
        	mod.add_options(expert_grp_tx)

    	(options_tx, args_tx) = parser_tx.parse_args ()

    	if len(args_tx) != 0:
        	parser_tx.print_help()
        	sys.exit(1)
	
    	############# Setting some default values for tx side of the block
    	options_tx.tx_freq = 462.5625e6
    	options_tx.samples_per_symbol =  2
    	options_tx.modulation = 'dbpsk'
    	options_tx.fusb_block_size = 4096
    	options_tx.fusb_nblocks = 16
    	options_tx.bitrate = 0.0125e6
    	#############

    	if options_tx.tx_freq is None:
        	sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        	parser_tx.print_help(sys.stderr)
        	sys.exit(1)

    	if options_tx.from_file is not None:
        	source_file = open(options_tx.from_file, 'r')
    	    
    	parser_rx = OptionParser (option_class=eng_option, conflict_handler="resolve")
    	expert_grp_rx = parser_rx.add_option_group("Expert_rx")
    	parser_rx.add_option("-m", "--modulation", type="choice", choices=demods.keys(),
                      	default='gmsk',
                      	help="Select modulation from: %s [default=%%default]"
                            	% (', '.join(demods.keys()),))
    	
    	receive_path.add_options(parser_rx, expert_grp_rx)

    	for mod in demods.values():
        	mod.add_options(expert_grp_rx)

    	(options_rx, args_rx) = parser_rx.parse_args ()

    	if len(args_rx) != 0:
        	parser_rx.print_help(sys.stderr)
        	sys.exit(1)
    	############# Setting some default values for rx side of the block
    	options_rx.rx_freq = 462.5625e6 #setting default rx_freq value
    	options_rx.samples_per_symbol =  2
    	options_rx.modulation = 'dbpsk'
    	options_rx.fusb_block_size = 4096
    	options_rx.fusb_nblocks = 16
    	options_rx.bitrate = 0.0125e6
    	#############

    	if options_rx.rx_freq is None:
        	sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        	parser_rx.print_help(sys.stderr)
        	sys.exit(1)
    	
	# build the graph

    	tb = my_top_block(mods[options_tx.modulation],
                      	demods[options_rx.modulation],
                      	rx_callback,options_tx,
                      	options_rx)
    	r = gr.enable_realtime_scheduling()
    	if r != gr.RT_OK:
        	print "Warning: failed to enable realtime scheduling"
    
    	tb.start()

    	#listening to random frequencies untill a match is found
    	running = True
    	ch_energy = tb.rxpath.probe.level() #setting initial value
	hop_freq = options_tx.tx_freq #  = options_rx.rx_freq...same for tx and rx side
   	while running:

		################################################sync mode####################################
		if mode == "sync":
			if sync_status != True:
	    			
				if return_flag == 0:
					ch,hop_freq = get_freq(hop_freq,ch_energy,0)
				else:
					ch,hop_freq = get_freq(hop_freq,ch_energy,elapsed_time)
					return_flag = 0

				tb.txpath.set_freq(hop_freq)
	    			tb.rxpath.set_freq(hop_freq)
      		
				ch_energy = tb.rxpath.probe.level() #check if primary user is present
				
				if int(ch_energy) > 1.5e8: #if primary user is there then dont transmit on this channel
					continue
				
	    			nbytes = 5 #int(1e6 * .0003)
				pkt_size = 5
	    			n = 0
	    			pktno = 0
    	    			while n < nbytes:
                			if options_tx.from_file is None:
                    				data = 's'
	        			else:
            	    				data = source_file.read(pkt_size - 2)
            	    				if data == '':
                        				break;

                			payload = struct.pack('!HsH', pktno & 0xffff,data,ch & 0xffff) #+ data
	        				
                			send_pkt(tb,payload)
					n += len(payload)
                			sys.stderr.write('.')
                			if options_tx.discontinuous and pktno % 5 == 4:
                    				time.sleep(1)
                				pktno += 1
	    			time.sleep(0.1)
            		
			else:
				print "sync channel found..channel ",ch,"\n"  
				n_attempts_counter = 0
				mode = "traffic"
				traffic_flag = False
				sync_status="False"
				start_time = datetime.now() #measuring the time for which the primary user is away
	
		################################################end of sync mode####################################

		################################################Communications mode#################################
		if mode == "traffic":
							
			nbytes = 15
    	    		pkt_size = 15
			data_pktno = 0
			n = 0
			while n < nbytes:
                		
               			if options_tx.from_file is None:
                 			data = 'dHi how are you' #Sending this message
	        			
                		else:
            		    		data = source_file.read(pkt_size - 2)
            		    		if data == '':
                	        		break;
	
			
                		payload = struct.pack('!15s', data)
	       							
                		send_pkt(tb,payload)
				#print "printing payload",data,"**\n"
                		n += len(payload)
                		sys.stderr.write('.')
                		if options_tx.discontinuous and data_pktno % 5 == 4:
                			time.sleep(1)
                		data_pktno += 1
	    			time.sleep(0.2 + 0.05*int(random.choice([0,1,2,3])))

				if traffic_flag != True:
					n_attempts_counter += 1
					if n_attempts_counter  > n_attempts: #get out of the data channel as it seems that the other node is still trying to rendezvous
						mode = "sync"
						continue

				ch_energy = tb.rxpath.probe.level() #check if primary user is present
				
            			if int(ch_energy) > 1.5e8: #if primary user is there then dont transmit on this channel
					stop_time = datetime.now()	
					_elapsed_time  = start_time - stop_time
					elapsed_time = _elapsed_time.seconds
					print "primary user detected..moving out of this channel\n"
					mode = "sync"
					return_flag = 1
                

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass