python画波形图

import numpy as np
import matplotlib
# matplotlib.use('TkAgg')
# matplotlib.use('GTK3Agg')
import matplotlib.pyplot as plt
import os

# from scipy.signal import resample

# def getNRTMWave(bw=100):
#     tv5GFolder = '/home/ransys/Downloads/tv/'
#     tvName = ['TM1_1_BW5MHz_SCS30kHz.bin', 'TM1_1_BW20MHz_SCS30kHz.bin', 'TM1_1_BW100MHz_SCS30kHz.bin']
#     bwSampleRateDict={
#         100:122.88e6,
#         20:30.72e6,
#         5:7.68e6
#     }

#     targetTv = [tv for tv in tvName if str(bw) in tv][0]

#     fName = os.path.join(tv5GFolder,targetTv)
#     # raw = np.fromfile(fName, dtype=np.complex64)
#     # raw = raw.view(np.float32)
#     # maxVal = max(raw)
#     # raw = raw/maxVal
#     raw = np.fromfile(fName, dtype=np.float32)
#     raw = raw/max(abs(raw))
#     raw = raw.view(np.complex64)
#     len12288 = int(len(raw)*bwSampleRateDict[100]/bwSampleRateDict[bw])
#     # len12288=len(raw)
#     if len12288 != len(raw):
#         sig = resample(raw, len12288)
#     else:
#         sig = raw
#     return sig

# def genPhaseRotatedTV(mod='TM11'):
#     tv5GFolder = '/home/ransys/Downloads/tv/'
#     tvName = ['TM1_1_BW20MHz_SCS30kHz_shift.bin', 'QAM64_shift.bin']

#     targetTv = tvName[0] if mod=='TM11' else tvName[1]

#     fName = os.path.join(tv5GFolder,targetTv)
#     raw = np.fromfile(fName, dtype=np.float32)
#     raw = raw/max(abs(raw))
#     raw = raw.view(np.complex64)
#     sig = raw
#     return sig

# def genTone(fs=122.88e6, tMs=10.0, fTone = 7.68e6/8):
#     # fc = 1e6
#     fc=fTone
#     tNSample = int(tMs*1e-3*fs)
#     t = 2*np.pi*fc*np.arange(tNSample)/fs
#     sig = np.cos(t) + np.sin(t)*1j
#     sig = np.exp(t*1j)
#     return sig

# def genQPSK():

#     qpskList = [1+1j, 1-1j, -1+1j, -1-1j]
#     QPSKMapper = (np.sqrt(2) / 2) * np.asarray(qpskList)
#     ns = 8192*32
#     mapIndex = np.random.randint(0, len(QPSKMapper), ns)
#     QPSKSymbols = QPSKMapper[mapIndex]
#     SPS=4
#     QPSKSymbolsUpsampled = np.zeros(ns*SPS,dtype=complex)
#     QPSKSymbolsUpsampled[::SPS] = QPSKSymbols
#     pulseShape = np.ones(SPS)
#     # Create our raised-cosine filter
#     num_taps = 101
#     beta = 0.35
#     Ts = SPS# Assume sample rate is 1 Hz, so sample period is 1, so *symbol* period is 8
#     t = np.arange(num_taps) - (num_taps-1)//2
#     pulseShape = np.sinc(t/Ts) * np.cos(np.pi*beta*t/Ts) / (1 - (2*beta*t/Ts)**2)
#     QPSKSignal = np.convolve(QPSKSymbolsUpsampled,pulseShape)
#     # plt.plot(np.real(QPSKSignal),np.real(QPSKSignal),'r.')
#     # plt.show()
#     QPSKSignal = resample(QPSKSignal, 8*len(QPSKSignal))
#     return QPSKSignal

