public static async Task InitILI9488DisplaySPI(ILI9488Display display, int SPIDisplaypin, int speed, SpiMode mode, string SPI_CONTROLLER_NAME, string DefaultDisplay)
        {
            var displaySettings = new SpiConnectionSettings(SPIDisplaypin);

            displaySettings.ClockFrequency = speed; // 500kHz;
            displaySettings.Mode           = mode;  //Mode0,1,2,3;  MCP23S17 needs mode 0
            string DispspiAqs     = SpiDevice.GetDeviceSelector(SPI_CONTROLLER_NAME);
            var    DispdeviceInfo = await DeviceInformation.FindAllAsync(DispspiAqs);

            display.SpiDisplay = await SpiDevice.FromIdAsync(DispdeviceInfo[0].Id, displaySettings);

            await ResetDisplay(display);
            await InitRegisters(display);
            await wakeup(display);

            if (String.IsNullOrEmpty(DefaultDisplay))
            {
                InitializeDisplayBuffer(display, ILI9488Display.BLACK);
            }
            else
            {
                await LoadBitmap(display, DefaultDisplay);
            }
            Flush(display);
        }
 private static void SetAddress(ILI9488Display display, UInt16 x0, UInt16 y0, UInt16 x1, UInt16 y1)
 {
     SendCommand(display, CMD_COLUMN_ADDRESS_SET);
     SendData(display, new byte[] { (byte)(x0 >> 8), (byte)(x0), (byte)(x1 >> 8), (byte)(x1) });
     SendCommand(display, CMD_PAGE_ADDRESS_SET);
     SendData(display, new byte[] { (byte)(y0 >> 8), (byte)(y0), (byte)(y1 >> 8), (byte)(y1) });
 }
        public static async Task wakeup(ILI9488Display display)
        {
            SendCommand(display, ILI9488_CMD_SLEEP_OUT);
            await Task.Delay(150);

            SendCommand(display, ILI9488_CMD_DISPLAY_ON);
        }
 public static void InitializeDisplayBuffer(ILI9488Display display, UInt16 colour)
 {
     for (uint i = 0; i < display.LCD_HORIZONTAL_MAX * display.LCD_VERTICAL_MAX; i++)
     {
         display.DisplayBuffer[i * 2]     = (byte)(colour >> 8);
         display.DisplayBuffer[i * 2 + 1] = (byte)(colour & 0xFF);
     }
 }
        public static async Task ResetDisplay(ILI9488Display display)
        {
            // assume power has just been turned on
            display.ResetPin.Write(GpioPinValue.High);
            await Task.Delay(10);

            display.ResetPin.Write(GpioPinValue.Low);   // reset
            await Task.Delay(10);                       // wait 10 ms

            display.ResetPin.Write(GpioPinValue.High);  // out of reset
            await Task.Delay(150);
        }
        public static async Task landscapeMode(ILI9488Display display)
        {
            try {
                SendCommand(display, ILI9488_CMD_MEMORY_ACCESS_CONTROL); SendData(display, new byte[] { 0xE8 });
                display.LCD_HORIZONTAL_MAX = ILI9488Display.VERTICAL_MAX_DEFAULT;
                display.LCD_VERTICAL_MAX   = ILI9488Display.HORIZONTAL_MAX_DEFAULT;
                await LoadBitmap(display, display.currentImage);

                Flush(display);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        public static async Task LoadBitmap(ILI9488Display display, string name)
        {
            try
            {
                StorageFile srcfile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(name));

                using (IRandomAccessStream fileStream = await srcfile.OpenAsync(Windows.Storage.FileAccessMode.Read))
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);

                    BitmapTransform transform = new BitmapTransform()
                    {
                        ScaledWidth  = Convert.ToUInt32(display.LCD_HORIZONTAL_MAX),
                        ScaledHeight = Convert.ToUInt32(display.LCD_VERTICAL_MAX)
                    };
                    PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
                        BitmapPixelFormat.Bgra8,
                        BitmapAlphaMode.Straight,
                        transform,
                        ExifOrientationMode.RespectExifOrientation,
                        ColorManagementMode.DoNotColorManage
                        );

                    byte[] sourcePixels = pixelData.DetachPixelData();
                    if (sourcePixels.Length != display.LCD_HORIZONTAL_MAX * display.LCD_VERTICAL_MAX * 4)
                    {
                        return;
                    }
                    int pi = 0;
                    for (UInt32 x = 0; x < sourcePixels.Length - 1; x += 4)
                    {
                        // we ignore the alpha value [3]
                        ushort temp = ILI9341.RGB24ToRGB565(sourcePixels[x + 2], sourcePixels[x + 1], sourcePixels[x]);
                        display.DisplayBuffer[pi * 2]     = (byte)((temp >> 8) & 0xFF);
                        display.DisplayBuffer[pi * 2 + 1] = (byte)(temp & 0xFF);
                        pi++;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            display.currentImage = name;
        }
        public static void Flush(ILI9488Display display)
        {
            if (display.DisplayBuffer.Length != display.LCD_VERTICAL_MAX * display.LCD_HORIZONTAL_MAX * 2)
            {
                return;
            }
            SetAddress(display, 0, 0, (UInt16)(display.LCD_HORIZONTAL_MAX - 1), (UInt16)(display.LCD_VERTICAL_MAX - 1));
            int block_size = 51200; // limits of the SPI interface is 64K but this is an even block for display ???

            byte[] buffer = new byte[block_size];
            // now we start to write the buffer out
            SendCommand(display, ILI9488_CMD_MEMORY_WRITE);
            Array.Copy(display.DisplayBuffer, 0, buffer, 0, 51200);
            SendData(display, buffer);
            Array.Copy(display.DisplayBuffer, 51200, buffer, 0, 51200);
            SendData(display, buffer);
            Array.Copy(display.DisplayBuffer, 51200 * 2, buffer, 0, 51200);
            SendData(display, buffer);
        }
        public static async Task InitRegisters(ILI9488Display display)
        {
            SendCommand(display, ILI9488_CMD_POSITIVE_GAMMA_CTRL);      SendData(display, new byte[] { 0x00, 0x07, 0x0F, 0x0D, 0x1B, 0x0A, 0x3C, 0x78, 0x4A, 0x07, 0x0E, 0x09, 0x1B, 0x1E, 0x0F });
            SendCommand(display, ILI9488_CMD_NEGATIVE_GAMMA_CTRL);      SendData(display, new byte[] { 0x00, 0x22, 0x24, 0x06, 0x12, 0x07, 0x36, 0x47, 0x47, 0x06, 0x0A, 0x07, 0x30, 0x37, 0x0F });

            SendCommand(display, ILI9488_CMD_POWER_CONTROL_1);          SendData(display, new byte[] { 0x10, 0x10 });
            SendCommand(display, ILI9488_CMD_POWER_CONTROL_2);          SendData(display, new byte[] { 0x41 });

            SendCommand(display, ILI9488_CMD_VCOM_CONTROL_1);                SendData(display, new byte[] { 0x00, 0x22, 0x80 });

            SendCommand(display, ILI9488_CMD_MEMORY_ACCESS_CONTROL);        SendData(display, new byte[] { 0x68 }); // standard

            SendCommand(display, ILI9488_CMD_INTERFACE_MODE_CONTROL);       SendData(display, new byte[] { 0x00 }); // standard

            SendCommand(display, ILI9488_CMD_FRAME_RATE_CONTROL_NORMAL);    SendData(display, new byte[] { 0xB0, 0x11 });

            SendCommand(display, ILI9488_CMD_DISPLAY_INVERSION_CONTROL);    SendData(display, new byte[] { 0x02 });

            SendCommand(display, ILI9488_CMD_INTERFACE_PIXEL_FORMAT);       SendData(display, new byte[] { 0x55 }); // the wave share is actually working in 16bit parallel mode

            SendCommand(display, ILI9488_CMD_SET_IMAGE_FUNCTION);           SendData(display, new byte[] { 0x01 });

            SendCommand(display, ILI9488_CMD_ENTRY_MODE_SET);               SendData(display, new byte[] { 0xC6 });

            SendCommand(display, ILI9488_CMD_ADJUST_CONTROL_3);             SendData(display, new byte[] { 0xA9, 0x51, 0x2C, 0x82 });

            SendCommand(display, ILI9488_CMD_DISPLAY_FUNCTION_CONTROL);     SendData(display, new byte[] { 0x00, 0x22, 0x3B });



            //SendCommand(display, CMD_DRIVER_TIMING_CONTROL_A);   SendData(display, new byte[] { 0x85, 0x00, 0x78 });
            //SendCommand(display, CMD_DRIVER_TIMING_CONTROL_B);   SendData(display, new byte[] { 0x00, 0x00 });

            //SendCommand(display, CMD_POWER_ON_SEQUENCE_CONTROL); SendData(display, new byte[] { 0x64, 0x03, 0x12, 0x81 });

            // SendCommand(display, CMD_VCOM_CONTROL_2);            SendData(display, new byte[] { 0x86 });
            // SendCommand(display, CMD_ENABLE_3G);                 SendData(display, new byte[] { 0x00 });
            // SendCommand(display, CMD_GAMMA_SET);                 SendData(display, new byte[] { 0x01 });
        }
 private static void SendCommand(ILI9488Display display, byte[] Command)
 {
     display.DCPin.Write(GpioPinValue.Low);
     display.SpiDisplay.Write(Command);
 }
 private static void SendData(ILI9488Display display, byte[] Data)
 {
     display.DCPin.Write(GpioPinValue.High);
     display.SpiDisplay.Write(Data);
 }
 public static void Sleep(ILI9488Display display)
 {
     SendCommand(display, CMD_DISPLAY_OFF);
     SendCommand(display, CMD_ENTER_SLEEP);
 }