private string EventKindToStringValue(PinEvent kind)
{
string result;
if (kind == PinEvent.None)
{
result = "none";
}
else if (kind.HasFlag(PinEvent.SyncBoth) ||
kind.HasFlag(PinEvent.AsyncBoth))
{
result = "both";
}
else if (kind.HasFlag(PinEvent.SyncRisingEdge) ||
kind.HasFlag(PinEvent.AsyncRisingEdge))
{
result = "rising";
}
else if (kind.HasFlag(PinEvent.SyncFallingEdge) ||
kind.HasFlag(PinEvent.AsyncFallingEdge))
{
result = "falling";
}
else
{
throw new NotSupportedException($"Not supported GPIO event kind '{kind}'");
}
return(result);
}
/// <summary>
/// schedule this event
/// </summary>
/// <param name="p"></param>
public void Schedule(PinEvent p)
{
lock (locker)
{
events.Add(p);
}
}
private void PinAndHit()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
pinEvent.Hit();
pinEvent.Done();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countFlushesAndBytesWritten()
internal virtual void CountFlushesAndBytesWritten()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent faultEvent = pinEvent.BeginPageFault();
{
EvictionEvent evictionEvent = faultEvent.BeginEviction();
{
FlushEventOpportunity flushEventOpportunity = evictionEvent.FlushEventOpportunity();
{
FlushEvent flushEvent = flushEventOpportunity.BeginFlush(0, 0, _swapper);
flushEvent.AddBytesWritten(27);
flushEvent.Done();
FlushEvent flushEvent1 = flushEventOpportunity.BeginFlush(0, 1, _swapper);
flushEvent1.AddBytesWritten(13);
flushEvent1.Done();
}
}
evictionEvent.Close();
}
faultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(1, _pageCursorTracer.faults());
assertEquals(1, _pageCursorTracer.evictions());
assertEquals(2, _pageCursorTracer.flushes());
assertEquals(40, _pageCursorTracer.bytesWritten());
}
private static void DetectButtonLed(GpioDriver driver)
{
using (var controller = new GpioController(driver, PinNumberingScheme.Bcm))
{
Pin button = controller.OpenPin(18, PinMode.Input);
if (button.IsModeSupported(PinMode.InputPullDown))
{
button.Mode = PinMode.InputPullDown;
}
Pin led = controller.OpenPin(26, PinMode.Output);
button.DebounceTimeout = TimeSpan.FromSeconds(1);
button.NotifyEvents = PinEvent.SyncFallingEdge;
button.ValueChanged += OnPinValueChanged2;
button.EnableRaisingEvents = true;
PinEvent events = button.NotifyEvents;
Console.WriteLine($"Events to detect: {events}");
Stopwatch watch = Stopwatch.StartNew();
while (watch.Elapsed.TotalSeconds < 15)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
}
protected internal override void SetPinEventsToDetect(int bcmPinNumber, PinEvent events)
{
ValidatePinNumber(bcmPinNumber);
PinEvent kind = PinEvent.Low;
bool enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
kind = PinEvent.High;
enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
kind = PinEvent.SyncRisingEdge;
enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
kind = PinEvent.SyncFallingEdge;
enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
kind = PinEvent.AsyncRisingEdge;
enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
kind = PinEvent.AsyncFallingEdge;
enabled = events.HasFlag(kind);
SetEventDetection(bcmPinNumber, kind, enabled);
ClearDetectedEvent(bcmPinNumber);
}
protected internal override void SetPinEventsToDetect(int gpioPinNumber, PinEvent events)
{
VerifyPinIsInValidRange(gpioPinNumber, nameof(gpioPinNumber));
lock (_openPinsLock)
VerifyPinIsOpen(gpioPinNumber, nameof(gpioPinNumber)).PinEventsToDetect = events;
}
/// <summary>
/// schedule this event
/// </summary>
/// <param name="p"></param>
public void Schedule(PinEvent p)
{
lock (locker)
{
events.Add(p);
}
}
public PinEvent[] GetEvents()
{
var c = new PinEvent[events.Count];
events.CopyTo(c, 0);
return(c);
}
private void PinFaultAndHit()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
pinEvent.Hit();
pageFaultEvent.Done();
pinEvent.Done();
}
protected internal override void SetPinEventsToDetect(int bcmPinNumber, PinEvent kind)
{
ValidatePinNumber(bcmPinNumber);
string edgePath = $"{GpioPath}/gpio{bcmPinNumber}/edge";
string stringValue = EventKindToStringValue(kind);
File.WriteAllText(edgePath, stringValue);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countPinsAndUnpins()
internal virtual void CountPinsAndUnpins()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
pinEvent.Done();
pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
assertEquals(2, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
}
protected internal override PinEvent GetPinEventsToDetect(int bcmPinNumber)
{
ValidatePinNumber(bcmPinNumber);
string edgePath = $"{GpioPath}/gpio{bcmPinNumber}/edge";
string stringValue = File.ReadAllText(edgePath);
PinEvent value = StringValueToEventKind(stringValue);
return(value);
}
/// <summary>
/// Pin the desired file page to this cursor, page faulting it into memory if it isn't there already. </summary>
/// <param name="filePageId"> The file page id we want to pin this cursor to. </param>
/// <param name="writeLock"> 'true' if we will be taking a write lock on the page as part of the pin. </param>
/// <exception cref="IOException"> if anything goes wrong with the pin, most likely during a page fault. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void pin(long filePageId, boolean writeLock) throws java.io.IOException
protected internal virtual void Pin(long filePageId, bool writeLock)
{
PinEvent = _tracer.beginPin(writeLock, filePageId, Swapper);
int chunkId = MuninnPagedFile.ComputeChunkId(filePageId);
// The chunkOffset is the addressing offset into the chunk array object for the relevant array slot. Using
// this, we can access the array slot with Unsafe.
long chunkOffset = MuninnPagedFile.ComputeChunkOffset(filePageId);
int[][] tt = PagedFile.translationTable;
if (tt.Length <= chunkId)
{
tt = ExpandTranslationTableCapacity(chunkId);
}
int[] chunk = tt[chunkId];
// Now, if the reference in the chunk slot is a latch, we wait on it and look up again (in a loop, since the
// page might get evicted right after the page fault completes). If we find a page, we lock it and check its
// binding (since it might get evicted and faulted into something else in the time between our look up and
// our locking of the page). If the reference is null or it referred to a page that had wrong bindings, we CAS
// in a latch. If that CAS succeeds, we page fault, set the slot to the faulted in page and open the latch.
// If the CAS failed, we retry the look up and start over from the top.
for ( ;;)
{
int mappedPageId = UnsafeUtil.getIntVolatile(chunk, chunkOffset);
if (mappedPageId != UNMAPPED_TTE)
{
// We got *a* page, but we might be racing with eviction. To cope with that, we have to take some
// kind of lock on the page, and check that it is indeed bound to what we expect. If not, then it has
// been evicted, and possibly even page faulted into something else. In this case, we discard the
// item and try again, as the eviction thread would have set the chunk array slot to null.
long pageRef = PagedFile.deref(mappedPageId);
bool locked = TryLockPage(pageRef);
if (locked & PagedFile.isBoundTo(pageRef, SwapperId, filePageId))
{
PinCursorToPage(pageRef, filePageId, Swapper);
PinEvent.hit();
return;
}
if (locked)
{
UnlockPage(pageRef);
}
}
else
{
if (UncommonPin(filePageId, chunkOffset, chunk))
{
return;
}
}
}
}
protected internal override PinEvent GetPinEventsToDetect(int bcmPinNumber)
{
ValidatePinNumber(bcmPinNumber);
PinEvent result = PinEvent.None;
PinEvent kind = PinEvent.Low;
bool enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
kind = PinEvent.High;
enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
kind = PinEvent.SyncRisingEdge;
enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
kind = PinEvent.SyncFallingEdge;
enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
kind = PinEvent.AsyncRisingEdge;
enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
kind = PinEvent.AsyncFallingEdge;
enabled = GetEventDetection(bcmPinNumber, kind);
if (enabled)
{
result |= kind;
}
return(result);
}
protected internal override void UnpinCurrentPage()
{
if (PinnedPageRef != 0)
{
PinEvent.done();
// Mark the page as dirty *after* our write access, to make sure it's dirty even if it was concurrently
// flushed. Unlocking the write-locked page will mark it as dirty for us.
if (EagerFlush)
{
EagerlyFlushAndUnlockPage();
}
else
{
PagedFile.unlockWrite(PinnedPageRef);
}
}
ClearPageCursorState();
}
void queueEvent(PinEvent e)
{
// schedule the off note
var dueOffAt = DateTime.Now.AddMilliseconds(e.TotalMsDelta);
lock (noteLock)
{
noteons[e.Message.PinNumber] = new NoteInfo()
{
Message = e.Message,
Off = dueOffAt,
};
}
// start thread if needed
if (playerThread == null)
{
playerThread = new Thread(new ThreadStart(playThreadLoop));
playerThread.Start();
}
}
void queueEvent(PinEvent e)
{
// schedule the off note
var dueOffAt = DateTime.Now.AddMilliseconds(e.TotalMsDelta);
lock (noteLock)
{
noteons[e.Message.PinNumber] = new NoteInfo()
{
Message = e.Message,
Off = dueOffAt,
};
}
// start thread if needed
if (playerThread == null)
{
playerThread = new Thread(new ThreadStart(playThreadLoop));
playerThread.Start();
}
}
private void GenerateEventSet()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(false, 0, _swapper);
{
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
pageFaultEvent.AddBytesRead(150);
{
EvictionEvent evictionEvent = pageFaultEvent.BeginEviction();
{
FlushEventOpportunity flushEventOpportunity = evictionEvent.FlushEventOpportunity();
FlushEvent flushEvent = flushEventOpportunity.BeginFlush(0, 0, _swapper);
flushEvent.AddBytesWritten(10);
flushEvent.Done();
}
evictionEvent.ThrewException(new IOException("eviction exception"));
evictionEvent.Close();
}
pageFaultEvent.Done();
}
pinEvent.Done();
}
void send(PinEvent e)
{
// send it right away if needed (optimisation)
if (e.TotalMsDelta == 0)
{
// yep... go send
// Debug.WriteLine("> " + e.Message.PinNumber + " --- " + e.Message.Value);
pinSender.Send(e.Message);
if (e.Message.Value == 0)
{
// this is off.. take it from the queue
lock (noteLock)
{
noteons.Remove(e.Message.PinNumber);
}
}
}
else
{
// no.. needs to be queued
queueEvent(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countPageFaultsAndBytesRead()
internal virtual void CountPageFaultsAndBytesRead()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
{
pageFaultEvent.AddBytesRead(42);
}
pageFaultEvent.Done();
pageFaultEvent = pinEvent.BeginPageFault();
{
pageFaultEvent.AddBytesRead(42);
}
pageFaultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(2, _pageCursorTracer.faults());
assertEquals(84, _pageCursorTracer.bytesRead());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countPageEvictions()
internal virtual void CountPageEvictions()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent faultEvent = pinEvent.BeginPageFault();
{
EvictionEvent evictionEvent = faultEvent.BeginEviction();
evictionEvent.FilePageId = 0;
evictionEvent.CachePageId = 0;
evictionEvent.ThrewException(new IOException("exception"));
evictionEvent.Close();
}
faultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(1, _pageCursorTracer.faults());
assertEquals(1, _pageCursorTracer.evictions());
assertEquals(1, _pageCursorTracer.evictionExceptions());
}
private static void Driver_DetectButtonLed(GpioDriver driver)
{
const int button = 18;
const int led = 26;
using (driver)
{
PinMode buttonMode = PinMode.Input;
if (driver.IsPinModeSupported(PinMode.InputPullDown))
{
buttonMode = PinMode.InputPullDown;
}
driver.OpenPin(button);
driver.SetPinMode(button, buttonMode);
driver.OpenPin(led);
driver.SetPinMode(led, PinMode.Output);
driver.SetDebounce(button, TimeSpan.FromSeconds(1));
driver.SetPinEventsToDetect(button, PinEvent.SyncFallingEdge);
driver.ValueChanged += OnPinValueChanged2;
driver.SetEnableRaisingPinEvents(button, true);
PinEvent events = driver.GetPinEventsToDetect(button);
Console.WriteLine($"Events to detect: {events}");
Stopwatch watch = Stopwatch.StartNew();
while (watch.Elapsed.TotalSeconds < 15)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
}
protected internal abstract void SetPinEventsToDetect(int gpioPinNumber, PinEvent events);
public PinEvent[] GetEvents()
{
var c = new PinEvent[events.Count];
events.CopyTo(c, 0);
return c;
}
void send(PinEvent e)
{
// send it right away if needed (optimisation)
if (e.TotalMsDelta == 0)
{
// yep... go send
// Debug.WriteLine("> " + e.Message.PinNumber + " --- " + e.Message.Value);
pinSender.Send(e.Message);
if (e.Message.Value == 0)
{
// this is off.. take it from the queue
lock (noteLock)
{
noteons.Remove(e.Message.PinNumber);
}
}
}
else
{
// no.. needs to be queued
queueEvent(e);
}
}
public void Dispose()
{
Pin?.Dispose();
Pin = null;
PinEventsToDetect = PinEvent.Any;
}
private bool GetEventDetection(int bcmPinNumber, PinEvent kind)
{
//switch (kind)
//{
// case GpioEventKind.High:
// value = GetBit(RegisterViewPointer->GPHEN, pin);
// break;
// case GpioEventKind.Low:
// value = GetBit(RegisterViewPointer->GPLEN, pin);
// break;
// case GpioEventKind.SyncRisingEdge:
// value = GetBit(RegisterViewPointer->GPREN, pin);
// break;
// case GpioEventKind.SyncFallingEdge:
// value = GetBit(RegisterViewPointer->GPFEN, pin);
// break;
// case GpioEventKind.AsyncRisingEdge:
// value = GetBit(RegisterViewPointer->GPAREN, pin);
// break;
// case GpioEventKind.AsyncFallingEdge:
// value = GetBit(RegisterViewPointer->GPAFEN, pin);
// break;
// default: throw new InvalidGpioEventKindException(kind);
//}
int index = bcmPinNumber / 32;
int shift = bcmPinNumber % 32;
string registerName = string.Empty;
uint register = 0U;
switch (kind)
{
case PinEvent.High:
register = _registerViewPointer->GPHEN[index];
break;
case PinEvent.Low:
register = _registerViewPointer->GPLEN[index];
break;
case PinEvent.SyncRisingEdge:
register = _registerViewPointer->GPREN[index];
break;
case PinEvent.SyncFallingEdge:
register = _registerViewPointer->GPFEN[index];
break;
case PinEvent.AsyncRisingEdge:
register = _registerViewPointer->GPAREN[index];
break;
case PinEvent.AsyncFallingEdge:
register = _registerViewPointer->GPAFEN[index];
break;
default:
throw new ArgumentException($"Invalid GPIO event kind '{kind}'");
}
uint value = (register >> shift) & 1;
bool result = Convert.ToBoolean(value);
return(result);
}
private void SetEventDetection(int bcmPinNumber, PinEvent kind, bool enabled)
{
//switch (kind)
//{
// case GpioEventKind.High:
// SetBit(RegisterViewPointer->GPHEN, pin);
// break;
// case GpioEventKind.Low:
// SetBit(RegisterViewPointer->GPLEN, pin);
// break;
// case GpioEventKind.SyncRisingEdge:
// SetBit(RegisterViewPointer->GPREN, pin);
// break;
// case GpioEventKind.SyncFallingEdge:
// SetBit(RegisterViewPointer->GPFEN, pin);
// break;
// case GpioEventKind.AsyncRisingEdge:
// SetBit(RegisterViewPointer->GPAREN, pin);
// break;
// case GpioEventKind.AsyncFallingEdge:
// SetBit(RegisterViewPointer->GPAFEN, pin);
// break;
// default: throw new InvalidGpioEventKindException(kind);
//}
int index = bcmPinNumber / 32;
int shift = bcmPinNumber % 32;
uint * registerPointer = null;
string registerName = string.Empty;
switch (kind)
{
case PinEvent.High:
registerPointer = &_registerViewPointer->GPHEN[index];
registerName = nameof(RegisterView.GPHEN);
break;
case PinEvent.Low:
registerPointer = &_registerViewPointer->GPLEN[index];
registerName = nameof(RegisterView.GPLEN);
break;
case PinEvent.SyncRisingEdge:
registerPointer = &_registerViewPointer->GPREN[index];
registerName = nameof(RegisterView.GPREN);
break;
case PinEvent.SyncFallingEdge:
registerPointer = &_registerViewPointer->GPFEN[index];
registerName = nameof(RegisterView.GPFEN);
break;
case PinEvent.AsyncRisingEdge:
registerPointer = &_registerViewPointer->GPAREN[index];
registerName = nameof(RegisterView.GPAREN);
break;
case PinEvent.AsyncFallingEdge:
registerPointer = &_registerViewPointer->GPAFEN[index];
registerName = nameof(RegisterView.GPAFEN);
break;
default:
throw new ArgumentException($"Invalid GPIO event kind '{kind}'");
}
//Console.WriteLine($"{registerName} register address = {(long)registerPointer:X16}");
uint register = *registerPointer;
//Console.WriteLine($"{registerName} original register value = {register:X8}");
if (enabled)
{
register |= 1U << shift;
}
else
{
register &= ~(1U << shift);
}
//Console.WriteLine($"{registerName} new register value = {register:X8}");
*registerPointer = register;
}