# def genQpskOfdm(numSlot=40, fftSize=4096, fs=122.88e6, cpLen = 288, rbList=np.arange(103), bwRb = 273):
#     numSymb = numSlot*14
#     qpskList = [1+1j, 1-1j, -1+1j, -1-1j]
#     qpskMapper = (np.sqrt(2) / 2) * np.asarray(qpskList)
#     numSc = len(rbList)*12
#     numQpsk = numSymb*numSc
#     mapIndex = np.random.randint(0, len(qpskMapper), numQpsk)
#     qpskSeq = qpskMapper[mapIndex]
#     qpskMap = np.zeros((numSc,numSymb),dtype=np.complex64)
#     qpskSymbF =  np.zeros((fftSize,numSymb),dtype=np.complex64)

#     scVal=np.zeros(numSc,dtype=int)
#     fftIdx=np.zeros(numSc,dtype=int)
#     for scCnt in np.arange(numSc):
#         scVal[scCnt] = rbList[int(np.floor(scCnt/12))]*12 + scCnt%12-bwRb*12/2
#         fftIdx[scCnt] = scVal[scCnt]%fftSize

#     # tMs = 500e-6
#     tdLen = int(numSlot*500e-6*122.88e6)
#     td = np.zeros(tdLen,dtype=np.complex64)
#     currSymbPos = 0
#     for symbIdx in np.arange(numSymb) :
#         if symbIdx<numSlot*14/2 and True:
#             if symbIdx%14==0:
#                 cpLen = 352
#             else:
#                 cpLen = 288
#             symbLen = fftSize+cpLen
#             qpskMap[:,symbIdx] = qpskSeq[symbIdx*numSc:(symbIdx+1)*numSc]
#             for scIdx in np.arange(numSc):
#                 qpskSymbF[fftIdx[scIdx],symbIdx] = qpskMap[scIdx, symbIdx]
#             startPos = currSymbPos + cpLen
#             endPos = currSymbPos + symbLen
#             td[startPos:endPos] = np.fft.ifft(qpskSymbF[:,symbIdx])
#             td[currSymbPos:(currSymbPos+cpLen)] = td[(currSymbPos + symbLen-cpLen):(currSymbPos + symbLen)]
#             currSymbPos = currSymbPos + symbLen
#     return td, qpskMap, scVal, fftIdx

# def genInt(len=1228800):
#     ii = np.arange(1228800).astype(np.int16)
#     qq = np.arange(1228800).astype(np.int16)
#     td = ii+qq*1j
#     return td

# isIntDig = False
# # sig = genTone(fs=122.88e6, tMs=30, fTone=120e3)
# # sig = getNRTMWave(100)
# # sig = genQPSK()
# [sig, qpskMap, scVal, fftIdx] = genQpskOfdm(rbList=np.arange(133,150))
# # [sig, qpskMap, scVal, fftIdx] = genQpskOfdm()
# # sig = genPhaseRotatedTV('TM11')
# # sig = genPhaseRotatedTV('QAM64')
# sig = genInt(); isIntDig = True

# sig = sig.astype(np.complex64)
# sigF32 = sig.view(np.float32)
# if isIntDig==False:
#     scale = (2**14)*1.6
#     sigF32 = sigF32/np.max(sigF32)
#     sigF32Scaled = sigF32*scale
# else:
#     sigF32Scaled = sigF32

# sigInt16 = (sigF32Scaled).astype(np.int16)

# # sigF32 =

# # iqDir = '/home/ransys/workspace/ranSys/plf/build/unittest'
# iqDir = '/mnt/c/workspace/ranSys/plf/build/unittest/radio_test/loop_sa_comp/'
# # iqDir = '/home/ransys/workspace/ransys/plf/build/unittest/radio_test/loop_sa_comp/'
# iqDir = '/home/ransys/workspace/ransys/plf/build/unittest/'
# iqDir = '/mnt/c/workspace/ranSys/nr_ue/radio/build/unittest/'
# iqDir = '/home/wzw/rdmaWorkspace/ransys/nr_ue/radio/build/unittest'
# # iqFile = '/home/ransys/Downloads/tx.bin'
# iqFile = 'tx.bin'
# fname = os.path.join(iqDir, iqFile)
# print(fname)
# sigInt16.tofile(fname)

