Exemple #1
0
void SpiWriteDataSynchronous(unsigned char *data, unsigned short size)
{
  unsigned char dummy;
  
  //DEBUGPRINT_F("\tCC3000: SpiWriteDataSynchronous Start\n\r");

  uint8_t loc;
  for (loc = 0; loc < size; loc ++) 
  {
    dummy = SPI.transfer(data[loc]);
#if (DEBUG_MODE == 1)
      if (!(loc==size-1))
      {
        //DEBUGPRINT_F(" ");
        DEBUGPRINT_HEX(data[loc]); 
      }
      else
      {
        //DEBUGPRINT_F(" ");
        DEBUGPRINT_HEX(data[loc]);
      }
#endif
  }
  
  //DEBUGPRINT_F("\n\r\tCC3000: SpiWriteDataSynchronous End\n\r");
}
//*****************************************************************************
//
//!  simple_link_recv
//!
//!  @param sd       socket handle
//!  @param buf      read buffer
//!  @param len      buffer length
//!  @param flags    indicates blocking or non-blocking operation
//!  @param from     pointer to an address structure indicating source address
//!  @param fromlen  source address structure size
//!
//!  @return         Return the number of bytes received, or -1 if an error
//!                  occurred
//!
//!  @brief          Read data from socket
//!                  Return the length of the message on successful completion.
//!                  If a message is too long to fit in the supplied buffer,
//!                  excess bytes may be discarded depending on the type of
//!                  socket the message is received from
//
//*****************************************************************************
int
simple_link_recv(long sd, void *buf, long len, long flags, sockaddr *from,
                socklen_t *fromlen, long opcode)
{
	unsigned char *ptr, *args;
	tBsdReadReturnParams tSocketReadEvent;
	
	ptr = tSLInformation.pucTxCommandBuffer;
	args = (ptr + HEADERS_SIZE_CMD);
	
	// Fill in HCI packet structure
	args = UINT32_TO_STREAM(args, sd);
	args = UINT32_TO_STREAM(args, len);
	args = UINT32_TO_STREAM(args, flags);

	// Generate the read command, and wait for the 
	hci_command_send(opcode,  ptr, SOCKET_RECV_FROM_PARAMS_LEN);
	
	// Since we are in blocking state - wait for event complete
	SimpleLinkWaitEvent(opcode, &tSocketReadEvent);

	DEBUGPRINT_F("\n\r\tRecv'd data... Socket #");
	DEBUGPRINT_DEC(tSocketReadEvent.iSocketDescriptor);
	DEBUGPRINT_F(" Bytes: 0x");
	DEBUGPRINT_HEX(tSocketReadEvent.iNumberOfBytes);
	DEBUGPRINT_F(" Flags: 0x");
	DEBUGPRINT_HEX(tSocketReadEvent.uiFlags);
	DEBUGPRINT_F("\n\r");

	// In case the number of bytes is more then zero - read data
	if (tSocketReadEvent.iNumberOfBytes > 0)
	{
		// Wait for the data in a synchronous way. Here we assume that the bug is 
		// big enough to store also parameters of receive from too....
	  SimpleLinkWaitData((unsigned char *)buf, (unsigned char *)from, (unsigned char *)fromlen);
	}
	
	errno = tSocketReadEvent.iNumberOfBytes;

#if (DEBUG_MODE == 1)
	for (uint8_t i=0; i<errno; i++) {
	  uart_putchar(((unsigned char *)buf)[i]);
	}
#endif
	
	return(tSocketReadEvent.iNumberOfBytes);
}
void SpiReadDataSynchronous(unsigned char *data, unsigned short size)
{
  unsigned short i = 0;
  
  DEBUGPRINT_F("\tCC3000: SpiReadDataSynchronous\n\r");
  SPI.setDataMode(SPI_MODE1);
  for (i = 0; i < size; i ++)
  {
    data[i] = SPI.transfer(0x03);
    DEBUGPRINT_F("  ");
    DEBUGPRINT_HEX(data[i]);
  }
  DEBUGPRINT_F("\n\r");
}
void SpiWriteDataSynchronous(unsigned char *data, unsigned short size)
{
  DEBUGPRINT_F("\tCC3000: SpiWriteDataSynchronous Start\n\r");

  unsigned short loc;
  for (loc = 0; loc < size; loc ++) 
  {
      theCcspi->transfer(data[loc]);
#if (DEBUG_MODE == 1)
      if (!(loc==size-1))
      {
        DEBUGPRINT_F(" ");
        DEBUGPRINT_HEX(data[loc]); 
      }
      else
      {
        DEBUGPRINT_F(" ");
        DEBUGPRINT_HEX(data[loc]);
      }
#endif
  }
  
  DEBUGPRINT_F("\n\r\tCC3000: SpiWriteDataSynchronous End\n\r");
}