def simulateSynch():
totalResults = []
for file in files:
print "Working on: " + file.split('/')[-2]
# Initial data ---------------------------------------------------------------
importer = Importer()
importedData = importer.getInputData(file, samplingInterval)
#PredictedData ---------------------------------------------------------------
predictor = DRPredictor()
predictedData = predictor.getPredictedData(importedData, predictionInterval, \
samplingInterval)
for txRate in txRates:
#Transmitted packets and data ---------------------------------------------
transmitter = SynchTransmitter()
transmittedPackets = transmitter.getTransmittedPackets(int(txRate), predictedData)
reconstructor = Reconstructor()
transmittedData = reconstructor.getReconstructedData(transmittedPackets)
result = PartBResult()
result.movementType = findMovementType(file)
result.threshold = 0
result.txRate = txRate
result.txError = calculateError(importedData, transmittedData)
totalResults.append(result)
return totalResults
def runSimulation():
totalResults = []
for file in files:
print "Working on: " + file.split('/')[-2]
# Initial data ---------------------------------------------------------------
importer = Importer()
importedData = importer.getInputData(file, samplingInterval)
#PredictedData ---------------------------------------------------------------
predictor = DRPredictor()
predictedData = predictor.getPredictedData(importedData, predictionInterval, \
samplingInterval)
for threshold in thresholds:
#Transmitted packets and data ---------------------------------------------
transmitter = DRTransmitter(heartbeat)
transmittedPackets = transmitter.getTransmittedPackets(threshold, predictedData)
reconstructor = Reconstructor()
transmittedData = reconstructor.getReconstructedData(transmittedPackets)
result = PartAResult()
result.movementType = findMovementType(file)
result.threshold = threshold
result.txRate = calculateTransmissionRate(importedData, transmittedPackets)
result.txError = calculateError(importedData, transmittedData)
totalResults.append(result)
return totalResults
def transmitData(inputFile, logDir, predictionInterval, samplingInterval,
heartbeat, drThreshold, delay, jitter, packetLoss):
# Import data
print "Importing data..."
importer = Importer()
rawInputData = importer.getInputData(inputFile, samplingInterval)
exportData(logDir + "RawInputData.txt", rawInputData)
# Filtering input data
print "Filtering data..."
samplingFreq = int(1e3 / samplingInterval)
taps = 80
bands = [0.0, 10, 11, 50.0]
weights = [1, 0]
coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq)
gain = 1.0 / sum(coefficients)
filteredInputData = filterData(rawInputData, logDir, "cc",
samplingInterval, coefficients)[0]
filteredInputData = amplifyData(filteredInputData, gain)
exportData(logDir + "FilteredInputData.txt", filteredInputData)
# Create the prediction vectors
print "Creating the prediction vectors..."
predictor = DRPredictor()
predictedData = predictor.getPredictedData(filteredInputData,
predictionInterval,
samplingInterval)
exportData(logDir + "PredictionData.txt", predictedData)
# Run the transmission algorithm
print "Simulating the transmission algorithm..."
transmitter = DRTransmitter(heartbeat)
drTxPackets = transmitter.getTransmittedPackets(drThreshold, predictedData)
exportData(logDir + "DRTxPackets.txt", drTxPackets)
# Simulate the transmission of the packets
print "Simulating the network..."
network = Network()
drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter,
packetLoss)
exportData(logDir + "DRRxPackets.txt", drRxPackets)
# Receive the packets
print "Receiving the packets..."
receiver = Receiver()
drRxFilteredPackets = receiver.getFilteredData(drRxPackets)
exportData(logDir + "DRRxData.txt", drRxFilteredPackets)
return [
rawInputData, filteredInputData, predictedData, drTxPackets,
drRxPackets, drRxFilteredPackets
]
def transmitData(inputFile, logDir, predictionInterval, samplingInterval,
heartbeat, drThreshold, delay, jitter, packetLoss):
# Import data
print "Importing data..."
importer = Importer()
rawInputData = importer.getInputData(inputFile, samplingInterval)
exportData(logDir + "RawInputData.txt", rawInputData)
# Filtering input data
print "Filtering data..."
samplingFreq = int(1e3/samplingInterval)
taps = 80
bands = [0.0, 10, 11, 50.0]
weights = [1, 0]
coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq)
gain = 1.0 / sum(coefficients)
filteredInputData = filterData(rawInputData, logDir, "cc", samplingInterval, coefficients)[0]
filteredInputData = amplifyData(filteredInputData, gain)
exportData(logDir + "FilteredInputData.txt", filteredInputData)
# Create the prediction vectors
print "Creating the prediction vectors..."
predictor = DRPredictor()
predictedData = predictor.getPredictedData(filteredInputData, predictionInterval, samplingInterval)
exportData(logDir + "PredictionData.txt", predictedData)
# Run the transmission algorithm
print "Simulating the transmission algorithm..."
transmitter = DRTransmitter(heartbeat)
drTxPackets = transmitter.getTransmittedPackets(drThreshold, predictedData)
exportData(logDir + "DRTxPackets.txt", drTxPackets)
# Simulate the transmission of the packets
print "Simulating the network..."
network = Network()
drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter, packetLoss)
exportData(logDir + "DRRxPackets.txt", drRxPackets)
# Receive the packets
print "Receiving the packets..."
receiver = Receiver()
drRxFilteredPackets = receiver.getFilteredData(drRxPackets)
exportData(logDir + "DRRxData.txt", drRxFilteredPackets)
return [rawInputData, filteredInputData, predictedData, drTxPackets,
drRxPackets, drRxFilteredPackets]
def simulateADR():
totalResults = []
for file in files:
print "Working on: " + file.split('/')[-2]
# Initial data ---------------------------------------------------------------
importer = Importer()
importedData = importer.getInputData(file, samplingInterval)
#PredictedData ---------------------------------------------------------------
predictor = DRPredictor()
predictedData = predictor.getPredictedData(importedData, predictionInterval, \
samplingInterval)
for index, delay in enumerate(delays):
delayList = [delay] * len(predictedData)
jitter = jitters[index]
jitterList = [jitter] * len(predictedData)
transmitter = ADRTransmitter(heartbeat)
transmittedPackets = transmitter.getTransmittedPackets(minThreshold, maxThreshold,
maxDelay, maxJitter, \
delayList, jitterList, \
predictedData)
reconstructor = Reconstructor()
transmittedData = reconstructor.getReconstructedData(transmittedPackets)
result = PartBResult()
result.movementType = findMovementType(file)
result.threshold = 0
result.txRate = calculateTransmissionRate(importedData, transmittedPackets)
result.txError = calculateError(importedData, transmittedData)
result.delay = delay
result.jitter = jitter
result.packetLoss = 0
totalResults.append(result)
return totalResults
# Tests
# ------------------------------------------------------------------------------------
# Initial data
importer = Importer()
importedData = importer.getInputData(inputFile, samplingInterval)
filteredData = []
for sample in importedData:
if sample.time >= filterLimits[0] and \
sample.time <= filterLimits[1]:
filteredData.append(copy(sample))
outputData("InitialData", filteredData)
# Predicted data
predictor = DRPredictor()
predictedData = predictor.getPredictedData(filteredData, predictionInterval, samplingInterval)
outputData("PredictedData", predictedData)
# Transmitted packets
# DR
transmitter = DRTransmitter(heartbeat)
DRPackets = transmitter.getTransmittedPackets(threshold, predictedData)
outputData("DRTransmittedPackets", DRPackets)
# Synch
transmitter = SynchTransmitter()
synchPackets = transmitter.getTransmittedPackets(txRate, predictedData)
outputData("SynchTransmittedPackets", synchPackets)
# ADR
transmitter = ADRTransmitter(heartbeat)
delayEstimate = [ networkParams[0] ] * len(predictedData)
plotFreqDomain = True plotPhaseResponse = True useDb = False lowerBoundTime = -1 #17000 upperBoundTime = -1 #22000 lowerBoundFreq = 0 upperBoundFreq = 100 # Import data print "Importing data..." importer = Importer() inputData = importer.getInputData(inputFile, samplingInterval) # Create the prediction vectors print "Creating the prediction vectors..." predictor = DRPredictor() predictedData = predictor.getPredictedData(inputData, predictionInterval, samplingInterval) # Run the transmission algorithm print "Simulating the transmission algorithm..." transmitter = DRTransmitter(heartbeat) DRTxPackets = transmitter.getTransmittedPackets(threshold, predictedData) # Simulate the transmission of the packets print "Simulating the network..." network = Network() DRRxPackets = network.getReceivedPackets(DRTxPackets, delay, jitter, packetLoss) # Receive the packets print "Receiving the packets..." receiver = Receiver()
# Plotting paramters
lowerTime = 18000
upperTime = 26500
yMax = 0.45
yMin = 0.05
# Simulate the algorithm
stepFunc = []
for i in range(0, 5001, 10):
if i < 200:
stepFunc.append(Sample(i, 0, 0, 0))
else:
stepFunc.append(Sample(i, 1, 1, 1))
predictor = DRPredictor()
predictedData = predictor.getPredictedData(stepFunc, predictionInterval,
samplingInterval)
s.exportData(logDir + "PredictionData.txt", predictedData)
transmitter = DRTransmitter(heartbeat)
drTxPackets = transmitter.getTransmittedPackets(.9, predictedData)
s.exportData(logDir + "TransmittedData.txt", drTxPackets)
network = Network()
drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter,
packetLoss)
s.exportData(logDir + "ReceivedData.txt", drRxPackets)
receiver = Receiver()
drRxFilteredPackets = receiver.getFilteredData(drRxPackets)
s.exportData(logDir + "FilteredData.txt", drRxFilteredPackets)
convergedData = s.convergeData(drRxFilteredPackets, logDir, "-",
samplingInterval, interpolationType,
# Plotting paramters lowerTime = 18000 upperTime = 26500 yMax = 0.45 yMin = 0.05 # Simulate the algorithm stepFunc = [] for i in range(0,5001, 10): if i < 200: stepFunc.append( Sample(i, 0, 0, 0) ) else: stepFunc.append( Sample(i, 1, 1, 1) ) predictor = DRPredictor() predictedData = predictor.getPredictedData(stepFunc, predictionInterval, samplingInterval) s.exportData(logDir + "PredictionData.txt", predictedData) transmitter = DRTransmitter(heartbeat) drTxPackets = transmitter.getTransmittedPackets(.9, predictedData) s.exportData(logDir + "TransmittedData.txt", drTxPackets) network = Network() drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter, packetLoss) s.exportData(logDir + "ReceivedData.txt", drRxPackets) receiver = Receiver() drRxFilteredPackets = receiver.getFilteredData(drRxPackets) s.exportData(logDir + "FilteredData.txt", drRxFilteredPackets) convergedData = s.convergeData(drRxFilteredPackets, logDir, "-", samplingInterval, interpolationType, reconstructionThreshold)[0] iData = [ [] ] * 4
