Samuele E. Locatelli
266 lines
9.2 KiB
C#
266 lines
9.2 KiB
C#
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Configuration;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
|
|
namespace MHT_Siemens
|
|
{
|
|
public class utils
|
|
{
|
|
/// <summary>
|
|
/// wrapper di log
|
|
/// </summary>
|
|
public static Logger lg;
|
|
/// <summary>
|
|
/// folder archiviazione dati configurazione (DATA\CONF)
|
|
/// </summary>
|
|
public static string confDir
|
|
{
|
|
get
|
|
{
|
|
return string.Format(@"{0}\{1}", Application.StartupPath, CRS("dataConfPath"));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// legge conf in formato char
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public static char CRC(string key)
|
|
{
|
|
char answ = '-';
|
|
try
|
|
{
|
|
answ = ConfigurationManager.AppSettings[key].ToCharArray()[0];
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// legge conf in formato stringa
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public static string CRS(string key)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = ConfigurationManager.AppSettings[key].ToString();
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// legge conf in formato INT
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public static Int32 CRI(string key)
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(CRS(key));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// legge conf in formato BOOLean
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public static bool CRB(string key)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(CRS(key));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Decodifica file allarme
|
|
/// </summary>
|
|
/// <param name="linea"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="memPre">tipo memoria (R/D/...)</param>
|
|
/// <param name="baseAddr">indirizzo di partenza memoria</param>
|
|
/// <param name="memSize">dimensione singolo slot in byte</param>
|
|
/// <returns></returns>
|
|
protected static otherData decodeOtherData(string linea, char separator, string memPre, int baseAddr, int memSize)
|
|
{
|
|
string[] valori = linea.Split(separator);
|
|
int shift = 0;
|
|
try
|
|
{
|
|
shift = Convert.ToInt32(valori[0]) - 1;
|
|
}
|
|
catch
|
|
{ }
|
|
string memAddr = string.Format("{0}{1}", memPre, baseAddr + shift * memSize);
|
|
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
|
|
}
|
|
/// <summary>
|
|
/// Decodifica file MAP (caso ESA/IOT)
|
|
/// </summary>
|
|
/// <param name="linea"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="ByteNum">indirizzo Byte: indirizzo di partenza memoria</param>
|
|
/// <param name="memSize">dimensione singolo slot in byte</param>
|
|
/// <param name="BitNum">indirizzo bit: numero riga x calcolo indice bit</param>
|
|
/// <returns></returns>
|
|
protected static otherData decodeBitData(string linea, char separator, int ByteNum, int memSize, int BitNum)
|
|
{
|
|
string[] valori = linea.Split(separator);
|
|
int shift = 0;
|
|
try
|
|
{
|
|
shift = Convert.ToInt32(valori[0]) - 1;
|
|
}
|
|
catch
|
|
{ }
|
|
int resto = 0;
|
|
Math.DivRem(BitNum, 8, out resto);
|
|
string memAddr = string.Format("{0}.{1}", ByteNum + shift * memSize, resto);
|
|
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
|
|
}
|
|
/// <summary>
|
|
/// Decodifica file MAP (caso FANUC/OSAI/...)
|
|
/// </summary>
|
|
/// <param name="linea"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="memPre">tipo memoria (R/D/...)</param>
|
|
/// <param name="baseAddr">indirizzo Byte: indirizzo di partenza memoria</param>
|
|
/// <param name="memSize">dimensione singolo slot in byte</param>
|
|
/// <param name="numRiga">indirizzo bit: numero riga x calcolo indice bit</param>
|
|
/// <returns></returns>
|
|
protected static otherData decodeBitData(string linea, char separator, string memPre, int baseAddr, int memSize, int numRiga)
|
|
{
|
|
string[] valori = linea.Split(separator);
|
|
int shift = 0;
|
|
try
|
|
{
|
|
shift = (Convert.ToInt32(valori[0]) - 1) / (8 * memSize);
|
|
}
|
|
catch
|
|
{ }
|
|
int resto = 0;
|
|
Math.DivRem(numRiga, 8 * memSize, out resto);
|
|
string memAddr = string.Format("{0}{1}.{2}", memPre, baseAddr + shift, resto);
|
|
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
|
|
}
|
|
/// <summary>
|
|
/// Legge il file di conf di una MAP di informazioni da gestire con lettura set memoria
|
|
/// </summary>
|
|
/// <param name="vettoreConf">nome vettore memoria</param>
|
|
/// <param name="nomeFile">file origine</param>
|
|
/// <param name="memSize">dimensione (in byte) della memoria</param>
|
|
/// <param name="numVett">dimensione (in byte) della memoria</param>
|
|
public static void loadConfFile(ref otherData[] vettoreConf, string nomeFile, int memSize, ref int numVett)
|
|
{
|
|
otherData lastData = new otherData();
|
|
int totRighe = 0;
|
|
string linea;
|
|
totRighe = File.ReadLines(nomeFile).Count();
|
|
// creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
|
|
vettoreConf = new otherData[File.ReadLines(nomeFile).Count()];
|
|
// carica da file...
|
|
StreamReader file = new StreamReader(nomeFile);
|
|
// leggo 1 linea alla volta...
|
|
int numRiga = 0;
|
|
int bitNum = 0;
|
|
int byteNum = 0;
|
|
while ((linea = file.ReadLine()) != null)
|
|
{
|
|
// SE non è un commento...
|
|
if (linea.Substring(0, 1) != "#")
|
|
{
|
|
// se finisce per BIT allora processo bit-a-bit...
|
|
if (linea.EndsWith("BOOL"))
|
|
{
|
|
try
|
|
{
|
|
string[] memIdx = linea.Split(utils.CRC("charSep"))[0].Split('.');
|
|
// calcolo bit e byte number...
|
|
int.TryParse(memIdx[0], out byteNum);
|
|
if (memIdx.Length > 1)
|
|
{
|
|
int.TryParse(memIdx[1], out bitNum);
|
|
}
|
|
else
|
|
{
|
|
bitNum = 0;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
byteNum = 0;
|
|
bitNum = 0;
|
|
}
|
|
lastData = decodeBitData(linea, utils.CRC("charSep"), byteNum, 1, bitNum);
|
|
vettoreConf[numRiga] = lastData;
|
|
}
|
|
else
|
|
{
|
|
lastData = decodeOtherData(linea, utils.CRC("charSep"), "", 1, memSize);
|
|
vettoreConf[numRiga] = lastData;
|
|
}
|
|
numRiga++;
|
|
}
|
|
}
|
|
// salvo lunghezza file...
|
|
try
|
|
{
|
|
numVett = Convert.ToInt32(lastData.memAddr) + 1;
|
|
}
|
|
catch
|
|
{
|
|
numVett = numRiga + 1;
|
|
}
|
|
// chiudo file
|
|
file.Close();
|
|
// ora trimmo vettore al solo numero VERO dei valori caricati...
|
|
Array.Resize<otherData>(ref vettoreConf, numRiga);
|
|
|
|
if (utils.CRB("verbose")) lg.Info(string.Format("Fine caricamento vettore di {0} variabili per file {1}", numRiga, nomeFile));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dato generico (per decodifica)
|
|
/// </summary>
|
|
public class otherData
|
|
{
|
|
public string codNum;
|
|
public string memAddr;
|
|
public string varName;
|
|
public string dataType;
|
|
public otherData()
|
|
{
|
|
codNum = "";
|
|
memAddr = "";
|
|
varName = "";
|
|
dataType = "";
|
|
}
|
|
public otherData(string _codNum, string _memAddr, string _varName, string _dataType)
|
|
{
|
|
codNum = _codNum;
|
|
memAddr = _memAddr;
|
|
varName = _varName;
|
|
dataType = _dataType;
|
|
}
|
|
}
|
|
}
|