# iqFile = 'tx.c64'
# fname = os.path.join(iqDir, iqFile)
# print(fname)
# sigF32.tofile(fname)

# print("bin file generated in"+iqDir)
# plt.plot(sigInt16[0::2])
# plt.show()
# a=0

# def read_16bit_with_numpy(file_path):
#     with open(file_path, 'rb') as file:
#         binary_data = file.read()
#     data_array = np.frombuffer(binary_data, dtype=np.int16)
#     return data_array

# # file_path = 'rdmaServer.bin'
# file_path = 'rdmaFile.bin'
# # file_path = 'rx.bin'
# data = read_16bit_with_numpy(file_path)
# # print(data)
# plt.plot(data[0::200])
# plt.show()

# def read_and_sample_data(file_path, bit_depth=16, chunk_size=4480, sample_size=1120):
#     byte_depth = bit_depth
#     with open(file_path, 'rb') as file:
#         binary_data = file.read()
#         full_data = np.frombuffer(binary_data, dtype=np.int16)

#     total_points = len(full_data)
#     num_segments = (total_points - chunk_size) // chunk_size + 1

#     sampled_data = []

#     for i in range(num_segments):
#         start_index = i * chunk_size
#         end_index = start_index + sample_size
#         sampled_data.extend(full_data[start_index:end_index])

#     return np.array(sampled_data)

def read_and_sample_data(file_path, bit_depth=16, chunk_size=4480, sample_size=1120):
    byte_depth = bit_depth
    with open(file_path, 'rb') as file:
        binary_data = file.read()
        full_data = np.frombuffer(binary_data, dtype=np.int16)

    # numAnt = 4
    # numSampPerAnt = 560
    # numSampPerSubSymb = numSampPerAnt*numAnt
    # numSampPerSymb = numSampPerSubSymb*8

    # numSampPerSlot = numSampPerSymb*14

    # numInt16PerSamp = 2
    # rxWaveform = np.zeros((4,1228800),dtype=np.complex64)
    # symbLen = np.ones(14)*288+4096;symbLen[0] = symbLen[0] +64
    # sampOff = 0
    # for slot in np.arange(20):
    #     slotBuffOff = numSampPerSlot*numInt16PerSamp*slot
    #     for symb in np.arange(14):
    #         symbBuffOff = numSampPerSymb*numInt16PerSamp*symb
    #         for subSymb in np.arange(8):
    #             subSymbBuffOff = numSampPerSubSymb*numInt16PerSamp*subSymb
    #             sampOff = int(slot*61440 + sampOff + subSymb*560)
    #             for ant in np.arange(numAnt):
    #                 antBuffOff = numSampPerAnt*numInt16PerSamp*ant
    #                 startPos = slotBuffOff + symbBuffOff +subSymbBuffOff + antBuffOff
    #                 currChunk = full_data[startPos:startPos+numSampPerAnt*numInt16PerSamp]
    #                 currChunkF32 = currChunk.astype(np.float32)
    #                 currChunkC64 = currChunkF32.view(np.complex64)
    #                 rxWaveform[ant,sampOff:sampOff+numSampPerAnt] = currChunkC64
    #         sampOff = sampOff + symbLen[symb]

    total_points = len(full_data)
    num_segments = (total_points - chunk_size) // chunk_size + 1

    sampled_data = []

    for i in range(num_segments):
        start_index = i * chunk_size + 1120
        end_index = start_index + sample_size + 1120
        sampled_data.extend(full_data[start_index:end_index])

    return sampled_data
    # return rxWaveform

file_path = 'rdmaFile.bin'
# file_path = 'rdmaFileServer.bin'
# file_path = 'rx.bin'
sampled_array = read_and_sample_data(file_path)
plt.plot(sampled_array[0::2], '-r.')
plt.show()
a = 0