Example #1
0
 private void WriteCommand(byte command)
 {
     pinDC.Write(false);
     spi.Write(new byte[1] {
         command
     });
 }
 /// <summary>
 /// Resets the module
 /// </summary>
 public void Reset()
 {
     resetPin.Write(false);
     Thread.Sleep(500);
     resetPin.Write(true);
     Thread.Sleep(1000);
 }
Example #3
0
        private int GetDistanceHelper()
        {
            long start        = 0;
            int  microseconds = 0;
            long time         = 0;
            int  distance     = 0;

            Trigger.Write(true);
            Thread.Sleep(10);
            Trigger.Write(false);

            int error = 0;

            while (!Echo.Read())
            {
                error++;
                if (error > 1000)
                {
                    break;
                }
                Thread.Sleep(0);
            }

            start = System.DateTime.Now.Ticks;

            while (Echo.Read())
            {
                Thread.Sleep(0);
            }

            time         = (System.DateTime.Now.Ticks - start);
            microseconds = (int)time / TicksPerMicrosecond;

            distance  = (microseconds / 58);
            distance += 2;

            if (distance < MAX_DISTANCE)
            {
                if (distance >= MIN_DISTANCE)
                {
                    return(distance);
                }
                else
                {
                    return(MinFlag);
                }
            }
            else
            {
                return(MaxFlag);
            }
        }
Example #4
0
        /// <summary>
        /// Sets the color of the module's LED to the passed in LEDColor enum.
        /// </summary>
        /// <param name="color"></param>
        public void SetColor(LEDColor color)
        {
            int r = ((int)(color) & 4);

            m_RedPin.Write((((int)color & 4) != 0 ? true : false));
            m_GreenPin.Write((((int)color & 2) != 0 ? true : false));
            m_BluePin.Write((((int)color & 1) != 0 ? true : false));
        }
Example #5
0
 private void SetSpeed(GTI.PWMOutput motor, GTI.DigitalOutput direction, int speed, bool isLeft)
 {
     if (speed == 0)
     {
         direction.Write(false);
         motor.Set(FEZCerbot.MOTOR_BASE_FREQUENCY, 0.01);
     }
     else if (speed < 0)
     {
         direction.Write(isLeft ? true : false);
         motor.Set(FEZCerbot.MOTOR_BASE_FREQUENCY, speed / -100.0);
     }
     else
     {
         direction.Write(isLeft ? false : true);
         motor.Set(FEZCerbot.MOTOR_BASE_FREQUENCY, speed / 100.0);
     }
 }
Example #6
0
 /// <summary>
 /// Renders Bitmap data on the display device.
 /// </summary>
 /// <param name="bitmap">The <see cref="T:Microsoft.SPOT.Bitmap"/> object to render on the display.</param>
 protected override void Paint(Bitmap bitmap)
 {
     try
     {
         if (Mainboard.NativeBitmapCopyToSpi != null)
         {
             SetClippingArea(0, 0, (uint)bitmap.Width - 1, (uint)bitmap.Height - 1);
             WriteCommand(0x2C);
             pinDC.Write(true);
             Mainboard.NativeBitmapCopyToSpi(bitmap, netMFSpiConfig, 0, 0, bitmap.Width, bitmap.Height, GT.Mainboard.BPP.BPP16_BGR_BE);
         }
         else
         {
             Draw(bitmap);
         }
     }
     catch
     {
         ErrorPrint("Painting error");
     }
 }
Example #7
0
        private static GTI.DigitalOutput backlightPin;// = new OutputPort(greenSocket.CpuPins[9], true);

        /// <summary>
        /// Sets the backlight to the passed in value.
        /// </summary>
        /// <param name="bOn">Backlight state.</param>
        public void SetBacklight(bool bOn)
        {
            if (greenSocket != null)
            {
                backlightPin.Write(bOn);
                _bBackLightOn = bOn;
            }
            else
            {
                ErrorPrint("Cannot set backlight yet. RGB sockets not yet initialized");
            }
        }
