Egalware/CMS-MTConn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

spostato check allarmi osai FUORI dalla classe OSAI in generic, ora procedo x SIEMENS poi testo...

Browse Source
This commit is contained in:
Samuele E. Locatelli
2017-05-12 16:57:53 +02:00
parent dc80939eda
commit bf4262e2dd
3 changed files with 431 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MTC_Adapter/MTC_Adapter/AdapterGeneric.cs
+143 -262
View File
@@ -1612,260 +1612,8 @@ namespace MTC_Adapter
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
}
#region oggetti specifici per CNC OSAI/FANUC/SIEMENS...
#region CNC OSAI
/// <summary>
/// Oggetto MAIN x connessione OSAI
/// </summary>
protected OSAI OSAI_ref;
/// <summary>
/// wrapper chiamata lettura/scrittura OSAI x BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="memOrderStart">0/1 orimo o secondo byte della word...</param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Byte(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, Int32 memOrderStart, ref byte[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x WORD...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Word(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref ushort[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x DOUBLE-WORD...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_DWord(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref uint[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x Short...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Short(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref short[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x INT...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Integer(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref int[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x Double...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Double(bool bWrite, OSAI.MemTypeDouble MemType, Int32 memIndex, ref double[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
#endregion
#region CNC Siemens
/// <summary>
/// Oggetto MAIN x connessione SIEMENS
/// </summary>
protected SIEMENS SIEMENS_ref;
/// <summary>
/// Area di memoria base x MTConnect con SIEMENS (DB1499)
/// </summary>
protected int baseMemDb = 1499;
/// <summary>
/// Area di memoria base x dati UTENSILE (DB253)
/// </summary>
protected int baseMemUT = 253;
/// <summary>
/// Area di memoria base x dati TESTE (DB254)
/// </summary>
protected int baseMemUO = 254;
/// <summary>
/// wrapper chiamata lettura/scrittura SINGOLO BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte Value)
{
bool answ = false;
// chiamo la versione multibyte...
byte[] ValArray = new byte[1];
SIEMENSMemRW_Byte(bWrite, MemType, memIndex, ref ValArray);
Value = ValArray[0];
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_Byte(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI Word...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Word(bool bWrite, int MemType, Int32 memIndex, ref ushort[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_Word(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI DWord...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_DWord(bool bWrite, int MemType, Int32 memIndex, ref uint[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_DWord(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
#endregion
#endregion
#region metodi adapter
/// <summary>
/// lettura file di persistenza
@@ -2081,15 +1829,6 @@ namespace MTC_Adapter
adpTryRestart = true;
parentForm.displayTaskAndWait("Adapter Started!");
}
/// <summary>
/// Effettua refresh del vettore privato degli allarmi attivi
/// </summary>
/// <param name="Alarm2Refresh">flag mask degli allarmi da aggiornare</param>
/// <param name="giveAck">boolean: se si debba tornare ACK</param>
public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
{
// carico lo stato di tutti gli allarmi... forzo a 1 il flag degli allarmi
}
/// <summary>
/// ferma l'adapter...
@@ -2361,6 +2100,8 @@ namespace MTC_Adapter
}
}
#region gestione allarmi
/// <summary>
/// effettua ogni log period una rilettura di TUTTI gli allarmi...
/// </summary>
@@ -2379,6 +2120,146 @@ namespace MTC_Adapter
if (utils.CRB("recTime")) logTimeResults();
}
/// <summary>
/// Effettua refresh del vettore privato degli allarmi attivi
/// </summary>
/// <param name="Alarm2Refresh">flag mask degli allarmi da aggiornare</param>
/// <param name="giveAck">boolean: se si debba tornare ACK</param>
public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
{
// indici memorie allarmi: strobe ed ACK
//int memIndex = 19036;
//int memIndexAck = 19018;
// log bitmap se verboso attivo + ho allarmi da refreshare
if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose"))
{
lg.Info("Richiesto refresh allarmi x bitmask: {0}", utils.binaryForm((int)Alarm2Refresh));
}
bool ackReturned = false;
// byte di acknowledge...
byte[] retACK_DW0 = new byte[4];
// inizio impostando una bitmap x ACK che abbia i bit abbassati se lo strobe è disattivo: AND logico tra STR e ACK
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
inizio = DateTime.Now;
uint[] MemBlock;
// controllo, SE devo leggere tutto uso un unico accesso ai 128byte, altrimenti leggo a blocchi di 32bit...
if (Alarm2Refresh == (StFlag32)unchecked((int)UInt32.MaxValue))
{
// blocco memoria x lettura dati COMPLETO (4Byte*32 = 128Byte)
MemBlock = new uint[32];
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
//OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock);
readAllAlarms(ref MemBlock);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
if (AlarmFlags != null)
{
try
{
// aggiorno vettore allarmi x intero! size del vettore di destinazione (in byte!!!!)
Buffer.BlockCopy(MemBlock, 0, AlarmFlags, 0, AlarmFlags.Length);
}
catch (Exception exc)
{
lg.Error(string.Format("Errore in BLOCKCOPY{0}{1}", Environment.NewLine, exc));
}
}
}
else
{
if (Alarm2Refresh != StFlag32.NONE)
{
// blocco memoria x lettura dati
MemBlock = new uint[1];
// verifico gli allarmi di tutti i bit alzati...
for (int i = 0; i < 32; i++)
{
if (Alarm2Refresh.HasFlag((StFlag32)Math.Pow(2, i)))
{
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
//OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock);
readAlarmBlock(ref MemBlock, i);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
try
{
// aggiorno vettore allarmi x intero!
Buffer.BlockCopy(MemBlock, 0, AlarmFlags, i * 4, 4);
}
catch (Exception exc)
{
lg.Error(string.Format("Errore in BLOCKCOPY per indice i = {2},{0}{1}", Environment.NewLine, exc, i));
}
if (utils.CRI("loglevel") > 5)
{
lg.Info("Bit {0}, MemBlock: {1}", i, MemBlock[0]);
}
// segnalo allarme letto! memorizzo allarme nel vettore ack....
retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i);
}
}
// scrivo ack se richiesto!!!
if (giveAck)
{
// scrivo update ad ack!!!
inizio = DateTime.Now;
//OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
writeAlarmAck(ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
ackReturned = true;
}
}
}
// SE non ho già tornato un ACK...
if (!ackReturned)
{
// se è diverso il vettori degli ACK in memoria da quello PLC...
if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0))
{
// invio INTERO set ACK_DW0 con bit abbassati...
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
inizio = DateTime.Now;
//OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
writeAlarmAck(ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
}
}
}
/// <summary>
/// Scrive vettore ACK degli allarmi
/// </summary>
/// <param name="retACK_DW0"></param>
/// <returns></returns>
public virtual bool writeAlarmAck(ref byte[] retACK_DW0)
{
return false;
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
/// </summary>
/// <param name="MemBlock"></param>
/// <returns></returns>
public virtual bool readAllAlarms(ref uint[] MemBlock)
{
return false;
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
/// </summary>
/// <param name="MemBlock"></param>
/// <param name="blockIndex"></param>
/// <returns></returns>
public virtual bool readAlarmBlock(ref uint[] MemBlock, int blockIndex)
{
return false;
}
#endregion
/// <summary>
/// recupero dati PATH
/// </summary>
public virtual void getPath()
MTC_Adapter/MTC_Adapter/AdapterOsai.cs
+186 -13
View File
@@ -10,6 +10,144 @@ namespace MTC_Adapter
{
public class AdapterOsai : AdapterGeneric
{
/// <summary>
/// Oggetto MAIN x connessione OSAI
/// </summary>
protected OSAI OSAI_ref;
/// <summary>
/// wrapper chiamata lettura/scrittura OSAI x BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="memOrderStart">0/1 orimo o secondo byte della word...</param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Byte(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, Int32 memOrderStart, ref byte[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x WORD...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Word(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref ushort[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x DOUBLE-WORD...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_DWord(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref uint[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x Short...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Short(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref short[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x INT...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Integer(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref int[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura x Double...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType"></param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool OsaiMemRW_Double(bool bWrite, OSAI.MemTypeDouble MemType, Int32 memIndex, ref double[] Value)
{
bool answ = false;
if (OSAI_ref.Connected)
{
try
{
answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// struttura dati OSAI x dati NC (pag 148)
/// </summary>
@@ -18,7 +156,7 @@ namespace MTC_Adapter
/// Vettore degli allarmi CNC attivi
/// </summary>
//public CMSCncLib.OPENcontrol.MSGERROR allarmiCNC;
public Dictionary<string, string> allarmiCNC =new Dictionary<string, string>();
public Dictionary<string, string> allarmiCNC = new Dictionary<string, string>();
/// <summary>
/// estende l'init della classe base...
/// </summary>
@@ -421,6 +559,7 @@ namespace MTC_Adapter
return answ;
}
#if false
/// <summary>
/// recupera allarmi ed aggiorna strobe (privato) degli allarmi
/// </summary>
@@ -429,12 +568,9 @@ namespace MTC_Adapter
public override void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
{
// indici memorie allarmi: strobe ed ACK
int memIndex = 19036;
int memIndexAck = 19018;
//int memIndex = 19036;
//int memIndexAck = 19018;
// log bitmap se verboso attivo + ho allarmi da refreshare
if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose"))
{
@@ -456,7 +592,8 @@ namespace MTC_Adapter
MemBlock = new uint[32];
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock);
//OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock);
readAllAlarms(ref MemBlock);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
if (AlarmFlags != null)
{
@@ -484,7 +621,8 @@ namespace MTC_Adapter
{
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock);
//OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock);
readAlarmBlock(ref MemBlock, i);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
try
{
@@ -508,7 +646,8 @@ namespace MTC_Adapter
{
// scrivo update ad ack!!!
inizio = DateTime.Now;
OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
//OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
writeAlarmAck(ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
ackReturned = true;
}
@@ -521,15 +660,49 @@ namespace MTC_Adapter
// se è diverso il vettori degli ACK in memoria da quello PLC...
if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0))
{
memIndex = 19018;
// invio INTERO set ACK_DW0 con bit abbassati...
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
inizio = DateTime.Now;
OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndex, 0, ref retACK_DW0);
//OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
writeAlarmAck(ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
}
}
}
}
#endif
/// <summary>
/// Scrive vettore ACK degli allarmi
/// </summary>
/// <param name="retACK_DW0"></param>
/// <returns></returns>
public override bool writeAlarmAck(ref byte[] retACK_DW0)
{
int memIndexAck = 19018;
return OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
/// </summary>
/// <param name="MemBlock"></param>
/// <returns></returns>
public override bool readAllAlarms(ref uint[] MemBlock)
{
int memIndex = 19036;
return OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock);
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
/// </summary>
/// <param name="MemBlock"></param>
/// <param name="blockIndex"></param>
/// <returns></returns>
public override bool readAlarmBlock(ref uint[] MemBlock, int blockIndex)
{
int memIndex = 19036;
return OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + blockIndex * 2, ref MemBlock);
}
/// <summary>
/// processing!
/// </summary>
@@ -1332,7 +1505,7 @@ namespace MTC_Adapter
// salvo valori vettore prec...
prevPosAxis[i] = newPos;
prevDirAxis[i] = newDir;
vettAxis[i].mAxFeedOver.Value = FeedRateOver;
}
catch
MTC_Adapter/MTC_Adapter/AdapterSiemens.cs
+102
View File
@@ -10,6 +10,108 @@ namespace MTC_Adapter
{
public class AdapterSiemens : AdapterGeneric
{
/// <summary>
/// Oggetto MAIN x connessione SIEMENS
/// </summary>
protected SIEMENS SIEMENS_ref;
/// <summary>
/// Area di memoria base x MTConnect con SIEMENS (DB1499)
/// </summary>
protected int baseMemDb = 1499;
/// <summary>
/// Area di memoria base x dati UTENSILE (DB253)
/// </summary>
protected int baseMemUT = 253;
/// <summary>
/// Area di memoria base x dati TESTE (DB254)
/// </summary>
protected int baseMemUO = 254;
/// <summary>
/// wrapper chiamata lettura/scrittura SINGOLO BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte Value)
{
bool answ = false;
// chiamo la versione multibyte...
byte[] ValArray = new byte[1];
SIEMENSMemRW_Byte(bWrite, MemType, memIndex, ref ValArray);
Value = ValArray[0];
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI BYTE...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_Byte(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI Word...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_Word(bool bWrite, int MemType, Int32 memIndex, ref ushort[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_Word(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// wrapper chiamata lettura/scrittura MULTI DWord...
/// </summary>
/// <param name="bWrite"></param>
/// <param name="MemType">main address (1499/1500)</param>
/// <param name="memIndex"></param>
/// <param name="MATRICE Value"></param>
/// <returns></returns>
public bool SIEMENSMemRW_DWord(bool bWrite, int MemType, Int32 memIndex, ref uint[] Value)
{
bool answ = false;
if (SIEMENS_ref.Connected)
{
try
{
answ = SIEMENS_ref.S_RW_DWord(bWrite, MemType, memIndex, ref Value);
}
catch
{ }
}
return answ;
}
/// <summary>
/// struttura dati SIEMENS x ALL DYN DATA
/// C:\Users\samuele\Documents\FOCAS A02B-0207-K737_04.20\Document\SpecE\Position\cnc_rddynamic2.htm