1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
| #include "packetprocess.h"
#include "packet_struct.h"
#include "QDebug"
#include<QtMath>
#include <QDateTime>
#include <netinet/in.h>
moodycamel::ConcurrentQueue<QVector<RadarCell>> packetprocess::cellQueue;
packetprocess::packetprocess(QObject* parent) : QThread(parent)
{}
void packetprocess::addPacket(const QByteArray& packet)
{
packetQueue.enqueue(packet);
}
/*Si arrêt du programme = transmission des dernières coordonnées stockées*/
void packetprocess::stopProcess()
{
stopFlag = true;
if (!tempCells.isEmpty())
{
cellQueue.enqueue(std::move(tempCells));
tempCells.clear();
}
}
Filter *packetprocess::getFilterAddress() { //Définition de la fonction getFilterAddress pour obtenir l'adresse de l'objet m_filter
return &m_filter; //Renvoyer un pointeur vers l'objet Filter pour configurer les filtres
}
/*Décode les paquet, et transmet lorsque nécessaire les données : distance, az_start, az_end, signalLVL au thread vertexConversion*/
void packetprocess::decodeAsterixHeader(const QByteArray& packet)
{
/*Initialisation*/
const Asterix240* asterixHeader = reinterpret_cast<const Asterix240*>(packet.data() + sizeof(MacHeader) + sizeof (IpHeader));
double a_start,a_end,dist;
/*Récupération de l'azimut + start_range + cell_duration*/
uint16_t start_az_raw = (static_cast<uint16_t>(asterixHeader->video_header_nano[0]) <<8) | asterixHeader->video_header_nano[1];
uint32_t start_rg_raw = (asterixHeader->video_header_nano[4] << 24) | (asterixHeader->video_header_nano[5] << 16) | (asterixHeader->video_header_nano[6] << 8) | asterixHeader->video_header_nano[7];
uint16_t end_az_raw = (static_cast<uint16_t>(asterixHeader->video_header_nano[2])<<8) | asterixHeader->video_header_nano[3];
/*Transmission des dernières coordonnées x;y et de signal
*stockés si détection d'un nouveau azimut*/
if (start_az_raw != lastAzimuth && !tempCells.isEmpty())
{
cellQueue.enqueue(std::move(tempCells));
tempCells.clear();
}
lastAzimuth = start_az_raw;
a_start = ((start_az_raw)/2)*M_PI/180.0;
a_end = ((end_az_raw)/2)*M_PI/180.0;
/*Boucle for permettant d'ajouter pour toutes les cellules du paquet en cours : distance, az_start, az_end, signalLVL
* à tempCells*/
for (int i=0;i<(asterixHeader->size_of_video_data)*64;i++)
{
dist = (cell_dur * (start_rg_raw+i+1-1)*c/2.0);
tempCells.append(RadarCell(a_start,a_end,dist,static_cast<double>(asterixHeader->video_block_medium_data_volume[i])));
}
/*Boucle if détectant si le nouveau paquet traité est un paquet de "fin" d'azimut, si oui = transmission des cellules
* tempCells dans cellQueue.*/
if (asterixHeader->size_of_video_data == 15)
{
cellQueue.enqueue(std::move(tempCells));
tempCells.clear();
}
}
void packetprocess::run()
{
while(!stopFlag) {
QByteArray packet;
{
while (packetQueue.try_dequeue(packet))
{
/*Traitemnt de sniff::run*/
m_filter.inputData(packet.data());//Remplissage du databuf de filter permettant les filtrages
if(!m_filter.isIP()) {
continue;}
if(!m_filter.isAllowed()) {
//std::cout <<"PAQUET SAUTÉ" << std::endl; //Test du filtrage des paquets
continue;}
decodeAsterixHeader(packet); //Fonction permettant l'extraction des données voulues
}
}
}
} |
Problème de vitesse VBO et d'émission de signal
Répondre avec citation
.
. 
.
.
Partager