Example #8
0
        /// <summary>
        /// Clears all relays.
        /// </summary>
        public void DisableAllRelays()
        {
            regData = 0;
            ushort reg = (ushort)regData;

            for (int i = 0; i < 16; i++)
            {
                if ((reg & 0x1) == 1)
                {
                    data.Write(false);
                }
                else
                {
                    data.Write(true);
                }


                clock.Write(true);
                clock.Write(false);

                reg >>= 1;
            }

            latch.Write(true);
            latch.Write(false);
        }
        private uint ReadData()
        {
            int  bitCount;
            uint data = 0;

            _cs.Write(false);
            {
                for (bitCount = 31; bitCount >= 0; bitCount--)
                {
                    _clk.Write(true);

                    if (_miso.Read())
                    {
                        data |= (uint)(1 << bitCount);
                    }

                    _clk.Write(false);
                }
            }
            _cs.Write(true);

            return(data);
        }
Example #10
0
        // This method is run when the mainboard is powered up or reset.
        void ProgramStarted()
        {
            Debug.Print("Program Started");

            _relay = extender.SetupDigitalOutput(Socket.Pin.Three, _relayState);

            var timer = new GT.Timer(1000);
            timer.Tick += timer1 =>
                              {
                                  _relayState = !_relayState;
                                  _relay.Write(_relayState);
                              };
            timer.Start();
        }
Example #11
0
        /// <summary>
        /// Clears all registers.
        /// </summary>
        public void Clear()
        {
            if (!reSized)
            {
                ErrorPrint("The array has not been sixed yet. Please indicate how many modules are chained before continuing");
            }

            Enable.Write(true);
            CLR.Write(false);

            System.Threading.Thread.Sleep(10);
            byte[] clear = new byte[1] {
                0
            };
            spi.Write(clear);

            CLR.Write(true);
            Enable.Write(false);

            for (int i = 0; i < data.Length; i++)
            {
                data[i] = 0x0;
            }
        }
Example #12
0
 /// <summary>
 /// Turns on the module's LED.
 /// </summary>
 public void TurnLEDOn()
 {
     led.Write(true);
 }
Example #13
0
 /// <summary>
 /// Turns the heating element on or off. This may take up to 10 seconds befre a proper reading is taken.
 /// </summary>
 /// <param name="bOn">True to turn the element on, false to turn it off.</param>
 public void SetHeatingElement(bool bOn)
 {
     heatingElementEnable.Write(bOn);
 }
