CITATION(gillesdrone @ 17 May 2010, 12:09)
vous confirmez que vous retrouvez le meme fonctionnement pour le SPO qu'avec FC1 ?
he oui.
Par contre, en captant mieux le lua, j'ai éssayé la chose suivante :
dans mon idée, il faudrait gerer le SPO dans le lua avant d'envoyer les infos au serveur SIOC. de façon a gerer, par exemple les led menace principale, comme le fait Lecréole avec _MCPState, cad une valeur binaire qui n'a besoin besoin que de la fonction sioc TESTBIT.
quelques avantages :
en tout premier, discerner le signal principal, des signaux secondaire , de façon a n'utiliser que ses paramètres a lui pour le power , et plus tard : le type (pas encore implémenté)...
les leds s'eiteigne quand la menace disparait.
On peut gere autant de menaces secondaires que l'on souhaite
Ben ça marche pas mal.... he, he, he
On va exploiter la fonction lua
LoGetTWSInfo()il y'a tout ce qu'il faut pour allumé notre SPO
cette fonction renvoi 2 objets
1- le mode courant, facile a récupérer
2- une table des menaces contenant paur chaque menace, 6 parametres
ID =, -- world ID
Type = {level1,level2,level3,level4}, -- world database classification of emitter
Power =, -- power of signal
Azimuth =,
Priority =,-- priority of emitter (int)
SignalType =, -- string with vlues: "scan" ,"lock", "missile_radio_guided","track_while_scan";
algo de mon traitement
1- creer une table de 10 lignes et 7 colones
chaque ligne est le détail d'une menace contenat ses 7 parametres
rq : qulqu'un sait combien de signaux peuvent etre capté par le SPO dans la vrai vie?
2- je fait une boucle de lecture de toutes les menaces détecté par le SPO
pour chaque "signal", allimentation de de mon tableau ligne a ligne
3 - déterminer le signal principale:
boucle de lecture de mon tableau pour identifier le signal ayant le Priority le plus élever
apres cette étapes, j'ai :
1-le signal principal avec son Power, azimut, ID et Type :-> gerera les leds azimut orange et power
2-une table de tous les autres signaux avec azimut et Type :-> gerea les leds azimut vertes
a coté de ça, je creé quelques fonction utiles pour tout gere dans le lua
-function SPOledAzim(Azimut) : prend un azimut en entree, et renvoi une table de 10 poste, correspondant aux 10 leds azimut (principale ou secondaire)
-function SPOConversion(t_Led) : prend une table de 10 poste (correspondant aux 10 leds azimut) et renvoi un nombre en binaire qui sera envoyé a SIOC a travers un offset
-function SPOdetermineLedVerte(t_LedVerte) : prend une matrice contenant 10 tables t_Led en entree et renvoi une table de 10 poste t_Led : cette fonction a pour but de combiner les divers signaux vert de facon a envoyé au SIOC une "concaténation" des signaux vert
les leds vertes ne clignoterons pas car a chaque boucle c'est la concaténation qui sera interprété par lua.
j'ai égallement crée 2 autres fonctions pour géré le signal principal
-function SPOdeterminePowerMenacePrincipale(power) : prend un power en entrée, et renvoi une valeur binaire qui sera envoyé a SIOC a trvers un offset
-function SPOledBH(_Alt1,_Alt2) : prend 2 altitude en entre et renvoi un chiffre qui sera envoyé a SIOC a trvers un offset.
code commenté, a ajouter dans la boucle principale apres la fin de LoGetPayloadInfo() par exemple _LoGetTWSInfo2 = LoGetTWSInfo()
if _LoGetTWSInfo2 then
-- SPO Mode : 0:all, 1:lock only, 2:launch only
envoyerInfo("270",_LoGetTWSInfo2.Mode)
-- nombre de radar détecté par le SPO
local _tableSPO = _LoGetTWSInfo2.Emitters
local _NbreSignaux = table.getn(_tableSPO);
envoyerInfo("271",table.getn(_tableSPO))
-- déclaration table des 10 signaux recu par le SPO
logData("******** Detection SPO **************")
t_menace = {} -- create the matrix
for i=1,10 do
t_menace[i] = {} -- create a new row
for j=1,7 do
t_menace[i][j] = 0
end
end
--t_LedVerte = 10 poste de chcun des azimut
t_LedVerte = {} -- create the matrix
for s=1,10 do
t_LedVerte[s] = {} -- create a new row
for u=1,10 do
t_LedVerte[s][u] = 0
end
end
local _ModesScan ={scan=0,lock=1,missile_radio_guided=2,track_while_scan=3,missile_active_homing=
4}
-- allimentation de mon tableau avec le emmitter_table
for i = 1, _NbreSignaux do
_objet = _tableSPO[i]
t_menace[i][1] = _objet.Power*1000
t_menace[i][2] = _objet.Azimuth*1000
local objEmitters = LoGetObjectById(_objet.ID)
t_menace[i][3] = objEmitters.Name
t_menace[i][4] = tonumber(_objet.Type.level1.._objet.Type.level2.._objet.Type.level3.._objet.Type.level4)
t_menace[i][5] = _objet.Priority
local _strScan = _objet.SignalType
t_menace[i][6] = _ModesScan[_strScan]
--local _Menacedtail = "avion = "..t_menace[i][3].." avec SignalType ****".._objet.SignalType
--logData(_Menacedtail)
t_menace[i][7] = _objet.ID
end
-- déclaration de variable contenant le signal principale
local Pri_pow = 0 -- power de la menace principale
local Prim_Azim = 0 -- azimut de la menace principale
local Prim_Name = 0 -- nom de la menace principale
local Prim_Type = 0 -- type menace principale
local Prim_Priority = 0 -- Priorité signal
local Prim_SignalType = 0 -- signal : scan=0,lock=1,missile_radio_guided=2,track_while_scan=3,missile_active_homing=4
local Prim_ID = 0
k = 0 -- nombre de menace secondaire
logData("tableau des menaces");
for j = 1, table.getn(t_menace) do
-- regle de détermination du plus menacçant : priority le plus élevé
if t_menace[j][5] > 0 then
--** detail radar détecté par SPO
local _Menacedtail = "présence radar : ".. t_menace[j][3].." : Pwr = "..t_menace[j][1].." Azim = "..t_menace[j][2].." Priority = "..t_menace[j][5].." SignalType = "..t_menace[j][6]
logData(_Menacedtail)
if t_menace[j][5] > Prim_Priority then
Pri_pow = t_menace[j][1]
Prim_Azim = t_menace[j][2]
Prim_Name = t_menace[j][3]
Prim_Type = t_menace[j][4]
Prim_Priority = t_menace[j][5]
Prim_SignalType = t_menace[j][6]
Prim_ID = t_menace[j][7]
end
k= k + 1
_LibMenace = " signal menace(s) secondaire = "..t_menace[j][3]..", Azimut="..t_menace[j][2]..", Type="..t_menace[j][4]..", Priority = "..t_menace[j][5]
logData(_LibMenace)
SPOledAzim(t_menace[j][2]) -- prend un azimut , renvoi un t_Led
t_LedVerte[k] = t_Led
end
end
-- a ce stade, nous avons la menace principale avec les var PRi_xxx et un tableau contenant 10 tables pour 10 potentiel menaces secondaire.
remarque : les leds vertes s'allume pour les menaces secondaires et egalement la principale, c'est ce que j'en comprend.
-- ********************************************************************************
**************************
--******************************* MENACE PRINCIPALE ************************************************
local _LibMenace = " signal menace Principal = "..Prim_Name.."-"..Prim_Type..", Priority = "..Prim_Priority..", Power = "..Pri_pow
logData(_LibMenace)
if _NbreSignaux == 0 then
envoyerInfo("272", 0) -- azimut
envoyerInfo("276", 0) -- power
envoyerInfo("278", 0) -- B/H
envoyerInfo("274", 0) -- type
envoyerInfo("277", 0) -- Signal
else
--1_AZIMUT
-- appel fonction determination azimut -> led
SPOledAzim(Prim_Azim)
-- conversion en base binaire
SPOConversion(t_Led)
-- envoi AZIMUT offset qui sert a SIOC : 2 72
envoyerInfo("272", _Traduc);
--2_Power
SPOdeterminePowerMenacePrincipale(Pri_pow)
envoyerInfo("276",_ValPower);
--3_Type
envoyerInfo("275",Prim_Type);
-- pour l'instant, je ne l'exploite qu'a travers le SIOC avec les fonction de Lecreole/Gillesdrone (offset 175)
--4_Signal {scan=0,lock=1,missile_radio_guided=2,track_while_scan=3,missile_active_homing=4
}
-- pas compris pour l'instant, j'utilise _LoGetTWSInfo de Lecreole.
--5_Position relative signal principale (au dessus, en dessous)
--5a altitude menace principale
local _objEmitterP = LoGetObjectById(Prim_ID);
local _AltiMenacePrincipal = _objEmitterP.LatLongAlt.Alt;
--5b- mon altitude
local _objMoi = LoGetSelfData();
local _AltimonAvion = _objMoi.LatLongAlt.Alt;
SPOledBH(_AltiMenacePrincipal,_AltimonAvion)
envoyerInfo("278",_ValBH);
end
-- ********************************************************************************
**************************
--******************************* MENACE SECONDAIRE *************************************************
if _NbreSignaux == 0 then
envoyerInfo("273", 0) -- azimut
envoyerInfo("275", 0) -- type
else
-- appel fonction determination azimut -> led
SPOdetermineLedVerte(t_LedVerte);
-- conversion en base binaire
SPOConversion(t_Led)
-- envoi AZIMUT offset qui sert a SIOC : 273
envoyerInfo("273",_Traduc)
end
end
-- ci dessous les fonction lua a ajouter a la fin du fichier principal, apres la fonction function logData(message)function SPOledAzim(Azimut)
L0 = math.ceil(Azimut * 5.729578)
t_Led = {0,0,0,0,0,0,0,0,0,0} -- table contenant les dix led Azimut '0'(eteint) ou '1' (allumé)
--********************************
if L0 < -11000 then
t_Led[1]= 1
end
--********************************
if L0 > -11000 and L0 <= -6000 then --LED - 90
t_Led[2]= 1
end
--********************************
if L0 >= -8000 and L0 <= -3500 then --LED -50
t_Led[3]= 1
end
--********************************
if L0 >= -4500 and L0 <= -1500 then --LED -30
t_Led[4]= 1
end
--********************************
if L0 >= -2500 and L0 <= 500 then
t_Led[5]= 1
end
--********************************
if L0 >= -500 and L0 <= 2500 then
t_Led[6]= 1
end
--********************************
if L0 >= 1500 and L0 <= 4400 then
t_Led[7]= 1
end
--********************************
if L0 >= 3500 and L0 <= 8000 then
t_Led[8]= 1
end
--********************************
if L0 >= 6000 and L0 <= 11000 then
t_Led[9]= 1
end
--********************************
if L0 > 11000 then --LED ARRIERE DROITE
t_Led[10]= 1
end
return t_Led
end
function SPOConversion(t_Led)
_Traduc = 0
if t_Led[1] ==1 then
_Traduc = _Traduc + 1
end
if t_Led[2] ==1 then
_Traduc = _Traduc + 256
end
if t_Led[3] ==1 then
_Traduc = _Traduc + 128
end
if t_Led[4] ==1 then
_Traduc = _Traduc + 64
end
if t_Led[5] ==1 then
_Traduc = _Traduc + 32
end
if t_Led[6] ==1 then
_Traduc = _Traduc + 16
end
if t_Led[7] ==1 then
_Traduc = _Traduc + 8
end
if t_Led[8] ==1 then
_Traduc = _Traduc + 4
end
if t_Led[9] ==1 then
_Traduc = _Traduc + 2
end
if t_Led[10] ==1 then
_Traduc = _Traduc + 512
end
return _Traduc
end
function SPOdetermineLedVerte(t_LedVerte)
t_Led = {0,0,0,0,0,0,0,0,0,0} -- table contenant les dix led Azimut '0'(eteint) ou '1' (allumé)
local _sum = 0
--[[
for p=1,10 do
local _LibMenace = "boucle itérative table t_LedVerte : poste"..p
for toto = 1, 10 do
_LibMenace = _LibMenace..", V"..toto.." = "..t_LedVerte[p][toto]
end
logData(_LibMenace)
end
--]]
for x=1,10 do
_sum = 0
for y=1,10 do
_sum = _sum + t_LedVerte[y][x]
end
if _sum > 0 then
t_Led[x] = 1
end
end
logData(& quot;***************************************************************************
**")
_LibMenace = "*************************resultat du cumul"
for toto = 1, 10 do
_LibMenace = _LibMenace..", V"..toto.." = "..t_Led[toto]
end
logData(_LibMenace)
logData(& quot;***************************************************************************
**")
return t_Led
end
function SPOdeterminePowerMenacePrincipale(power)
_ValPower = 0
if power > 0 then
_ValPower = 1
end
if power > 50 then
_ValPower = _ValPower + 2
end
if power > 100 then
_ValPower = _ValPower + 4
end
if power > 150 then
_ValPower = _ValPower + 8
end
if power > 210 then
_ValPower = _ValPower + 16
end
if power > 280 then
_ValPower = _ValPower + 32
end
if power > 330 then
_ValPower = _ValPower + 64
end
if power > 400 then
_ValPower = _ValPower + 128
end
if power > 520 then
_ValPower = _ValPower + 256
end
if power > 600 then
_ValPower = _ValPower + 512
end
if power > 666 then
_ValPower = _ValPower + 1024
end
if power > 730 then
_ValPower = _ValPower + 2048
end
if power > 800 then
_ValPower = _ValPower + 4096
end
if power > 865 then
_ValPower = _ValPower + 8192
end
if power > 900 then
_ValPower = _ValPower + 16384
end
return _ValPower
end
function SPOledBH(_Alt1,_Alt2)
-- ne connaissant pas les regle exacte pour la gestion des led B et H, je part du principe que :
-- si le signal est a + de 3000 m de moi, c'est la B qui s'allume
-- si le signal est a - de 3000 m de moi, c'est la H qui s'allume
-- si entre -3000 et 3000, B et H allumé
_ValBH= 0
local _delta = _Alt1 - _Alt2
if _delta > 3000 then
-- au dessus
_ValBH = 1
else
if _delta > -3000 then
-- meme niveau
_ValBH = 2
else
-- en dessous.
_ValBH = 3
end
end
_LibMenace = " _AltiMenacePrincipal = ".._Alt1..", _AltimonAvion = ".._Alt2.." : delta = ".._delta.." équivalent a _ValBH = ".._ValBH
logData(_LibMenace)
return _ValBH
end
-- ********************************
-- coté SIOC : beaucoup plus simple
--********************************........
Var 0270, name Lo2_twsMode
Var 0271, name Lo2_NbrEmiter
Var 0272, name LedSPOPri
{
CALL &Sub_Principal, &LedSPOPri
}
Var 0273, name LedSPOSec
{
CALL &Sub_Second, &LedSPOSec
}
Var 0274, name SPOtypePrin
{
&TypeSPOpri = &SPOtypePrin
CALL &typAWACS
CALL &typAERO
CALL &typLONGP
CALL &typMOYENP
CALL &typSHORTP
CALL &typEWR
}
Var 0275, name SPOtypeSec
Var 0276, name SPO_Pw_Pr
{
CALL &Sub_PowPrin, &SPO_Pw_Pr
}
Var 0277, name signSPO // etat du signal SPO / Scan, Lock etc
Var 0278, name SPOledBH
{
CALL &Sub_SPO_BH, &SPOledBH
}
....
avecVar 0822, name Sub_Principal, Link SUBRUTINE // Azimuth SPO
{
L0 = &LedSPOPri
&V_SPOARG = TESTBIT L0 ,0 // 1=AG
&V_SPOD90 = TESTBIT L0 ,1 // 2=G90
&V_SPOD50 = TESTBIT L0 ,2 // 4=G50
&V_SPOD30 = TESTBIT L0 ,3 // 8=G30
&V_SPOD10 = TESTBIT L0 ,4 // 16=G10
&V_SPOG10 = TESTBIT L0 ,5 // 32=D10
&V_SPOG30 = TESTBIT L0 ,6 // 64=D30
&V_SPOG50 = TESTBIT L0 ,7 // 128=D50
&V_SPOG90 = TESTBIT L0 ,8 // 256=D90
&V_SPOARD = TESTBIT L0 ,9 // 512=AD
}
Var 0823, name Sub_Second, Link SUBRUTINE // Azimuth SPO
{
L0 = &LedSPOSec
&V_verSPOAG = TESTBIT L0 ,0 // 1=AG
&V_verSPOD90 = TESTBIT L0 ,1 // 2=D90
&V_verSPOD50 = TESTBIT L0 ,2 // 4=D50
&V_verSPOD30 = TESTBIT L0 ,3 // 8=D30
&V_verSPOD10 = TESTBIT L0 ,4 // 16=D10
&V_verSPOG10 = TESTBIT L0 ,5 // 32=G10
&V_verSPOG30 = TESTBIT L0 ,6 // 64=G30
&V_verSPOG50 = TESTBIT L0 ,7 // 128=G50
&V_verSPOG90 = TESTBIT L0 ,8 // 256=G90
&V_verSPOAD = TESTBIT L0 ,9 // 512=AD
}
Var 0801, name Sub_PowPrin , Link SUBRUTINE // Power SPO
{
L0 = &SPO_Pw_Pr
&V_PSPO1 = TESTBIT L0 ,0
&V_PSPO2 = TESTBIT L0 ,1
&V_PSPO3 = TESTBIT L0 ,2
&V_PSPO4 = TESTBIT L0 ,3
&V_PSPO5 = TESTBIT L0 ,4
&V_PSPO6 = TESTBIT L0 ,5
&V_PSPO7 = TESTBIT L0 ,6
&V_PSPO8 = TESTBIT L0 ,7
&V_PSPO9 = TESTBIT L0 ,8
&V_PSPO10 = TESTBIT L0 ,9
&V_PSPO11 = TESTBIT L0 ,10
&V_PSPO12 = TESTBIT L0 ,11
&V_PSPO13 = TESTBIT L0 ,12
&V_PSPO14 = TESTBIT L0 ,13
&V_PSPO15 = TESTBIT L0 ,14
}
Var 0500, name Sub_SPO_BH, Link SUBRUTINE // gestion du B/H SPO
{
IF &SPOledBH = 0
{
&V_lockB = 0
&V_lockH = 0
}
ELSE
{
IF &SPOledBH = 1
{
&V_lockB = 1
&V_lockH = 0
}
IF &SPOledBH = 2
{
&V_lockB = 1
&V_lockH = 1
}
IF &SPOledBH = 3
{
&V_lockB = 0
&V_lockH = 1
}
}
}
-- ca marche bien chez moi, mais ca reste experimental, il y'a surement quelques optimisations a faire ...
-- les prb restants :
1- type de menaces, j'aimerai connaitre la regle pour coder la correspondance Type, led dans le SIOC pour gerer les led comme le reste
2- SignalType : (scan=0,lock=1,missile_radio_guided=2,track_while_scan=3,missile_active_homing=4
) , on en a besoins pour eteindre les led lorsque le SPO ne capte plus de signal (quand on tire fort sur le manche...)
mais je ne comprend pas comment c'est gerer... du coup je garde le code de Lecreole juste pour ça :
_LoGetTWSInfo = LoGetTWSInfo()
local _SignalType ={scan=0,lock=0,missile_radio_guided=0,track_while_scan=0}
local _SignalTypeValeur ={scan=0,lock=1,missile_radio_guided=2,track_while_scan=3}
local _SignalTypeCode = 0;
for k,v in pairs(_LoGetTWSInfo.Emitters) do
local objEmitters = LoGetObjectById(v.ID);
if _SignalType[v.SignalType]==0 then
_SignalType[v.SignalType] = 1;
_SignalTypeCode = _SignalTypeCode + math.pow(2, _SignalTypeValeur[v.SignalType]);
end
end
envoyerInfo("277",_SignalTypeCode);
n'hésiter pas à tester et a améliorer mon code
je ne connais pas bien le lua.