/// <summary>
/// Initializes a default intance of the TypeAliasCollection with aliases for primitive types
/// </summary>
public TypeAliasCollection()
{
this.bindings = new TwoWayDictionary <Type, string>();
this.assemblyList = new List <Assembly>();
AddDefaultAliases();
AddDefaultAssemblies();
}
/// <summary>
/// Initializes a default intance of the TypeAliasCollection with aliases for primitive types
/// </summary>
public TypeAliasCollection()
{
this.bindings = new TwoWayDictionary<Type, string>();
this.assemblyList = new List<Assembly>();
AddDefaultAliases();
AddDefaultAssemblies();
}
public RiscV(string cpuType, long frequency, Machine machine, PrivilegeMode privilegeMode = PrivilegeMode.Priv1_10, Endianess endianness = Endianess.LittleEndian) : base(cpuType, machine, endianness)
{
InnerTimer = new ComparingTimer(machine.ClockSource, frequency, enabled: true, eventEnabled: true);
intTypeToVal = new TwoWayDictionary <int, IrqType>();
intTypeToVal.Add(0, IrqType.MachineTimerIrq);
intTypeToVal.Add(1, IrqType.MachineExternalIrq);
intTypeToVal.Add(2, IrqType.MachineSoftwareInterrupt);
var architectureSets = DecodeArchitecture(cpuType);
foreach (var @set in architectureSets)
{
if (Enum.IsDefined(typeof(InstructionSet), set))
{
TlibAllowFeature((uint)set);
}
else if ((int)set == 'G' - 'A')
{
//G is a wildcard denoting multiple instruction sets
foreach (var gSet in new [] { InstructionSet.I, InstructionSet.M, InstructionSet.F, InstructionSet.D, InstructionSet.A })
{
TlibAllowFeature((uint)gSet);
}
}
else
{
this.Log(LogLevel.Warning, $"Undefined instruction set: {char.ToUpper((char)(set + 'A'))}.");
}
}
TlibSetPrivilegeMode109(privilegeMode == PrivilegeMode.Priv1_09 ? 1 : 0u);
}
protected Layout <TRoom> TransformLayout(IMapLayout <TRoom> layout, TwoWayDictionary <IRoomDescription, GameObject> roomDescriptionsToRoomTemplates)
{
var roomTransformations = new RoomTransformations();
// Prepare an object to hold instantiated room templates
var parentGameObject = new GameObject("Room template instances");
parentGameObject.transform.parent = Payload.GameObject.transform;
// Initialize rooms
var layoutData = new Dictionary <TRoom, RoomInfo <TRoom> >();
foreach (var layoutRoom in layout.Rooms)
{
var roomTemplate = roomDescriptionsToRoomTemplates[layoutRoom.RoomDescription];
// Instatiate room template
var room = Object.Instantiate(roomTemplate);
room.SetActive(false);
room.transform.SetParent(parentGameObject.transform);
// Transform room template if needed
var transformation = layoutRoom.Transformation;
roomTransformations.Transform(room, transformation);
// Compute correct room position
// We cannot directly use layoutRoom.Position because the dungeon moves
// all room shapes in a way that they are in the first plane quadrant
// and touch the xy axes. So we have to subtract the original lowest
// x and y coordinates.
var smallestX = layoutRoom.RoomDescription.Shape.GetPoints().Min(x => x.X);
var smallestY = layoutRoom.RoomDescription.Shape.GetPoints().Min(x => x.Y);
var correctPosition = layoutRoom.Position.ToUnityIntVector3() - new Vector3Int(smallestX, smallestY, 0);
room.transform.position = correctPosition;
var roomInfo = new RoomInfo <TRoom>(roomTemplate, room, correctPosition, TransformDoorInfo(layoutRoom.Doors),
layoutRoom.IsCorridor, layoutRoom);
room.transform.position = new Vector3(room.transform.position.x * 32, room.transform.position.y * 16, 0);
//room.gameObject.SetActive(true);
foreach (Transform child in room.transform)
{
if (child.gameObject.tag == "object")
{
var pos = child.transform.localPosition;
child.transform.SetParent(room.transform.parent);
child.transform.localScale = new Vector3(1, 1, 0);
child.transform.position = new Vector3(room.transform.position.x + pos.x, room.transform.position.y + pos.y, 0);
}
}
room.transform.localScale = new Vector3(1, 1, 0);
layoutData.Add(layoutRoom.Node, roomInfo);
}
return(new Layout <TRoom>(layoutData));
}
static PropertySerializationTypeConverter()
{
_serializationTypesStringMap = new TwoWayDictionary <PropertySerializationType, string> ();
_serializationTypesStringMap.Add(PropertySerializationType.CamelCase, "camelCase");
_serializationTypesStringMap.Add(PropertySerializationType.LowerSnakeCase, "lower_snake_case");
_serializationTypesStringMap.Add(PropertySerializationType.PascalCase, "PascalCase");
_serializationTypesStringMap.Add(PropertySerializationType.UnderscoreCamelCase, "_underscoreCamelCase");
}
public void ReversingTwoWayDictionaryTwiceResultsInFirstDictionary()
{
var original = new TwoWayDictionary <string, int>();
var doubleReversed = original.Reversed.Reversed;
doubleReversed.ShouldBeSameAs(original);
}
public override void Process()
{
RoomDescriptionsToRoomTemplates = new TwoWayDictionary <IRoomDescription, GameObject>();
RoomShapesLoader = new RoomShapesLoader();
Payload.MapDescription = SetupMapDescription();
Payload.RoomDescriptionsToRoomTemplates = RoomDescriptionsToRoomTemplates;
}
public void Indexer_EntryExists_ReturnsExpectedEntry()
{
var dictionary = new TwoWayDictionary <string, int>
{
["id"] = 5,
};
Assert.AreEqual(dictionary["id"], 5);
}
public void AddingASingleItemResultsInACountOfOne()
{
var left = Guid.NewGuid().ToString();
var right = Guid.NewGuid().GetHashCode();
var original = new TwoWayDictionary <string, int> {
{ left, right }
};
original.Count.ShouldBe(1);
}
public BasicLayoutConverterGrid2D(
LevelDescriptionGrid2D <TNode> mapDescription,
ConfigurationSpacesGrid2D <TConfiguration, RoomNode <TNode> > configurationSpaces,
TwoWayDictionary <RoomTemplateInstanceGrid2D, IntAlias <PolygonGrid2D> > intAliasMapping
)
{
MapDescription = mapDescription;
ConfigurationSpaces = configurationSpaces;
IntAliasMapping = intAliasMapping;
}
public BasicLayoutConverter(
MapDescriptionMapping <TNode> mapDescription,
IConfigurationSpaces <int, IntAlias <PolygonGrid2D>, TConfiguration, ConfigurationSpace> configurationSpaces,
TwoWayDictionary <RoomTemplateInstance, IntAlias <PolygonGrid2D> > intAliasMapping
)
{
MapDescription = mapDescription;
ConfigurationSpaces = configurationSpaces;
IntAliasMapping = intAliasMapping;
}
public void ValueFromOriginalShouldBeUsableAsKeyInReversed()
{
var left = Guid.NewGuid().ToString();
var right = Guid.NewGuid().GetHashCode();
var original = new TwoWayDictionary <string, int> {
{ left, right }
};
original[left].ShouldBe(right);
original.Reversed[right].ShouldBe(left);
}
public static TwoWayDictionary <TElement, int> CreateIntMapping <TElement>(this IEnumerable <TElement> elements)
{
var mapping = new TwoWayDictionary <TElement, int>();
foreach (var element in elements)
{
mapping.Add(element, mapping.Count);
}
return(mapping);
}
public RevolutionWorld(int entityInitialCapacity = 0)
{
lastEntity = default;
Chunks = new RevolutionChunk[1];
// the first chunk has no component
Chunks[0] = new RevolutionChunk(new Type[0]);
entityToChunk = new Dictionary <RawEntity, RevolutionChunk>(entityInitialCapacity);
identifierToEntity = new TwoWayDictionary <EntityIdentifier, RawEntity>(entityInitialCapacity);
}
public static TwoWayDictionary <TKey, TValue> ToTwoWayDictionary <TKey, TValue>(this IDictionary <TKey, TValue> dictionary)
{
var twoWayDictionary = new TwoWayDictionary <TKey, TValue>();
foreach (var pair in dictionary)
{
twoWayDictionary.Add(pair.Key, pair.Value);
}
return(twoWayDictionary);
}
public int Count_ReturnsExpectedValue(int entriesToAdd)
{
var dictionary = new TwoWayDictionary <string, int>();
for (var i = 0; i < entriesToAdd; i++)
{
dictionary.Add(i.ToString(), i);
}
return(dictionary.Count);
}
/// <summary>
/// Returns the mapping from original vertices to ints.
/// </summary>
/// <returns></returns>
public virtual TwoWayDictionary <TNode, int> GetRoomsMapping()
{
IsLocked = true;
var mapping = new TwoWayDictionary <TNode, int>();
foreach (var pair in Rooms)
{
mapping.Add(pair.Key, pair.Value);
}
return(mapping);
}
public void EnsureBothDirections()
{
var dictionary = new TwoWayDictionary <int, int>();
dictionary.Add(1, 2);
Assert.True(dictionary.ContainsKey(1));
Assert.True(dictionary.ContainsValue(2));
Assert.False(dictionary.ContainsKey(2));
Assert.False(dictionary.ContainsValue(1));
Assert.Equal(2, dictionary[1]);
Assert.Equal(1, dictionary.Reverse[2]);
}
public RoomShapesHandlerGrid2D(
TwoWayDictionary <RoomTemplateInstanceGrid2D, IntAlias <PolygonGrid2D> > intAliasMapping,
ILevelDescription <TNode> mapDescription, Dictionary <TNode, List <WeightedShape> > shapesForNodes, RoomTemplateRepeatMode?repeatModeOverride = null, RoomTemplateRepeatMode?repeatModeDefault = null)
{
this.intAliasMapping = intAliasMapping;
this.mapDescription = mapDescription;
this.shapesForNodes = shapesForNodes;
this.repeatModeDefault = repeatModeDefault;
this.repeatModeOverride = repeatModeOverride;
graphWithoutCorridors = mapDescription.GetGraphWithoutCorridors();
Initialize();
}
static PriorRollsLineHelper()
{
_fieldMappings = new TwoWayDictionary<PriorRollsLineField, string>();
foreach (var prop in typeof(PriorRollsLine).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty))
{
var att = AttributeHelper.GetSingleAttribute<PriorRollsFieldAttribute>(prop);
if (att == null) continue;
Mappings.Add(att.Field, prop.Name);
}
}
private Dictionary <int, List <int> > GetInitialClusters(TwoWayDictionary <TLayout, int> layouts)
{
var clusters = new Dictionary <int, List <int> >();
foreach (var pair in layouts)
{
clusters.Add(clusters.Count, new List <int>()
{
pair.Value
});
}
return(clusters);
}
public RoomShapesHandler(
IConfigurationSpaces <TNode, IntAlias <PolygonGrid2D>, TConfiguration, ConfigurationSpace> configurationSpaces,
TwoWayDictionary <RoomTemplateInstance, IntAlias <PolygonGrid2D> > intAliasMapping,
IMapDescription <TNode> mapDescription,
RoomTemplateRepeatMode?repeatModeOverride = null)
{
this.configurationSpaces = configurationSpaces;
this.intAliasMapping = intAliasMapping;
this.mapDescription = mapDescription;
this.repeatModeOverride = repeatModeOverride;
stageOneGraph = mapDescription.GetStageOneGraph();
Initialize();
}
private bool RegisterType(TwoWayDictionary <Type, MessageDescriptor> registeredTypes, Type type)
{
lock (_lock)
{
if (!registeredTypes.ContainsKey(type) && TryGetDescriptorFromAttribute(type, out var descriptor))
{
registeredTypes.Add(type, descriptor);
return(true);
}
return(false);
}
}
public void ClearingATwoWayDictionaryShouldAlsoClearItsReverse()
{
var original = new TwoWayDictionary <string, int> {
{ "one", 1 }
};
original.Count.ShouldBe(1);
original.Reversed.Count.ShouldBe(1);
original.Clear();
original.Count.ShouldBe(0);
original.Reversed.Count.ShouldBe(0);
}
protected override MapDescription <int> SetupMapDescription()
{
if (Config.LevelGraph == null)
{
throw new ArgumentException("LevelGraph must not be null.");
}
RoomToIntMapping = new TwoWayDictionary <Room, int>();
var mapDescription = new MapDescription <int>();
mapDescription.SetDefaultTransformations(new List <Transformation>()
{
Transformation.Identity
});
// Setup individual rooms
foreach (var room in Config.LevelGraph.Rooms)
{
RoomToIntMapping.Add(room, RoomToIntMapping.Count);
mapDescription.AddRoom(RoomToIntMapping[room]);
SetupRoomShapesForRoom(mapDescription, room);
}
// Add default room shapes
SetupDefaultRoomShapes(mapDescription, Config.LevelGraph);
// Add corridors
if (Config.UseCorridors)
{
SetupCorridorRoomShapes(mapDescription, Config.LevelGraph);
}
// Add passages
foreach (var connection in Config.LevelGraph.Connections)
{
var from = RoomToIntMapping[connection.From];
var to = RoomToIntMapping[connection.To];
mapDescription.AddPassage(from, to);
}
if (Payload is IRoomToIntMappingPayload <Room> payloadWithMapping)
{
payloadWithMapping.RoomToIntMapping = RoomToIntMapping;
}
return(mapDescription);
}
private void InitMembers()
{
presetButtonDict = new TwoWayDictionary <UAnchorPreset, Button>();
presetButtonDict.Add(UAnchorPreset.TopLeft, AnchorTopLeftButton);
presetButtonDict.Add(UAnchorPreset.TopMid, AnchorTopMidButton);
presetButtonDict.Add(UAnchorPreset.TopRight, AnchorTopRightButton);
presetButtonDict.Add(UAnchorPreset.MidLeft, AnchorMidLeftButton);
presetButtonDict.Add(UAnchorPreset.MidMid, AnchorMidMidButton);
presetButtonDict.Add(UAnchorPreset.MidRight, AnchorMidRightButton);
presetButtonDict.Add(UAnchorPreset.BotLeft, AnchorBotLeftButton);
presetButtonDict.Add(UAnchorPreset.BotMid, AnchorBotMidButton);
presetButtonDict.Add(UAnchorPreset.BotRight, AnchorBotRightButton);
presetButtonDict.Add(UAnchorPreset.StretchLeft, AnchorStretchLeftButton);
presetButtonDict.Add(UAnchorPreset.StretchMid, AnchorStretchMidButton);
presetButtonDict.Add(UAnchorPreset.StretchRight, AnchorStretchRightButton);
presetButtonDict.Add(UAnchorPreset.TopStretch, AnchorTopStretchButton);
presetButtonDict.Add(UAnchorPreset.MidStretch, AnchorMidStretchButton);
presetButtonDict.Add(UAnchorPreset.BotStretch, AnchorBotStretchButton);
presetButtonDict.Add(UAnchorPreset.StretchAll, AnchorStretchAllButton);
anchorButtons = new Button[] {
AnchorTopLeftButton,
AnchorTopMidButton,
AnchorTopRightButton,
AnchorMidLeftButton,
AnchorMidMidButton,
AnchorMidRightButton,
AnchorBotLeftButton,
AnchorBotMidButton,
AnchorBotRightButton,
AnchorStretchLeftButton,
AnchorStretchMidButton,
AnchorStretchRightButton,
AnchorTopStretchButton,
AnchorMidStretchButton,
AnchorBotStretchButton,
AnchorStretchAllButton,
};
}
public PSE_USB(Machine machine, ControllerMode mode = ControllerMode.Host) : base(machine)
{
this.mode = mode;
addressToDeviceCache = new TwoWayDictionary <byte, IUSBDevice>();
fifoFromDeviceToHost = new Queue <byte> [NumberOfEndpoints];
fifoFromHostToDevice = new Queue <byte> [NumberOfEndpoints];
receiveDeviceAddress = new IValueRegisterField[NumberOfEndpoints];
transmitDeviceAddress = new IValueRegisterField[NumberOfEndpoints];
requestInTransaction = new IFlagRegisterField[NumberOfEndpoints];
transmitTargetEndpointNumber = new IValueRegisterField[NumberOfEndpoints];
receiveTargetEndpointNumber = new IValueRegisterField[NumberOfEndpoints];
for (var i = 0; i < NumberOfEndpoints; i++)
{
fifoFromDeviceToHost[i] = new Queue <byte>();
fifoFromHostToDevice[i] = new Queue <byte>();
}
MainIRQ = new GPIO();
DmaIRQ = new GPIO();
byteRegisters = new ByteRegisterCollection(this);
wordRegisters = new WordRegisterCollection(this);
doubleWordRegisters = new DoubleWordRegisterCollection(this);
var gate = new GPIOGate(MainIRQ);
usbInterruptsManager = new InterruptManager <UsbInterrupt>(this, gate.GetGPIO(), "main");
txInterruptsManager = new InterruptManager <TxInterrupt>(this, gate.GetGPIO(), "main");
rxInterruptsManager = new InterruptManager <RxInterrupt>(this, gate.GetGPIO(), "main");
DefineCommonRegisters();
DefineIndexedRegisters();
DefineFifoRegisters();
DefineControlAndStatusRegisters();
DefineNonIndexedEndpointControlAndStatusRegisters();
DefineMultipointControlAndStatusRegisters();
ResetInterrupts();
}
private double[][] GetLayoutDistanceMatrix(TwoWayDictionary <TLayout, int> layouts, GetDistanceDelegate <TLayout> getDistance)
{
var distanceMatrix = new double[layouts.Count][];
for (int i = 0; i < layouts.Count; i++)
{
distanceMatrix[i] = new double[layouts.Count];
}
for (int i = 0; i < layouts.Count - 1; i++)
{
for (int j = i + 1; j < layouts.Count; j++)
{
var distance = getDistance(layouts.GetByValue(i), layouts.GetByValue(j));
distanceMatrix[i][j] = distance;
distanceMatrix[j][i] = distance;
}
}
return(distanceMatrix);
}
protected override MapDescription <int> SetupMapDescription()
{
RoomToIntMapping = new TwoWayDictionary <Room, int>();
LevelGraph = new UndirectedAdjacencyListGraph <Room>();
MapDescription = new MapDescription <int>();
// Transformations of room shapes currently not available
MapDescription.SetDefaultTransformations(new List <Transformation>()
{
Transformation.Identity
});
// Get random length of the main path
var mainPathLength = Payload.Random.Next(Config.MinLength, Config.MaxLength);
// Add vertices on the main path
var mainPath = SetupMainPath(mainPathLength);
// Add shortcut
if (Config.AddShortcuts)
{
SetupShortcut(mainPath);
}
// Add redundant rooms
if (Config.AddRedundantRooms)
{
SetupRedundantRooms();
}
// Setup map description rooms and connections
SetupMapDescriptionFromLevelGraph();
// Setup room templates
SetupRoomTemplates();
Payload.RoomToIntMapping = RoomToIntMapping;
return(MapDescription);
}
/// <summary>
/// Initializes a default intance of the TypeAliasCollection with aliases for primitive types
/// </summary>
public TypeAliasCollection()
{
this.bindings = new TwoWayDictionary<Type, string>();
AddDefaultAliases();
}
/// <inheritdoc />
/// <remarks>
/// Adds number to a given prefix until all corridors have a name.
/// </remarks>
public void AddCorridorsToMapping(ICorridorMapDescription <int> mapDescription, TwoWayDictionary <string, int> mapping)
{
var graph = mapDescription.GetGraph();
var corridors = graph.Vertices.Where(mapDescription.IsCorridorRoom).ToList();
var counter = 0;
foreach (var corridor in corridors)
{
while (true)
{
var name = prefix + counter;
if (!mapping.ContainsKey(name))
{
mapping.Add(name, corridor);
break;
}
counter++;
}
}
}
public MiV_CoreGPIO(Machine machine) : base(machine, NumberOfInterrupts)
{
innerLock = new object();
IRQ = new GPIO();
irqManager = new GPIOInterruptManager(IRQ, State);
var registersMap = new Dictionary <long, DoubleWordRegister>
{
{ (long)Registers.OutputRegister, new DoubleWordRegister(this).WithValueField(0, 32, FieldMode.Write, writeCallback: (_, value) =>
{
lock (innerLock)
{
var bits = BitHelper.GetBits(value);
for (var i = 0; i < bits.Length; i++)
{
Connections[i].Set(bits[i]);
}
}
}) },
{ (long)Registers.InputRegister, new DoubleWordRegister(this).WithValueField(0, 32, FieldMode.Read, valueProviderCallback: _ =>
{
lock (innerLock)
{
return(BitHelper.GetValueFromBitsArray(State));
}
}) },
{ (long)Registers.InterruptClearRegister, new DoubleWordRegister(this).WithValueField(0, 32, writeCallback: (_, value) =>
{
lock (innerLock)
{
foreach (var i in BitHelper.GetSetBits(value))
{
irqManager.ClearInterrupt((uint)i);
}
}
}, valueProviderCallback: _ => {
lock (innerLock)
{
return(BitHelper.GetValueFromBitsArray(irqManager.ActiveInterrupts));
}
}) }
};
var intTypeToVal = new TwoWayDictionary <GPIOInterruptManager.InterruptTrigger, uint>();
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.ActiveHigh, 0);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.ActiveLow, 1);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.RisingEdge, 2);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.FallingEdge, 3);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.BothEdges, 4);
for (var i = 0; i < NumberOfInterrupts; i++)
{
var j = i;
registersMap.Add((long)Registers.ConfigurationRegisterBase + i * 0x4, new DoubleWordRegister(this)
.WithFlag(0, writeCallback: (_, v) =>
{
if (v)
{
irqManager.PinDirection[j] |= GPIOInterruptManager.Direction.Output;
}
else
{
irqManager.PinDirection[j] &= ~GPIOInterruptManager.Direction.Output;
}
},
valueProviderCallback: _ => (irqManager.PinDirection[j] & GPIOInterruptManager.Direction.Output) != 0, name: "OUTREG")
.WithFlag(1, writeCallback: (_, value) =>
{
if (value)
{
irqManager.PinDirection[j] |= GPIOInterruptManager.Direction.Input;
}
else
{
irqManager.PinDirection[j] &= ~GPIOInterruptManager.Direction.Input;
}
},
valueProviderCallback: _ => (irqManager.PinDirection[j] & GPIOInterruptManager.Direction.Input) != 0, name: "INREG")
.WithTag("OUTBUFF", 2, 1)
.WithFlag(3, writeCallback: (_, v) => { irqManager.InterruptEnable[j] = v; }, valueProviderCallback: _ => irqManager.InterruptEnable[j], name: "INTENABLE")
//bit 4 unused
.WithValueField(5, 3, writeCallback: (_, value) =>
{
if (!intTypeToVal.TryGetValue(value, out var type))
{
this.Log(LogLevel.Warning, "Invalid interrupt type for pin #{0}: {1}", j, value);
return;
}
irqManager.InterruptType[j] = type;
}, valueProviderCallback: _ =>
{
if (!intTypeToVal.TryGetValue(irqManager.InterruptType[j], out var value))
{
throw new ArgumentOutOfRangeException($"Unknown interrupt trigger type: {irqManager.InterruptType[j]}");
}
return(value);
}, name: "INTTYPE"));
}
registers = new DoubleWordRegisterCollection(this, registersMap);
}
public PSE_GPIO(Machine machine) : base(machine, 32)
{
locker = new object();
IRQ = new GPIO();
irqManager = new GPIOInterruptManager(IRQ, State);
var registersMap = new Dictionary <long, DoubleWordRegister>
{
{ (long)Registers.InterruptRegister, new DoubleWordRegister(this)
.WithValueField(0, 32,
writeCallback: (_, val) =>
{
foreach (var i in BitHelper.GetSetBits(val))
{
irqManager.ClearInterrupt(i);
if ((irqManager.PinDirection[i] & GPIOInterruptManager.Direction.Input) != 0)
{
Connections[i].Set(false);
}
}
},
valueProviderCallback: _ => BitHelper.GetValueFromBitsArray(irqManager.ActiveInterrupts), name: "INTR") },
{ (long)Registers.InputRegister, new DoubleWordRegister(this)
.WithValueField(0, 32, out inputReg, FieldMode.Read,
valueProviderCallback: val =>
{
var pins = irqManager.PinDirection.Select(x => (x & GPIOInterruptManager.Direction.Input) != 0);
var result = pins.Zip(State, (pin, state) => pin && state);
return(BitHelper.GetValueFromBitsArray(result));
}, name: "GPIN") },
{ (long)Registers.OutputRegister, new DoubleWordRegister(this)
.WithValueField(0, 32,
valueProviderCallback: val =>
{
var pins = irqManager.PinDirection.Select(x => (x & GPIOInterruptManager.Direction.Output) != 0);
var result = pins.Zip(Connections.Values, (pin, state) => pin && state.IsSet);
return(BitHelper.GetValueFromBitsArray(result));
},
writeCallback: (_, val) =>
{
// Potentially we should raise an exception, as GPIO is bidirectional,
// but we do not have such infrastructure.
var bits = BitHelper.GetBits(val);
for (var i = 0; i < bits.Length; i++)
{
if ((irqManager.PinDirection[i] & GPIOInterruptManager.Direction.Output) != 0)
{
Connections[i].Set(bits[i]);
}
}
}, name: "GPOUT") },
{ (long)Registers.ClearRegister, new DoubleWordRegister(this)
.WithValueField(0, 32, writeCallback: (_, val) => SetRegisterBits(val, false), name: "CLEAR_BITS") },
{ (long)Registers.SetRegister, new DoubleWordRegister(this)
.WithValueField(0, 32, writeCallback: (_, val) => SetRegisterBits(val, true), name: "SET_BITS") },
};
var intTypeToVal = new TwoWayDictionary <GPIOInterruptManager.InterruptTrigger, uint>();
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.ActiveHigh, 0);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.ActiveLow, 1);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.RisingEdge, 2);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.FallingEdge, 3);
intTypeToVal.Add(GPIOInterruptManager.InterruptTrigger.BothEdges, 4);
for (var i = 0; i < RegisterLength; i++)
{
var j = i;
registersMap.Add(i * RegisterOffset, new DoubleWordRegister(this)
.WithFlag(0,
writeCallback: (_, val) =>
{
if (val)
{
irqManager.PinDirection[j] |= GPIOInterruptManager.Direction.Output;
}
else
{
irqManager.PinDirection[j] &= ~GPIOInterruptManager.Direction.Output;
}
},
valueProviderCallback: _ => (irqManager.PinDirection[j] & GPIOInterruptManager.Direction.Output) != 0, name: "OutputRegEnable")
.WithFlag(1,
writeCallback: (_, value) =>
{
if (value)
{
irqManager.PinDirection[j] |= GPIOInterruptManager.Direction.Input;
}
else
{
irqManager.PinDirection[j] &= ~GPIOInterruptManager.Direction.Input;
}
},
valueProviderCallback: _ => (irqManager.PinDirection[j] & GPIOInterruptManager.Direction.Input) != 0, name: "InputRegEnable")
.WithTag("OutputBufferEnable", 2, 1)
.WithFlag(3, writeCallback: (_, v) => { irqManager.InterruptEnable[j] = v; }, valueProviderCallback: _ => irqManager.InterruptEnable[j], name: "InterruptEnable")
.WithReservedBits(4, 1)
.WithValueField(5, 3,
writeCallback: (_, value) =>
{
if (!intTypeToVal.TryGetValue(value, out var type))
{
this.Log(LogLevel.Warning, "Invalid interrupt type for pin #{0}: {1}", j, value);
return;
}
irqManager.InterruptType[j] = type;
},
valueProviderCallback: _ => intTypeToVal[irqManager.InterruptType[j]], name: "InterruptType"));
}
registers = new DoubleWordRegisterCollection(this, registersMap);
}
public void TestInitialize()
{
Dict = new TwoWayDictionary<string, string>();
}
