private void Decode_Demande_Info(Communication.Communication_Message message, Trame_Decoder decoder)
{
if (message.Trame.Slave_Adresse == Communication.Slave_Adresses.PC)
{
decoder.Allow_To_Send();
}
}
private void Decode_Logger_Debug(Communication.Communication_Message message)
{
Logger_Debug debugger = new Logger_Debug();
//décompose les datas du message recu
Logger_Debug.Log_Message data = debugger.Trame_To_Data(message.Trame);
//tranforme-les en un Log
string time = $"{message.Heure.Hour}:{message.Heure.Minute}:{message.Heure.Second}:{message.Heure.Millisecond}";
Color color;
switch (data.data.Color)
{
default:
case Logger_Debug.Logger_Debug_Color.Color_Black:
color = Color.black;
break;
case Logger_Debug.Logger_Debug_Color.Color_Blue:
color = Color.blue;
break;
case Logger_Debug.Logger_Debug_Color.Color_Red:
color = Color.red;
break;
}
Logger_New_Line.Logger_Message log = new Logger_New_Line.Logger_Message(time, data.data.Channel, color, data.str);
Logger_New_Line.Logger_Viewer.Add_New_Logger_Line(log);
}
public void Add_Message_To_Queue(Communication.Communication_Message message)
{
if (Decodeurs[0] != null)
{
Decodeurs[0].Pop_Message(message);
}
}
public void Send_Trame(Communication.Communication_Trame trame)
{
Communication.Communication_Message message = new Communication.Communication_Message();
message.Heure = DateTime.Now;
message.Trame = trame;
Push_Message_Out(message);
}
private void Send_Message(Communication.Communication_Message message_to_Send)
{
List <byte> OutputBuffer = new List <byte>();
Sending_Data encoder = new Sending_Data();
SendBytes(serialPort, encoder.Send_Trame(message_to_Send));
}
public void Decodage_Message(Communication.Communication_Message message, Trame_Decoder decoder)
{
if (message == null)
{
return;
}
switch (message.Trame.Instruction)
{
default:
break;
case Communication.Com_Instruction.BOOTLOADER_ACK:
Bootloader_ACK_Recieved = true;
break;
case Communication.Com_Instruction.LOGGER_DEBUG:
Decode_Logger_Debug(message);
break;
case Communication.Com_Instruction.REPONSE_INFO_Multi_FCT:
Decode_Reponse_Info(message);
break;
case Communication.Com_Instruction.REPONSE_INFO_IA:
Decode_Reponse_Info_IA(message);
break;
case Communication.Com_Instruction.ASTAR_CONTENU:
Decode_ASTAR_Contenu(message);
break;
case Communication.Com_Instruction.ASTAR_VECTEURS_Fixes:
Decode_ASTAR_Vector(message, true);
break;
case Communication.Com_Instruction.ASTAR_VECTEURS_Mobiles:
Decode_ASTAR_Vector(message, false);
break;
case Communication.Com_Instruction.STRATEGIE_CHANGEMENT_ETAT:
Decode_Strategie_Changement_Etat(message);
break;
case Communication.Com_Instruction.GRAPHIQUES_ADD_DATA:
Decode_Graphique_Datas(message);
break;
case Communication.Com_Instruction.DEMANDE_INFO:
Decode_Demande_Info(message, decoder);
break;
}
//compte le nombre de messages recus
Nb_Messages_Interpretes++;
}
private void Decode_Reponse_Info_IA(Communication.Communication_Message message)
{
Infos_Carte temp = new Infos_Carte();
//Interprete un message de type "Infos des cartes IA"
//Transforme la trame en un message interpretable
Infos_Carte.Com_Reponse_Info_IA data = temp.Trame_To_Data_IA(message.Trame);
//Maj de la classe contenant les dernieres infos pour toutes les cartes
Last_Data_Received.Update_Last_Data_Received_IA(data);
}
private void Decode_Graphique_Datas(Communication.Communication_Message message)
{
Graphique.st_Graph_Datas datas = new Graphique.st_Graph_Datas();
//décompose les datas du message recu
datas = Graph_viewer.GetComponent <Graphique>().Trame_To_Data(message.Trame);
//Ajoute les data au graphique
if (Graph_viewer != null)
{
Graph_viewer.GetComponent <Graphique>().Ajoute_Data(datas);
}
}
public void Pick_Message(out Communication.Communication_Message message)
{
if (Received_Messages.Count > 0)
{
message = Received_Messages.Dequeue();
return;
}
message = null;
//Aucun message à lire
return;
}
public void Decodage_and_Save_Message(Communication.Communication_Message message, Trame_Decoder decoder)
{
if (message == null)
{
return;
}
//Pour chaque décodeur (chacun son tour)
Decodage_Message(message, decoder);
//Enregistre pour le log
Save_Message(message);
}
public void Push_Message_Out(Communication.Communication_Message message)
{
Nb_Messages_Envoies++;
//Log le message envoyé
this.GetComponent <Interprete_Message>().Save_Message(message);
//Envoi le message sur chaque port connecté
foreach (Trame_Decoder encoder in Decodeurs)
{
encoder.Push_Message_Out(message);
}
}
/* Prend un message, et transforme-le en trame pret à partir, avec en-tête X-bee et CRC */
public byte[] Send_Trame(Communication.Communication_Message Message_to_send)
{
Message_to_send.Trame.XBEE_DEST_ADDR = Communication.Adress_Xbee.ALL_XBEE; //Envoie du PC vers tous les XBEE par defaut
byte[] data = new byte[Message_to_send.Trame.Length + 11];
data[0] = 0x7E; //Xbee API start byte
int length = Message_to_send.Trame.Length + 7;
data[1] = (byte)(length >> 8); //length high
data[2] = (byte)(length & 0xFF); //length low
data[3] = 0x01; //Frame type: Tx, 16 bits addr
data[4] = 0x01; //Frame ID
data[5] = (byte)((int)Message_to_send.Trame.XBEE_DEST_ADDR >> 8); //add high
data[6] = (byte)((int)Message_to_send.Trame.XBEE_DEST_ADDR & 0xFF); //add low
data[7] = 0x00; //Option
byte index = 0;
//Datas
{
data[8] = (byte)(Message_to_send.Trame.Instruction);
data[9] = (byte)(Message_to_send.Trame.Slave_Adresse);
for (index = 0; index < Message_to_send.Trame.Length; index++)
{
data[10 + index] = Message_to_send.Trame.Data[index];
}
}
short API_CRC = 0;
for (index = 3; index < 10 + Message_to_send.Trame.Length; index++)
{
API_CRC += data[index];
}
API_CRC &= 0xFF;
API_CRC = (byte)(0xFF - API_CRC);
data[index] = (byte)(API_CRC);
return(data);
}
private void Decode_Strategie_Changement_Etat(Communication.Communication_Message message)
{
Action_Strategie decoder = new Action_Strategie();
Action_Strategie.Action_Datas data = new Action_Strategie.Action_Datas();
//décompose les datas du message recu
data = decoder.Trame_To_Data(message.Trame);
//Ajoute une ligne à l'historique des changements d'états de la Strategie
if (Action_History_go != null)
{
Action_History_go.GetComponent <Action_History>().Update_Action(data);
}
//Met à jour le tableau avec l'ensemble des actions
Action_Liste.Update_Action(data, data.Robot_ID);
}
public void Add_Data(Communication.Communication_Message message_to_add)
{
if (message_to_add.Trame.Data.Length != Communication.COMMUNICATION_TRAME_MAX_DATA)
{
byte[] new_data = new byte[Communication.COMMUNICATION_TRAME_MAX_DATA];
for (int index = 0; index < message_to_add.Trame.Data.Length; index++)
{
new_data[index] = message_to_add.Trame.Data[index];
}
message_to_add.Trame.Data = new_data;
}
messages.Add(message_to_add);
Nombre_Messages = messages.Count;
}
private void Decode_ASTAR_Vector(Communication.Communication_Message message, bool fixes)
{
ASTAR_VECT.Reception_Message_Astar_Vector(message.Trame, fixes);
}
private void Decode_ASTAR_Contenu(Communication.Communication_Message message)
{
ASTAR.Reception_Message_Astar(message.Trame);
}
public void Save_Message(Communication.Communication_Message message)
{
message.message_number = message_number++;
file_Logger.Write_Logging_Data(message);
}
private void Reading_Task(string file)
{
//vérifie qu'il y a bien des données à lire
if (deserialized_data.messages.Count == 0)
{
return;
}
Interprete_Message Interpreter = this.GetComponent <Interprete_Message>();
//start asynchronous data sending
tasks.Add(Task.Factory.StartNew(async() =>
{
Logger_New_Line.Log($"Start Reading logged data: {System.IO.Path.GetFileName(file)}", 6, Color.black);
Communication.Communication_Message message_output = new Communication.Communication_Message();
DateTime heure_premier_enregistrement = deserialized_data.messages[0].Heure;
TimeSpan delay = new TimeSpan();
DateTime last_hour = heure_premier_enregistrement;
//Si une pause dans la lecture est demandee
while (Pause_Reading_Token)
{
await Task.Delay(100);
}
//Pour chaque message dans la Liste
foreach (Communication.Communication_Message message in deserialized_data.messages)
{
//Attend que l'heure de traiter ce message soit venue
delay = message.Heure.Subtract(last_hour);
await Task.Delay(Math.Abs((int)(delay.TotalMilliseconds / Reading_Speed)));
//interprete ce message
try
{
Interpreter.Add_Message_To_Queue(message);
}
catch
{
Logger_New_Line.Log("Exception while reading", 6, Color.red);
}
Nb_Lines_Read++;
last_hour = message.Heure;
//si on demande l'arret de la lecture
if (Stop_Reading_Token)
{
throw new TaskCanceledException();
}
//Si une pause dans la lecture est demandee
while (Pause_Reading_Token)
{
await Task.Delay(100);
}
}
}));
}
private static async Task <bool> EnvoiAsync(System.IO.Ports.SerialPort serialPort1, Trame_Decoder decoder)
{
byte[] data_to_send;
//Envoie le message
Sending_Data comm = new Sending_Data();
Communication.Communication_Message trame = new Communication.Communication_Message();
trame.Trame.Instruction = Communication.Com_Instruction.BOOTLOADER;
trame.Trame.Slave_Adresse = (Communication.Slave_Adresses)destination_board;
trame.Trame.XBEE_DEST_ADDR = Communication.Adress_Xbee.ALL_XBEE;
int page_length = 0;
//start listening for messages and copy the messages back to the client
foreach (string _line in _lines)
{
byte _line_length = TwoChar_To_Byte(_line[1], _line[2]);
page_length += _line_length;
data_to_send = ReadHexLine_to_ByteArray(_line);
trame.Trame.Length = (byte)data_to_send.Length;
for (int i = 0; i < data_to_send.Length; i++)
{
trame.Trame.Data[i] = data_to_send[i];
}
//Envoi du message
decoder.Push_Message_Out(trame);
//Cree une trame de communication
line_number_position++;
/*await Task.Delay(2);
* if(page_length >= 4096)
* {
* await Task.Delay(200);
* page_length = 0;
* }*/
//await Task.Delay(1);
while (decoder.Received_Messages.Count == 0)
{
;
}
if (decoder.Received_Messages.Dequeue().Trame.Instruction == Communication.Com_Instruction.BOOTLOADER_ACK)
{
await Task.Delay(1);
}
else
{
return(false);
}
if (cancellationToken)
{
throw new TaskCanceledException();
}
}
return(true);
}
public void Push_Message_Out(Communication.Communication_Message message)
{
this.serialport.OutputMessages.Enqueue(message);
}
public void Start()
{
data_test = new Infos_Carte.Com_Reponse_Info();
data_test.Numero_Robot = Infos_Carte.Com_Position_Robot_Identification.Gros_Robot;
data_test.Numero_Carte = 1;
data_test.PositionRobot.Position_X = 2500;
data_test.PositionRobot.Position_Y = 10000;
data_test.PositionRobot.Angle = 12300;
data_test.Position_Servos = new Infos_Carte.Com_Position_Servos();
data_test.Position_Servos.Position = new ushort[Infos_Carte.NB_SERVO];
data_test.Position_Servos.Position[0] = 500;
data_test.Position_Servos.Position[1] = 600;
data_test.Position_Servos.Position[2] = 300;
data_test.Position_Servos.Position[3] = 800;
data_test.Position_Servos.Position[4] = 100;
data_test.Position_Servos.Position[5] = 50;
data_test.Position_AX12 = new Infos_Carte.Com_Position_AX12();
data_test.Position_AX12.Position = new ushort[Infos_Carte.NB_AX_12];
data_test.Position_AX12.Position[0] = 500;
data_test.Position_AX12.Position[1] = 250;
data_test.Position_AX12.Position[2] = 26;
data_test.Position_AX12.Position[3] = 128;
data_test.Position_AX12.Torque = new short[Infos_Carte.NB_AX_12];
data_test.Position_AX12.Torque[0] = 500;
data_test.Position_AX12.Torque[1] = 250;
data_test.Position_AX12.Torque[2] = 26;
data_test.Position_AX12.Torque[3] = 128;
data_test.Mesures_Analogiques = new Infos_Carte.Com_Mesures_Analogiques();
data_test.Mesures_Analogiques.Mesure = new ushort[Infos_Carte.NB_MES_ANA];
data_test.Mesures_Analogiques.Mesure[0] = 1023;
data_test.Mesures_Analogiques.Mesure[1] = 2046;
data_test.Mesures_Analogiques.Mesure[2] = 3069;
data_test.Mesures_Analogiques.Mesure[3] = 4092;
data_test.Tension_Batterie = 1524;
data_test.Etat_Alim = 0b11111111;
data_test.Etat_Contacteurs = 0b11111111;
Communication com = new Communication();
Communication.Communication_Message message = new Communication.Communication_Message();
message.Heure = DateTime.Now;
message.Trame.Instruction = Communication.Com_Instruction.REPONSE_INFO_Multi_FCT;
message.Trame.Data = com.COPYDATA(data_test);
//Communication_GO.GetComponent<Interprete_Message>().Decodage_and_Save_Message(message);
data_test.Numero_Robot = Infos_Carte.Com_Position_Robot_Identification.Petit_Robot;
data_test.Numero_Carte = 1;
data_test.PositionRobot.Position_X = 10000;
data_test.PositionRobot.Position_Y = 15000;
data_test.PositionRobot.Angle = 0;
message.Trame.Data = com.COPYDATA(data_test);
//this.StartCoroutine("test_logger_quantity");
//this.StartCoroutine(test_logger_saver());
Trame_Decoder[] encoder = Communication_GO.GetComponentsInChildren <Trame_Decoder>();
tasks.Add(Task.Factory.StartNew(async() =>
{
await Task.Delay(15000);
for (int i = 0; i < 4000; i++)
{
data_test.PositionRobot.Position_X++;
//data_test.PositionRobot.Position_Y--;
data_test.PositionRobot.Angle += 3;
message = new Communication.Communication_Message();
message.Heure = DateTime.Now;
message.Trame.Instruction = Communication.Com_Instruction.REPONSE_INFO_Multi_FCT;
message.Trame.Data = com.COPYDATA(data_test);
encoder[0].Push_Message_Out(message);
await Task.Delay(150);
}
}));
}
/* Reception des octets reçus et transformation en une trame brute */
public static Communication.Communication_Message ReadTrame(Virtual_SerialPort _SerialPort)
{
Communication.Communication_Message received_message = new Communication.Communication_Message();
byte API_start = 0, API_LENGTH_HIGH = 0, API_LENGTH_LOW = 0, API_DUMMY, API_FRAME_TYPE = 0;
short API_LENGTH = 0;
short crc = 0;
byte index = 0, rx_crc = 0;
//reception de l'heure de la trame
received_message.Heure = DateTime.Now;
//Reception En-tête API
byte boucle = 0;
while (API_start != 0x7E)
{
_SerialPort.ReadRemoveInputByte(out API_start);
boucle++;
if (boucle > 5)
{
Debug.Log("API_start != 0x7E");
return(null);
}
}
//Le start byte est recu, on demarre la lecture de la trame
_SerialPort.ReadRemoveInputByte(out API_LENGTH_HIGH);
_SerialPort.ReadRemoveInputByte(out API_LENGTH_LOW);
API_LENGTH = API_LENGTH_HIGH;
API_LENGTH <<= 8;
API_LENGTH += API_LENGTH_LOW;
if (API_LENGTH > Communication.COMMUNICATION_TRAME_MAX_DATA + 11)
{
Debug.Log("API_LENGTH > Communication.COMMUNICATION_TRAME_MAX_DATA + 11");
return(null);
}
//Packet Type
_SerialPort.ReadRemoveInputByte(out API_FRAME_TYPE);
crc += API_FRAME_TYPE;
if (API_FRAME_TYPE == 0x89)
{
//Tx status
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
if (API_DUMMY == 00)
{
//Mess tx succes
//RxXbeeAck = OK;
}
//API CRC
_SerialPort.ReadRemoveInputByte(out rx_crc);
return(null);
}
boucle = 0;
while (_SerialPort.Number_Byte_To_Read() < API_LENGTH - 1)
{
boucle++;
if (boucle > 50)
{
Debug.Log($"_SerialPort.InputBuffer.Count < API_LENGTH - 1; boucle {_SerialPort.Number_Byte_To_Read()}/{API_LENGTH + 1}");
return(null);
}
Task.Delay(1);
}
//Tx Address
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
//RSSI
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
//Option
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
crc += API_DUMMY;
//Reception datas
//Instruction
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
received_message.Trame.Instruction = (Communication.Com_Instruction)(API_DUMMY);
crc += (byte)received_message.Trame.Instruction;
//Slave Address
_SerialPort.ReadRemoveInputByte(out API_DUMMY);
received_message.Trame.Slave_Adresse = (Communication.Slave_Adresses)(API_DUMMY);
crc += (byte)received_message.Trame.Slave_Adresse;
//Trame length
received_message.Trame.Length = (byte)(API_LENGTH - 7);
if (received_message.Trame.Length > Communication.COMMUNICATION_TRAME_MAX_DATA)
{
Debug.Log("received_message.Trame.Length > Communication.COMMUNICATION_TRAME_MAX_DATA");
return(null);
}
boucle = 0;
while (_SerialPort.Number_Byte_To_Read() < received_message.Trame.Length + 1)
{
boucle++;
if (boucle > 50)
{
Debug.Log("SerialPort.InputBuffer.Count < received_message.Trame.Length + 1; boucle");
return(null);
}
Task.Delay(1);
}
//Reception des data
for (index = 0; index < received_message.Trame.Length; index++)
{
_SerialPort.ReadRemoveInputByte(out received_message.Trame.Data[index]);
crc += (byte)(received_message.Trame.Data[index]);
}
//API CRC
_SerialPort.ReadRemoveInputByte(out rx_crc);
//Contrôle CRC
crc &= 0xFF;
crc = (byte)(0xFF - crc);
//Vérifie le CRC
if (crc == rx_crc)
{
return(received_message);
}
else
{
if (index == 0)
{
Debug.Log($"Error Comm CRC: {crc}/RX crc: {rx_crc}; previous: {(byte)received_message.Trame.Slave_Adresse}, instruction: {received_message.Trame.Instruction}");
}
else
{
Debug.Log($"Error Comm CRC: {crc}/RX crc: {rx_crc}; previous: {received_message.Trame.Data[index - 1]}, instruction: {received_message.Trame.Instruction}");
}
return(null);
}
}
public void Pop_Message(Communication.Communication_Message message)
{
Received_Messages.Enqueue(message);
}
