Hi all,
I have a pyPMU and a pyPDC instance running on the same windows virtual machine. Essentially they are synchronized to the same clock. The pyPMU instance receives phasor data from another source and sends the data as synchrophasor packets to the pyPDC. The pyPDC parses the synchrophasor data, extracts the time stamp(data['time']) and then compares with the current time (time.time()).
The results for this comparison is as follows for data rates 10,25,50,100 fps. RR = reporting rate or Data Rate in frames per sec
RR
Transmission time (avg)
fps
ms
10
99.59
25
39.23
50
19.5
100
9.43
As seen in the table the time difference between the synchrophasor time stamp from the PMU, and the time when it is being parsed in the PDC is same as 1\RR. I do not understand why? Any insight? I was under the impression that some random or constant delay will take place in the communication.
The codes are as follows
pyPMU
## Import necessary libraries
import math
import numpy as np
import socket
import struct
from synchrophasor.frame import ConfigFrame2
from synchrophasor.pmu import Pmu
import time
# from synchrophasor.frame import ConfigFrame2
# from time import time
from synchrophasor.frame import CommandFrame
from datetime import datetime
##
"""
randomPMU will listen on ip:port for incoming connections.
After request to start sending measurements - random
values and values from OPAL RT model. It will also receive RR from OPAL RT
and configure frame rate accordingly.
"""
if __name__ == "__main__":
## Configure socket for Phasor data ##
UDP_IP = "10.10.114.22"
UDP_PORT = 8201 #UDP phasor values 32 bytes (V,phi,P)
sock_ph = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
sock_ph.bind((UDP_IP, UDP_PORT))
print("socket bound, waiting for data...")
## Configure socket for RR Value ##
UDP_PORT2 = 600 # OPAL sends RR to this port
sock_rr = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
sock_rr.bind((UDP_IP, UDP_PORT2)) # binding is required for receiving not sending
sock_rr.settimeout(1 / 10000) # you dont want to wait forever a data that might not come
flag = False
## Configure socket for RR Value send to CA algorithm ##
UDP_PORT3 = 9901
sock_rr_send = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
## PMU configuration ##
pmu = Pmu(ip="10.10.114.22", port=1410) #original port config
## connect to another VM 10.10.114.23
#pmu = Pmu(ip="10.10.114.22", port=1410)
pmu.logger.setLevel("DEBUG")
cfg = ConfigFrame2(1, # PMU_ID
1000000, # TIME_BASE
1, # Number of PMUs included in data frame
"PDAS_bus2", # Station name
1410, # Data-stream ID(s)
(True, True, True, True), # Data format - POLAR; PH - REAL; AN - REAL; FREQ - REAL;
3, # Number of phasors(was 3)
1, # Number of analog values
1, # Number of digital status words
["VA", "VB", "VC", "ANALOG1", "BREAKER 1 STATUS",
"BREAKER 2 STATUS", "BREAKER 3 STATUS", "BREAKER 4 STATUS", "BREAKER 5 STATUS",
"BREAKER 6 STATUS", "BREAKER 7 STATUS", "BREAKER 8 STATUS", "BREAKER 9 STATUS",
"BREAKER A STATUS", "BREAKER B STATUS", "BREAKER C STATUS", "BREAKER D STATUS",
"BREAKER E STATUS", "BREAKER F STATUS", "BREAKER G STATUS"], # Channel Names
[(0, "v"), (0, "v"),
(0, "v")], # Conversion factor for phasor channels - (float representation, not important)
[(1, "pow")], # Conversion factor for analog channels
[(0x0000, 0xffff)], # Mask words for digital status words
50, # Nominal frequency
1, # Configuration change count
50) # Rate of phasor data transmission) 50 default here
pmu.set_configuration(cfg)
pmu.set_header("Random PMU: Modified by Pratyush")
pmu.run()
############## C37.118 Reporting Rates #########################
rr_list = [5, 10, 25, 50, 100] # list of available RR as per standard
First = True
phasor_list = []
flag = False
while True:
#print(pmu.cfg2,type(pmu.cfg2))
cframe = pmu.cfg2
config_rr = cframe.get_data_rate()
pmu_rr = str(config_rr).encode("ascii") # int to bytes e.g. 50 to b'50'
sock_rr_send.sendto(pmu_rr, (UDP_IP, UDP_PORT3))
#print(pmu_rr)
try:
aware_rr = sock_rr.recv(1024)
#drr = int(struct.unpack('d', aware_rr[8:16])[0]) # if coming from OPAL
del_rr = int(aware_rr.decode("utf-8")) # the received value is +1 or -1
#drr = crr + del_rr
drr=del_rr
flag = True
except socket.timeout: # to catch the error essentially it will only store drr if there is something to store and set the flag
pass
if pmu.clients:
## Socket Values
## Listen to the socket
raw = sock_ph.recv(32)
if First:
tm_strt = datetime.now()
First = False
else:
pass
#print(raw)
header, mag, angle = struct.unpack('ddd', raw)
phasor = (mag, angle)
Vol_A=raw
VA = float(mag)
phi_A = float(angle)
VB = VA
phi_B = phi_A+(math.pi) * 2 / 3
VC = VA
phi_C = phi_A-(math.pi) * 2 / 3
phasor_list.append([VA, phi_A, VB, phi_B, VC, phi_C])
# print(len(phasor_list))
if len(phasor_list) >= (1000 / config_rr):
phasor_array = np.array(phasor_list)
#y = np.mean(phasor_array, axis=0)
y = phasor_array[-1] #latest value
time_stp = datetime.now()
sim_time = (time_stp - tm_strt).total_seconds()
# print(y, time_stp, sim_time)
phasor_list = []
pmu.send_data(phasors=[(y[0], y[1]), (y[2], y[3]), (y[4], y[5])], analog=[9.91], digital=[0x0001])
# print([(VA,phi_A),(VB,phi_B),(VC,phi_C),datetime.now()])
#if len(phasor_list) > (1000 / config_rr):
if flag: # if it received something it changes the RR
pmu.set_data_rate(drr)
#time.sleep(1/ 1000)
flag=False
pmu.join()
pyPDC
from synchrophasor.pdc import Pdc
from synchrophasor.frame import DataFrame
from synchrophasor.frame import ConfigFrame2
import time
from synchrophasor.frame import CommandFrame
import copy
import pickle
import sys
import socket
import struct
"""
PDC will connect to pmu_ip:pmu_port and send request
for header message, configuration and eventually
to start sending measurements.
Here it receives data from PMUs, calculates FPS and Data Rate.
Prints and Saves Configured FPS, actual measured FPS and Data Rate along with phasor measurements
"""
if __name__ == "__main__":
tt_list = []
############## Measured Reporting Rates send to OPAL #########################
UDP_IP_OPAL = "10.10.114.21"
# UDP_PORT1fps_send = 8301
# sock_rr_send1 = socket.socket(socket.AF_INET, # Internet
# socket.SOCK_DGRAM) # UDP
UDP_PORT1fps_send = 8301
sock_rr_send1 = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
#init_time = int(time())
#time_delay = 5
pdc = Pdc(pdc_id=7, pmu_ip="10.10.114.22", pmu_port=1410)
pdc.logger.setLevel("DEBUG")
pdc.run() # Connect to PMU
header = pdc.get_header() # Get header message from PMU
config = pdc.get_config() # Get configuration from PMU
cnfg_fps_default = config.get_data_rate()
fps = cnfg_fps_default
pdc.start() # Request to start sending measurements
# print(fps)
timestamps = []
alldata = []
first = True
i = 0
# ## Configure socket for RR Value Change status##
# UDP_IP = "10.10.114.22"
# UDP_PORT = 603 # whether RR is changed or not, if = 1, RR change initiated else 0
# sock_ch = socket.socket(socket.AF_INET, # Internet
# socket.SOCK_DGRAM) # UDP
# sock_ch.bind((UDP_IP, UDP_PORT)) # binding is required for receiving not sending
# sock_ch.settimeout(1 / 100) # you dont want to wait forever a data that might not come
# change = 0
try:
while True:
# try:
# # listening to rr change signal
# change = sock_ch.recv(1024)
# change = int(change.decode("utf-8"))
# #print(change)
# except socket.timeout: # if nothing comes
# pass
# # timing asking each 60s or 1 minute:
# if change == 1: #time() >= (init_time + time_delay) or
# #init_time += time_delay # this is not a pretty way to do it but i think is clear what is happening
#
# # asking the CFG2:
# pdc.pmu_socket.sendto(CommandFrame(pdc.pdc_id, 'cfg2').convert2bytes(), pdc.pmu_address)
# change = 0
#print("Config frame received")
# config = pdc.get_config()
data = pdc.get() # Keep receiving data
if type(data) == ConfigFrame2:
# config = pdc.get_config() # version="cfg2"
cnfg_fps = data.get_data_rate()
print("config frame received and data rate is %f" %cnfg_fps)
if type(data) == DataFrame:
data = data.get_measurements()
# print(type(data),sys.getsizeof(data)) # Type and size of object in bytes
# i+=1
timestamps.append(data['time'])
if first:
timestrt = data["time"] # unix timestamp; gives time in seconds
cnfg_fps = copy.copy(cnfg_fps_default)
first = False
data_size = 9999
data_rate = 9999
else:
timestp = data["time"]
pdc_time = time.time()
transmission_time = (pdc_time-timestp)*1000
tt_list.append(transmission_time)
acctual_fps = 1 / (timestp - timestrt)
data_size = sys.getsizeof(data) # in bits
data_rate = ((data_size) * 8) / (1024 * 1024 * (timestp - timestrt)) # in Mbps
timestrt = timestp
#print("Transmission time is %f ms"%transmission_time)
# print(cnfg_fps, "fps",acctual_fps,"fps",data_rate,"Mbps")
print("Configured FPS = %s ; Actual FPS = %f, Data Rate = %f Mbps" %
(cnfg_fps, acctual_fps, data_rate),"PMU time=",timestp,"pdc time=",time.time())
fps = acctual_fps
timestamp = time.time()
dev_id = 91
msg_id = i
msg_len = 16
send_opal = struct.pack('=hihdd', dev_id, msg_id, msg_len, timestamp, fps)
sock_rr_send1.sendto(send_opal, (UDP_IP_OPAL, UDP_PORT1fps_send)) # send actual fps to OPAL
i = i + 1
alldata.extend((data, fps, cnfg_fps,data_rate,data_size))
if not data:
#pdc.quit() # Close connection
print("Data not coming. Warning !!")
# print(data,type(data))
# break
except ConnectionResetError:
# pdc.stop()
# pdc.quit()
print(tt_list)
timestring = time.strftime("%Y%m%d-%H%M")
with open("sync2_%s.pickle"%timestring, "wb+")as handle:
pickle.dump(alldata, handle)
print("A file has been written....")
Hi all, I have a pyPMU and a pyPDC instance running on the same windows virtual machine. Essentially they are synchronized to the same clock. The pyPMU instance receives phasor data from another source and sends the data as synchrophasor packets to the pyPDC. The pyPDC parses the synchrophasor data, extracts the time stamp
(data['time'])and then compares with the current time (time.time()).The results for this comparison is as follows for data rates 10,25,50,100 fps. RR = reporting rate or Data Rate in frames per sec
As seen in the table the time difference between the synchrophasor time stamp from the PMU, and the time when it is being parsed in the PDC is same as 1\RR. I do not understand why? Any insight? I was under the impression that some random or constant delay will take place in the communication.
The codes are as follows pyPMU
pyPDC