private bool DoTestSdcard()
{
var result = true;
this.UpdateStatusText("Waiting for Sd initialize...", true);
var storageController = StorageController.FromName(SC20260.StorageController.SdCard);
IDriveProvider drive;
try_again:
if (this.isRunning == false)
{
result = false;
goto _return;
}
try {
drive = FileSystem.Mount(storageController.Hdc);
var driveInfo = new DriveInfo(drive.Name);
this.UpdateStatusText(MountSuccess, false);
}
catch {
this.UpdateStatusText("Sd: " + BadConnect1, true);
while (this.doNext == false)
{
Thread.Sleep(1000);
goto try_again;
}
result = false;
goto _return;
}
_return:
try {
GHIElectronics.TinyCLR.IO.FileSystem.Flush(storageController.Hdc);
GHIElectronics.TinyCLR.IO.FileSystem.Unmount(storageController.Hdc);
}
catch {
}
return(result);
}
private static void Main()
{
// Indicator LED
var led1 = GpioController.GetDefault().OpenPin(G30.GpioPin.PC7);
led1.SetDriveMode(GpioPinDriveMode.Output);
led1.Write(GpioPinValue.Low);
var sd = StorageController.FromName(@"GHIElectronics.TinyCLR.NativeApis.STM32F4.SdCardStorageController\0");
var drive = FileSystem.Mount(sd.Hdc);
// While not required, having the right time is needed
// The File System saves the file with current time
var rtcControl = RtcController.GetDefault();
// We will use this time if RTC is not valid - 2019/January/1 10:5:0
var CurrentTime = new DateTime(2019, 1, 1, 10, 5, 0);
if (rtcControl.IsValid)
{
CurrentTime = rtcControl.Now;
}
else
{
rtcControl.Now = CurrentTime;
}
SystemTime.SetTime(CurrentTime);
// Add a file
var file = new FileStream($@"{drive.Name}Test.txt", FileMode.Append);
var bytes = Encoding.UTF8.GetBytes("Hello is recorded at: " +
DateTime.UtcNow.ToString() + Environment.NewLine);
file.Write(bytes, 0, bytes.Length);
file.Close();
// Show a list of files on root directory
var directory = new DirectoryInfo(drive.Name);
var files = directory.GetFiles();
foreach (var f in files)
{
Debug.WriteLine(f.Name);
}
FileSystem.Flush(sd.Hdc);
// Turn an LED on indicating the operation is complete!
// Reset the board a few times and check the file content.
led1.Write(GpioPinValue.High);
}
private bool DoTestUsbHost()
{
var result = true;
this.UpdateStatusText("Waiting for usb host initialize...", true);
UsbWindow.InitializeUsbHostController();
while (!UsbWindow.IsUsbHostConnected && this.isRunning)
{
Thread.Sleep(100);
}
if (this.isRunning == false)
{
return(false);
}
var storageController = StorageController.FromName(SC20260.StorageController.UsbHostMassStorage);
IDriveProvider drive;
try {
drive = FileSystem.Mount(storageController.Hdc);
var driveInfo = new DriveInfo(drive.Name);
this.UpdateStatusText(MountSuccess, false);
}
catch {
this.UpdateStatusText("Usb Host: " + BadConnect1, true);
result = false;
goto _return;
}
_return:
try {
GHIElectronics.TinyCLR.IO.FileSystem.Flush(storageController.Hdc);
GHIElectronics.TinyCLR.IO.FileSystem.Unmount(storageController.Hdc);
}
catch {
}
return(result);
}
// This method is run when the mainboard is powered up or reset.
public void ProgramStarted()
{
//usb host
var usbHostController = GHIElectronics.TinyCLR.Devices.UsbHost.
UsbHostController.GetDefault();
usbHostController.Enable();
//sdcard
var sd = StorageController.FromName(SC20260.StorageController.SdCard);
var drive = FileSystem.Mount(sd.Hdc);
var lcd = new DisplayDriver43(SC20260.GpioPin.PA15);
GHI.Glide.Glide.SetupGlide(480, 272, 96, 0, lcd.display);
// Use Debug.WriteLine to show messages in Visual Studio's "Output" window during debugging.
Debug.WriteLine("Program Started");
Screens = new Hashtable();
//populate all form
var F1 = new SplashForm(ref MainWindow);
F1.FormRequestEvent += General_FormRequestEvent;
Screens.Add(Screen.ScreenTypes.Splash, F1);
var F2 = new PromptForm(ref MainWindow, ref lcd, ref drive, ref usbHostController);
F2.FormRequestEvent += General_FormRequestEvent;
Screens.Add(Screen.ScreenTypes.Prompt, F2);
GHI.Glide.Glide.FitToScreen = true;
GlideTouch.Initialize();
//load splash
LoadForm(Screen.ScreenTypes.Splash);
//GHI.Glide.Glide.MainWindow = window;
lcd.CapacitiveScreenReleased += Lcd_CapacitiveScreenReleased;
lcd.CapacitiveScreenPressed += Lcd_CapacitiveScreenPressed;
lcd.CapacitiveScreenMove += Lcd_CapacitiveScreenMove;
//string dir = Strings.NormalizeDirectory("\\sd");
//string siz = Strings.FormatDiskSize(1128);
}
public static void Initialize()
{
if (_initialized)
{
return;
}
lock (_lock)
{
if (_initialized)
{
return;
}
Controller = StorageController.FromName(SC20260.StorageController.SdCard);
Drive = FileSystem.Mount(Controller.Hdc);
}
_initialized = true;
}
public SDTest()
{
byte[] buffer = new byte[256];
sc = StorageController.FromName(@"GHIElectronics.TinyCLR.NativeApis.STM32F7.SdCardStorageController\0");
sc.Open();
drive = sc.Provider;
//try
//{
// drive = FileSystem.Mount(sc.Hdc);
//}
//catch (Exception ex)
//{
// string s = ex.Message;
// Debug.WriteLine("ERROR SDCard:" + s);
//}
drive.Open();
drive.Read(0, 256, buffer, 0, 10000);
Debug.WriteLine("Read from card: " + buffer[0].ToString());
//int n = drive.Write(100000L, 4, new byte[] { 0x55, 0xAA, 0x55, 0xAA }, 0, 100000);
//Debug.WriteLine("Write to card: " + n.ToString());
drive.Close();
sc.Close();
}
private void ThreadTest()
{
const int BlockSize = 1024;
this.isRuning = true;
var data = System.Text.Encoding.UTF8.GetBytes("This is for usb\n");
// Defragment memory
var dataWrite = new byte[BlockSize];
var dataRead = new byte[BlockSize];
for (var i = 0; i < BlockSize; i += data.Length)
{
Array.Copy(data, 0, dataWrite, i, data.Length);
}
var storageController = StorageController.FromName(SC20260.StorageController.UsbHostMassStorage);
IDriveProvider drive;
var timeout = 0;
while (usbConnected == false)
{
Thread.Sleep(1000);
timeout++;
if (timeout > 5) // 5 seconds
{
break;
}
}
if (usbConnected == false)
{
this.UpdateStatusText(BadConnect1, true);
goto _return;
}
try {
drive = FileSystem.Mount(storageController.Hdc);
var driveInfo = new DriveInfo(drive.Name);
this.UpdateStatusText(FreeSize + driveInfo.TotalFreeSpace, true);
this.UpdateStatusText(TotalSize + driveInfo.TotalSize, false);
this.UpdateStatusText(VolumeLabel + driveInfo.VolumeLabel, false);
this.UpdateStatusText(RootDirectory + driveInfo.RootDirectory, false);
this.UpdateStatusText(DriveFormat + driveInfo.DriveFormat, false);
this.UpdateStatusText(MountSuccess, false);
}
catch {
this.UpdateStatusText(BadConnect1, true);
goto _return;
}
var filename = drive.Name + "\\TEST_USB.TXT";
try {
using (var fsWrite = new FileStream(filename, FileMode.Create)) {
fsWrite.Write(dataWrite, 0, dataWrite.Length);
fsWrite.Flush();
fsWrite.Close();
}
}
catch {
this.UpdateStatusText(BadWrite, false);
goto _unmount;
}
try {
using (var fsRead = new FileStream(filename, FileMode.Open)) {
fsRead.Read(dataRead, 0, dataRead.Length);
for (var i = 0; i < dataRead.Length; i++)
{
if (dataRead[i] != dataWrite[i])
{
this.UpdateStatusText(BadConnect2, false);
goto _unmount;
}
}
fsRead.Flush();
fsRead.Close();
}
}
catch {
this.UpdateStatusText(BadRead, false);
goto _unmount;
}
this.UpdateStatusText(TestSuccess, false);
_unmount:
try {
GHIElectronics.TinyCLR.IO.FileSystem.Flush(storageController.Hdc);
GHIElectronics.TinyCLR.IO.FileSystem.Unmount(storageController.Hdc);
}
catch {
}
_return:
this.isRuning = false;
}
private void ThreadTest()
{
this.isRunning = true;
var storeController = StorageController.FromName(SC20260.StorageController.QuadSpi);
var drive = storeController.Provider;
drive.Open();
var sectorSize = drive.Descriptor.RegionSizes[0];
var textWrite = System.Text.UTF8Encoding.UTF8.GetBytes("this is for test");
var dataRead = new byte[sectorSize];
var dataWrite = new byte[sectorSize];
for (var i = 0; i < sectorSize; i += textWrite.Length)
{
Array.Copy(textWrite, 0, dataWrite, i, textWrite.Length);
}
var roundTest = 0;
var startSector = 0;
var endSector = 8;
_again:
if (roundTest == 1)
{
startSector = 4088; // last 8 sectors
endSector = startSector + 8;
}
for (var s = startSector; s < endSector; s++)
{
var address = s * sectorSize;
this.UpdateStatusText("Erasing sector " + s, true);
// Erase
drive.Erase(address, sectorSize, TimeSpan.FromSeconds(100));
// Write
this.UpdateStatusText("Writing sector " + s, false);
drive.Write(address, sectorSize, dataWrite, 0, TimeSpan.FromSeconds(100));
this.UpdateStatusText("Reading sector " + s, false);
//Read to compare
drive.Read(address, sectorSize, dataRead, 0, TimeSpan.FromSeconds(100));
for (var idx = 0; idx < sectorSize; idx++)
{
if (dataRead[idx] != dataWrite[idx])
{
this.UpdateStatusText("Compare failed at: " + idx, false);
goto _return;
}
}
}
roundTest++;
if (roundTest == 2)
{
this.UpdateStatusText("Tested Quad Spi successful!", false);
}
else
{
goto _again;
}
_return:
drive.Close();
this.isRunning = false;
return;
}
private bool DoTestExternalFlash()
{
var storeController = StorageController.FromName(SC20260.StorageController.QuadSpi);
var drive = storeController.Provider;
var result = true;
drive.Open();
var sectorSize = drive.Descriptor.RegionSizes[0];
var dataRead = new byte[sectorSize];
var dataWrite = new byte[sectorSize];
var rd = new Random();
var roundTest = 0;
var startSector = 0;
var endSector = 8;
var md5 = MD5.Create();
_again:
if (roundTest == 1)
{
startSector = 4088;
endSector = startSector + 8;
}
for (var s = startSector; s < endSector; s++)
{
md5.Clear();
rd.NextBytes(dataWrite);
var md5dataWrite = md5.ComputeHash(dataWrite);
this.UpdateStatusText("Testing external flash.", true);
var address = s * sectorSize;
this.UpdateStatusText("External flash - Erasing sector " + s, false);
// Erase
drive.Erase(address, sectorSize, TimeSpan.FromSeconds(100));
// Write
this.UpdateStatusText("External flash - Writing sector " + s, false);
drive.Write(address, sectorSize, dataWrite, 0, TimeSpan.FromSeconds(100));
this.UpdateStatusText("External flash - Reading sector " + s, false);
//Read to compare
drive.Read(address, sectorSize, dataRead, 0, TimeSpan.FromSeconds(100));
md5.Clear();
var md5Read = md5.ComputeHash(dataRead);
for (var i = 0; i < md5Read.Length; i++)
{
if (md5Read[i] != md5dataWrite[i])
{
this.UpdateStatusText("External flash - Compare failed at: " + s, false);
result = false;
goto _return;
}
}
}
roundTest++;
if (roundTest == 2)
{
this.UpdateStatusText("Tested Quad Spi successful!", false);
}
else
{
goto _again;
}
_return:
drive.Close();
return(result);
}
static void DoDraw()
{
try {
var sd = StorageController.FromName(SC20260.StorageController.SdCard);
var drive = FileSystem.Mount(sd.Hdc);
var spiController = SpiController.FromName(SC20260.SpiBus.Spi5);
var ledController = new APA102CController(spiController, (PanelsWide * PanelsHigh) << 8);
var stream = new FileStream(@"A:\output.avi", FileMode.Open);
var aviDecoder = new AviDecoder(stream);
var fpsCounter = 0;
var oneSecondStart = DateTime.Now;
var textColor = new SolidBrush(Color.White);
aviDecoder.Run();
var frameCounter = 0;
var pauseCounter = 0;
while (true)
{
var t1 = DateTime.Now;
if (pauseApp == true && pauseCounter > 0)
{
goto display_text;
}
pauseCounter = pauseApp ? (pauseCounter + 1) : 0;
try {
Bitmap bitmap;
bitmap = aviDecoder.GetBimap();
screen.Clear();
if (bitmap != null)
{
var data = NativeCookData(bitmap, (byte)(0b1110_0000 | intensity));
ledController.SetBuffer(data, 0, data.Length);
for (var i = 0; i < 2; i++) // flush twice to fix pannel 5 mesy sometime
{
ledController.Flush();
}
screen.DrawImage(bitmap, (LcdWidth - bitmap.Width) >> 1, (LcdHeight - bitmap.Height) >> 1);
}
}
catch {
}
display_text:
screen.DrawString("Status: " + (frameCounter < 1 ? "Loading... " : (pauseApp ? "Paused" : "Playing")), font, textColor, 10, 10);
screen.DrawString("Intensity: " + intensity, font, textColor, 10, 30);
screen.Flush();
frameCounter++;
if (frameCounter % 10 == 0)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Thread.Sleep(1);
if (aviDecoder != null && aviDecoder.headerInfo != null && aviDecoder.headerInfo.TimeBetweenFrames != 0)
{
var t2 = DateTime.Now - t1;
if (t2.TotalMilliseconds < aviDecoder.headerInfo.TimeBetweenFrames)
{
Thread.Sleep(aviDecoder.headerInfo.TimeBetweenFrames - (int)t2.TotalMilliseconds);
}
fpsCounter++;
var oneSecondEnd = DateTime.Now - oneSecondStart;
if (oneSecondEnd.TotalMilliseconds >= 1000)
{
Debug.WriteLine("Fps = " + fpsCounter);
fpsCounter = 0;
oneSecondStart = DateTime.Now;
}
}
}
}
catch {
screen.Clear();
screen.DrawString("Loading file from sd card failed.", font, new SolidBrush(Color.Red), 10, 10);
screen.DrawString("Check the card and Reset application.", font, new SolidBrush(Color.Red), 10, 30);
screen.Flush();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QspiMemory"/> class.
/// </summary>
public QspiMemory()
{
qspi = StorageController.FromName(SC20260.StorageController.QuadSpi).Provider;
qspi.Open();
}
public CardDevice(string name)
{
_storageController = StorageController.FromName(name);
}
