public static extern bool gambatte_getmemoryarea(IntPtr core, MemoryAreas which, ref IntPtr data, ref int length);
public static extern void GetMemoryAreas(IntPtr g, [Out] MemoryAreas mem);
public static extern void BizGetMemoryAreas(IntPtr ctx, [Out] MemoryAreas dst);
public static extern bool gambatte_getmemoryarea(IntPtr core, MemoryAreas which, ref IntPtr data, ref int length);
public abstract bool sameboy_getmemoryarea(IntPtr core, MemoryAreas which, ref IntPtr data, ref int length);
public abstract void BizGetMemoryAreas(IntPtr ctx, [Out] MemoryAreas dst);
private static bool IsVariableTypeValidForAddress(PlcMemoryModes operatingMode, MemoryAreas area, VariableTypes variableType, int memoryAddress, bool writeRequired)
{
if (operatingMode == PlcMemoryModes.CSCJMode)
{
switch (area)
{
case MemoryAreas.CIO:
switch (variableType)
{
case VariableTypes.Bit:
case VariableTypes.BitWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 614315), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
case VariableTypes.Word:
case VariableTypes.WordWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 6143), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.WR:
switch (variableType)
{
case VariableTypes.Bit:
case VariableTypes.BitWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 51115), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
case VariableTypes.Word:
case VariableTypes.WordWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 511), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.DM:
switch (variableType)
{
case VariableTypes.Bit:
Contract.Assert(memoryAddress.Between(0, 3276715), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
case VariableTypes.Word:
Contract.Assert(memoryAddress.Between(0, 32767), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.HR:
switch (variableType)
{
case VariableTypes.Bit:
case VariableTypes.BitWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 51115), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
case VariableTypes.Word:
case VariableTypes.WordWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 511), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.AR:
switch (variableType)
{
case VariableTypes.Bit:
case VariableTypes.BitWithForcedStatus:
if (writeRequired)
{
Contract.Assert(memoryAddress.Between(44800, 95915), String.Format("This memory address is out of range for {0} using the {1} data type. As this is a write operation the memory area must be between: {2} and {3}", area, variableType, 44800, 95915));
}
else
{
Contract.Assert(memoryAddress.Between(0, 44715), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
}
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.TIM:
switch (variableType)
{
case VariableTypes.CompletionFlag:
case VariableTypes.CompletionFlagWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 4095), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
case MemoryAreas.CNT:
switch (variableType)
{
case VariableTypes.CompletionFlag:
case VariableTypes.CompletionFlagWithForcedStatus:
Contract.Assert(memoryAddress.Between(0, 4095), String.Format("This memory address is out of range for {0} using the {1} data type", area, variableType));
return true;
default:
throw new InvalidOperationException("The variable type is not valid for this memory address");
}
default:
throw new InvalidOperationException(String.Format("Invalid memory area detected {0}", area));
}
}
else
{
throw new NotImplementedException();
}
}
private static byte ParseMemoryAreaCode(VariableTypes variableType, PlcMemoryModes mode, MemoryAreas memoryArea)
{
{
if (mode == PlcMemoryModes.CSCJMode)
{
switch (variableType)
{
case VariableTypes.Bit:
switch (memoryArea)
{
case MemoryAreas.CIO:
return Convert.ToByte("30", 16);
case MemoryAreas.WR:
return Convert.ToByte("31", 16);
case MemoryAreas.HR:
return Convert.ToByte("32", 16);
case MemoryAreas.AR:
return Convert.ToByte("33", 16);
case MemoryAreas.DM:
return Convert.ToByte("02", 16);
case MemoryAreas.TK:
return Convert.ToByte("06", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.BitWithForcedStatus:
switch (memoryArea)
{
case MemoryAreas.CIO:
return Convert.ToByte("70", 16);
case MemoryAreas.WR:
return Convert.ToByte("71", 16);
case MemoryAreas.HR:
return Convert.ToByte("72", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.Word:
switch (memoryArea)
{
case MemoryAreas.CIO:
return Convert.ToByte("B0", 16);
case MemoryAreas.WR:
return Convert.ToByte("B1", 16);
case MemoryAreas.HR:
return Convert.ToByte("B2", 16);
case MemoryAreas.AR:
return Convert.ToByte("B3", 16);
case MemoryAreas.DM:
return Convert.ToByte("82", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.WordWithForcedStatus:
switch (memoryArea)
{
case MemoryAreas.CIO:
return Convert.ToByte("F0", 16);
case MemoryAreas.WR:
return Convert.ToByte("F1", 16);
case MemoryAreas.HR:
return Convert.ToByte("F2", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.CompletionFlag:
switch (memoryArea)
{
case MemoryAreas.TIM:
case MemoryAreas.CNT:
return Convert.ToByte("09", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.Status:
switch (memoryArea)
{
case MemoryAreas.TK:
return Convert.ToByte("46", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
case VariableTypes.PV:
switch (memoryArea)
{
case MemoryAreas.IR:
return Convert.ToByte("DC", 16);
case MemoryAreas.DR:
return Convert.ToByte("DC", 16);
case MemoryAreas.TIM:
case MemoryAreas.CNT:
return Convert.ToByte("89", 16);
default:
throw new InvalidOperationException(String.Format("The memory area {0} is not valid when using {1} mode when using the memory area as {2} ", memoryArea, mode, variableType));
}
default:
throw new InvalidOperationException(String.Format("An invalid variable type {0} was used. ", variableType));
}
}
else
{
//CV Mode
throw new NotImplementedException();
}
}
}