Example #14
0
 private void Reset()
 {
     pinReset.Write(false);
     Thread.Sleep(150);
     pinReset.Write(true);
 }
        /// <summary>
        /// Used to set a motor's speed.
        /// <param name="_motorSide">The motor <see cref="Motor"/> you are setting the speed for.</param>
        /// <param name="_newSpeed"> The new speed that you want to set the current motor to.</param>
        /// </summary>
        public void MoveMotor(Motor _motorSide, int _newSpeed)
        {
            // Make sure the speed is within an acceptable range.
            if (_newSpeed > 100 || _newSpeed < -100)
            {
                new ArgumentException("New motor speed outside the acceptable range (-100-100)", "_newSpeed");
            }

            //////////////////////////////////////////////////////////////////////////////////
            // Motor1
            //////////////////////////////////////////////////////////////////////////////////
            if (_motorSide == Motor.Motor2)
            {
                // Determine the direction we are going to go.
                if (_newSpeed == 0)
                {
                    //if (m_lastSpeed1 == 0)
                    m_Direction1.Write(false);
                    m_Pwm1.Set(Frequency, 0.01);
                }
                else if (_newSpeed < 0)
                {
                    // Set direction and power.
                    m_Direction1.Write(true);

                    /////////////////////////////////////////////////////////////////////////////
                    // Quick fix for current PWM issue
                    double fix = (double)((100 - System.Math.Abs(_newSpeed)) / 100.0);
                    if (fix >= 1.0)
                    {
                        fix = 0.99;
                    }
                    if (fix <= 0.0)
                    {
                        fix = 0.01;
                    }
                    /////////////////////////////////////////////////////////////////////////////

                    m_Pwm1.Set(Frequency, fix);
                }
                else
                {
                    // Set direction and power.
                    m_Direction1.Write(false);

                    /////////////////////////////////////////////////////////////////////////////
                    // Quick fix for current PWM issue
                    double fix = (double)(_newSpeed / 100.0);
                    if (fix >= 1.0)
                    {
                        fix = 0.99;
                    }
                    if (fix <= 0.0)
                    {
                        fix = 0.01;
                    }
                    /////////////////////////////////////////////////////////////////////////////

                    m_Pwm1.Set(Frequency, fix);
                }

                // Save our speed
                m_lastSpeed1 = _newSpeed;
            }
            //////////////////////////////////////////////////////////////////////////////////
            // Motor2
            //////////////////////////////////////////////////////////////////////////////////
            else
            {
                // Determine the direction we are going to go.
                if (_newSpeed == 0)
                {
                    //if( m_lastSpeed2 == 0)
                    m_Direction2.Write(false);
                    m_Pwm2.Set(Frequency, 0.01);
                }
                else if (_newSpeed < 0)
                {
                    // Set direction and power.
                    m_Direction2.Write(true);

                    /////////////////////////////////////////////////////////////////////////////
                    // Quick fix for current PWM issue
                    double fix = (double)((100 - System.Math.Abs(_newSpeed)) / 100.0);
                    if (fix >= 1.0)
                    {
                        fix = 0.99;
                    }
                    if (fix <= 0.0)
                    {
                        fix = 0.01;
                    }
                    /////////////////////////////////////////////////////////////////////////////

                    m_Pwm2.Set(Frequency, fix);
                }
                else
                {
                    // Set direction and power.
                    m_Direction2.Write(false);

                    /////////////////////////////////////////////////////////////////////////////
                    // Quick fix for current PWM issue
                    double fix = (double)(_newSpeed / 100.0);
                    if (fix >= 1.0)
                    {
                        fix = 0.99;
                    }
                    if (fix <= 0.0)
                    {
                        fix = 0.01;
                    }
                    /////////////////////////////////////////////////////////////////////////////

                    m_Pwm2.Set(Frequency, fix);
                }

                // Save our speed
                m_lastSpeed2 = _newSpeed;
            }
            //////////////////////////////////////////////////////////////////////////////////
        }
Example #16
0
 /// <summary>
 /// Enables or disables the display backlight.
 /// </summary>
 /// <param name="state">The state to set the backlight to.</param>
 public void SetBacklight(bool state)
 {
     pinBacklight.Write(state);
 }
Example #17
0
 /// <summary>
 /// Enables the outputs to the relays.
 /// </summary>
 private void EnableOutputs()
 {
     enable.Write(false);
 }
Example #18
0
        private void SoftwareSPI_WriteRead(byte[] write, byte[] read)
        {
            int writeLen = write.Length;
            int readLen  = 0;

            if (read != null)
            {
                readLen = read.Length;

                for (int i = 0; i < readLen; i++)
                {
                    read[i] = 0;
                }
            }

            int loopLen = (writeLen < readLen ? readLen : writeLen);

            byte w = 0;

            CS.Write(false);

            // per byte
            for (int len = 0; len < loopLen; len++)
            {
                if (len < writeLen)
                {
                    w = write[len];
                }

                byte mask = 0x80;

                // per bit
                for (int i = 0; i < 8; i++)
                {
                    CLOCK.Write(false);

                    if ((w & mask) == mask)
                    {
                        MOSI.Write(true);
                    }
                    else
                    {
                        MOSI.Write(false);
                    }

                    CLOCK.Write(true);

                    if (true == MISO.Read())
                    {
                        if (read != null)
                        {
                            read[len] |= mask;
                        }
                    }

                    mask >>= 1;
                }

                MOSI.Write(false);
                CLOCK.Write(false);
            }

            Thread.Sleep(20);
            CS.Write(true);
        }
Example #19
0
        /// <summary>
        /// Attempts to enable writing to the flash, and returns the result.
        /// </summary>
        /// <returns>True is writing is enabled, false if it is not</returns>
        public bool WriteEnable()
        {
            ClearBuffers();

            writeData[0] = CMD_WRITE_ENABLE;

            statusLED.Write(true);

            spi.Write(writeData);

            writeData[0] = CMD_READ_STATUS;

            spi.WriteRead(writeData, readData);

            statusLED.Write(false);

            return((readData[1] & 0x2) != 0);
        }