public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
Sequential mainHandler = () =>
{
byte data = 0;
byte[] buff = new byte[] { 1, 2, 3, 4, 5 };
UART.Read(115200, RXD, out data);
for (int i = 0; i < buff.Length; i++)
{
byte existing = 0;
existing = buff[i];
UART.RegisteredWrite(115200, existing, out internalTXD);
}
};
FPGA.Config.OnStartup(mainHandler);
}
public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD)
{
var stream = new FPGA.SyncStream <byte>();
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
object txdLock = new object();
Sequential <byte> streamHandler = (value) =>
{
lock (txdLock)
{
UART.RegisteredWrite(115200, value, out internalTXD);
}
};
FPGA.Config.OnStream(stream, streamHandler, 2);
Sequential handler = () =>
{
byte data = 0;
UART.Read(115200, RXD, out data);
for (ushort i = 0; i < data; i++)
{
stream.Write((byte)i);
}
};
const bool trigger = true;
FPGA.Config.OnSignal(trigger, handler);
}
public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
Sequential handler = () =>
{
byte prev = 100, next = 0;
while (true)
{
next = UART.Read(115200, RXD);
UART.RegisteredWrite(115200, prev, out internalTXD);
UART.RegisteredWrite(115200, next, out internalTXD);
prev = next;
}
};
FPGA.Config.OnStartup(handler);
}
public static async Task Aggregator(
// blinker
FPGA.OutputSignal <bool> LED1,
// UART
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
IsAlive.Blink(LED1);
Sequential handler = () =>
{
for (byte b = 0; b < 10; b++)
{
UART.RegisteredWrite(115200, b, out internalTXD);
}
UART.RegisteredWrite(115200, 255, out internalTXD);
};
FPGA.Config.OnTimer(TimeSpan.FromSeconds(1), handler);
}
public static void WriteData(
FPGA.Register <ulong> a00, FPGA.Register <ulong> a01, FPGA.Register <ulong> a02, FPGA.Register <ulong> a03, FPGA.Register <ulong> a04,
FPGA.Register <ulong> a05, FPGA.Register <ulong> a06, FPGA.Register <ulong> a07, FPGA.Register <ulong> a08, FPGA.Register <ulong> a09,
FPGA.Register <ulong> a10, FPGA.Register <ulong> a11, FPGA.Register <ulong> a12, FPGA.Register <ulong> a13, FPGA.Register <ulong> a14,
FPGA.Register <ulong> a15, FPGA.Register <ulong> a16, FPGA.Register <ulong> a17, FPGA.Register <ulong> a18, FPGA.Register <ulong> a19,
FPGA.Register <ulong> a20, FPGA.Register <ulong> a21, FPGA.Register <ulong> a22, FPGA.Register <ulong> a23, FPGA.Register <ulong> a24,
out bool TXD)
{
TXD = true;
FPGA.Collections.ReadOnlyDictionary <byte, ulong> mapItems = new FPGA.Collections.ReadOnlyDictionary <byte, ulong>()
{
{ 0, a00 }, { 1, a01 }, { 2, a02 }, { 3, a03 }, { 4, a04 },
{ 5, a05 }, { 6, a06 }, { 7, a07 }, { 8, a08 }, { 9, a09 },
{ 10, a10 }, { 11, a11 }, { 12, a12 }, { 13, a13 }, { 14, a14 },
{ 15, a15 }, { 16, a16 }, { 17, a17 }, { 18, a18 }, { 19, a19 },
{ 20, a20 }, { 21, a21 }, { 22, a22 }, { 23, a23 }, { 24, a24 },
};
for (byte pos = 0; pos < 25; pos++)
{
ulong tmp = 0;
tmp = mapItems[pos];
for (byte j = 0; j < 8; j++)
{
UART.RegisteredWrite(115200, (byte)tmp, out TXD);
tmp = tmp >> 8;
}
}
}
public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
object txdLock = new object();
byte counter = 0;
object counterLock = new object();
var transmitterStream = new FPGA.SyncStream <byte>();
Sequential <byte> transmitterStreamHandler = (value) =>
{
lock (txdLock)
{
UART.RegisteredWrite(115200, value, out internalTXD);
}
};
FPGA.Config.OnStream(transmitterStream, transmitterStreamHandler, 2);
var receiverStream = new FPGA.SyncStream <byte>();
Sequential <byte> receiverStreamHandler = (value) =>
{
Func <uint> instanceId = () => FPGA.Config.InstanceId();
byte increment = 0;
lock (counterLock)
{
increment = counter;
counter++;
}
transmitterStream.Write((byte)(value + increment + instanceId()));
};
FPGA.Config.OnStream(receiverStream, receiverStreamHandler, 3);
Sequential handler = () =>
{
byte data = 0;
UART.Read(115200, RXD, out data);
for (ushort i = 0; i < data; i++)
{
receiverStream.Write((byte)i);
}
};
const bool trigger = true;
FPGA.Config.OnSignal(trigger, handler);
}
public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
Sequential mainHandler = () =>
{
byte data = 0;
byte[] buff = new byte[] { 0, 1, 2, 3, 4 };
for (int i = 0; i < buff.Length; i++)
{
UART.Read(115200, RXD, out data);
UART.RegisteredWrite(115200, data, out internalTXD);
byte existing = 0;
existing = buff[i];
UART.RegisteredWrite(115200, existing, out internalTXD);
buff[i] = (byte)(data + existing);
}
for (int i = 0; i < buff.Length; i++)
{
data = buff[i];
UART.RegisteredWrite(115200, data, out internalTXD);
}
byte sum = 0;
for (int i = 0; i < buff.Length; i++)
{
data = buff[i];
sum += data;
}
UART.RegisteredWrite(115200, sum, out internalTXD);
};
const bool trigger = true;
FPGA.Config.OnSignal(trigger, mainHandler);
}
public static async Task Aggregator(
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
Sequential mainHandler = () =>
{
byte data = 0;
byte[] buff = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
UART.Read(115200, RXD, out data);
for (byte i = 0; i < buff.Length; i++)
{
byte tmp = 0;
tmp = buff[i];
tmp += data;
buff[i] = tmp;
UART.RegisteredWrite(115200, tmp, out internalTXD);
}
for (byte jjj = 0; jjj < buff.Length; jjj++)
{
buff[jjj] = jjj;
}
;
};
const bool trigger = true;
FPGA.Config.OnSignal(trigger, mainHandler);
}
public static void DeviceControl(
FPGA.OutputSignal <bool> DOUT,
FPGA.InputSignal <bool> RXD,
FPGA.OutputSignal <bool> TXD
)
{
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
object commsLock = new object();
bool internalDOUT = false;
FPGA.Config.Link(internalDOUT, DOUT);
const uint baud = 115200;
FPGA.SyncStream <uint> heartBeat = new FPGA.SyncStream <uint>();
const int servosCount = 5;
byte[] servosBuff = new byte[servosCount];
Sequential servosHandler = () =>
{
FPGA.OutputSignal <bool> ServoItem = new FPGA.OutputSignal <bool>();
bool servoOut = false;
FPGA.Config.Link(servoOut, ServoItem);
while (true)
{
uint idx = FPGA.Config.InstanceId();
byte servoData = 0;
servoData = servosBuff[idx];
MG996R.Write(servoData, out servoOut);
}
};
FPGA.Config.OnStartup(servosHandler, servosCount);
// SERVOs driver
Sequential <uint> servosDataHandler = (iteration) =>
{
byte data = 0;
lock (commsLock)
{
UART.RegisteredWrite(baud, 2, out internalTXD);
for (int i = 0; i < servosCount; i++)
{
data = UART.Read(baud, RXD);
servosBuff[i] = data;
}
}
};
FPGA.Config.OnStream(heartBeat, servosDataHandler);
// LED driver
Sequential <uint> ledHandler = (iteration) =>
{
uint data = 0;
uint[] buff = new uint[64];
lock (commsLock)
{
UART.RegisteredWrite(baud, 1, out internalTXD);
for (int i = 0; i < buff.Length; i++)
{
UART.ReadUnsigned32(baud, RXD, ref data);
buff[i] = data;
}
}
WS2812B.SyncWrite(buff, 0, buff.Length, out internalDOUT);
};
FPGA.Config.OnStream(heartBeat, ledHandler);
// main application driver
uint beat = 0;
Sequential heartBeatHandler = () =>
{
heartBeat.Write(beat);
beat++;
};
FPGA.Config.OnTimer(TimeSpan.FromMilliseconds(100), heartBeatHandler);
}
public static async Task Aggregator(
FPGA.OutputSignal <bool> TXD,
FPGA.InputSignal <bool> RXD
)
{
const uint baud = 115200;
const uint tasksCount = 10;
ushort[] buff = new ushort[tasksCount];
FPGA.Signal <bool> tasksTrigger = false;
object buffLock = new object();
uint completedTasks = 0;
Func <bool> tasksCompleted = () => completedTasks == tasksCount;
bool internalTXD = true;
FPGA.Config.Link(internalTXD, TXD);
Sequential onStartup = () =>
{
while (true)
{
byte cmd = UART.Read(baud, RXD);
lock (buffLock)
{
completedTasks = 0;
tasksTrigger = true;
}
FPGA.Runtime.WaitForAllConditions(tasksCompleted);
for (uint idx = 0; idx < buff.Length; idx++)
{
ushort data = 0;
data = buff[idx];
UART.RegisteredWrite(baud, (byte)data, out internalTXD);
UART.RegisteredWrite(baud, (byte)(data >> 8), out internalTXD);
}
}
};
FPGA.Config.OnStartup(onStartup);
Sequential taskHandler = () =>
{
uint taskIndex = FPGA.Config.InstanceId();
FPGA.OutputSignal <bool> ADC1NCS = new FPGA.OutputSignal <bool>();
FPGA.OutputSignal <bool> ADC1SLCK = new FPGA.OutputSignal <bool>();
FPGA.OutputSignal <bool> ADC1DIN = new FPGA.OutputSignal <bool>();
FPGA.InputSignal <bool> ADC1DOUT = new FPGA.InputSignal <bool>();
ushort adcChannel1Value = 0, adcChannel2Value = 0;
ADC102S021.Read(out adcChannel1Value, out adcChannel2Value, ADC1NCS, ADC1SLCK, ADC1DIN, ADC1DOUT);
lock (buffLock)
{
// TODO: inline expression in memory accessor
uint offset1 = taskIndex * 2, offset2 = offset1 + 1;
buff[offset1] = adcChannel1Value;
buff[offset2] = adcChannel2Value;
completedTasks++;
}
};
FPGA.Config.OnSignal(tasksTrigger, taskHandler, tasksCount);
}
