/**
 * @brief  Sends header information to CC3000
 * @param  None
 * @retval None
 */
long SpiWrite(unsigned char *ucBuf, unsigned short usLength)
{

        int NotAborted = 0;
        switch (State())
        {
        case eSPI_STATE_POWERUP:

          NotAborted = WaitFor(eSPI_STATE_INITIALIZED);
          if (!NotAborted) {
              break;
          }
          // fall through - No break at the end of case

        case eSPI_STATE_INITIALIZED:

          NotAborted = SetState(eSPI_STATE_FIRST_WRITE, eAssert);
          usLength = SpiSetUp(ucBuf,usLength);
          if (NotAborted)
          {
              //Delay for at least 50 us
              Delay_Microsecond(50);

              //SPI writes first 4 bytes of data
              NotAborted = SpiIO(eWrite, ucBuf, 4, TRUE);
              if (NotAborted)
              {
                //Delay for at least 50 us
                Delay_Microsecond(50);

                //SPI writes next 4 bytes of data
                NotAborted = SpiIO(eWrite, &ucBuf[4], usLength - 4, TRUE);
              }
          }
          break;

        default:
            NotAborted = WaitFor(eSPI_STATE_IDLE);
            if(NotAborted)
            {
              NotAborted = Reserve(eSPI_STATE_WRITE_WAIT_IRQ);
              WARN("CC3000 SpiWrite acquire bus");
              if(NotAborted)
              {
                  usLength = SpiSetUp(ucBuf, usLength);
                  NotAborted = WaitFor(eSPI_STATE_WRITE_PROCEED);
                  if(NotAborted)
                  {
                      NotAborted = SpiIO(eWrite, ucBuf, usLength, TRUE);
                  }
              }
            }
          break;
        }
        return NotAborted ? usLength : -1;
}
/****************************************************************************
 CC3000 SPI Protocol API
 ****************************************************************************/
void SpiOpen(gcSpiHandleRx pfRxHandler)
{

	sSpiInformation.ulSpiState = eSPI_STATE_POWERUP;

	sSpiInformation.SPIRxHandler = pfRxHandler;
	sSpiInformation.pRxPacket = wlan_rx_buffer;
	sSpiInformation.usRxPacketLength = 0;
	sSpiInformation.pTxPacket = NULL;
	sSpiInformation.usTxPacketLength = 0;

	/* Enable Interrupt */
        tSLInformation.WriteWlanPin( WLAN_DISABLE );
        Delay_Microsecond(MS2u(300));
 	tSLInformation.WlanInterruptEnable();
        Delay_Microsecond(MS2u(1));
        tSLInformation.WriteWlanPin( WLAN_ENABLE );
        WaitFor(eSPI_STATE_INITIALIZED);

}
Ejemplo n.º 3
0
/*
 * @brief This should block for a certain number of microseconds.
 */
void delayMicroseconds(unsigned int us)
{
	Delay_Microsecond(us);
}
Ejemplo n.º 4
0
void panic_(ePanicCode code)
{
        __disable_irq();
        flash_codes_t pcd = flash_codes[code];
        LED_SetRGBColor(RGB_COLOR_WHITE);
        LED_Off(LED_RGB);
        uint16_t c;
        while(1) {
                // preamble
            for (c = 3; c; c--) {
                LED_SetRGBColor(pcd.led);
                LED_On(LED_RGB);
                Delay_Microsecond(MS2u(150));
                LED_Off(LED_RGB);
                Delay_Microsecond(MS2u(100));
            }

            Delay_Microsecond(MS2u(100));
            for (c = 3; c; c--) {
                LED_SetRGBColor(pcd.led);
                LED_On(LED_RGB);
                Delay_Microsecond(MS2u(300));
                LED_Off(LED_RGB);
                Delay_Microsecond(MS2u(100));
            }
            Delay_Microsecond(MS2u(100));

            for (c = 3; c; c--) {
                LED_SetRGBColor(pcd.led);
                LED_On(LED_RGB);
                Delay_Microsecond(MS2u(150));
                LED_Off(LED_RGB);
                Delay_Microsecond(MS2u(100));
            }

                // pause
                Delay_Microsecond(MS2u(900));
                // play code
                for (c = code; c; c--) {
                    LED_SetRGBColor(pcd.led);
                    LED_On(LED_RGB);
                    Delay_Microsecond(MS2u(300));
                    LED_Off(LED_RGB);
                    Delay_Microsecond(MS2u(300));
                }
                // pause
                Delay_Microsecond(MS2u(800));
        }
}