Ejemplo n.º 1
0
/**
 * @brief	Reads the STATUS register in the nRF24L01
 * @param	Device: The device to use
 * @retval	The status register
 */
uint8_t NRF24L01_GetStatus(NRF24L01_Device* Device)
{
	SELECT_DEVICE(Device);
	uint8_t status = SPI_WriteRead(Device->SPIDevice, NOP);
	DESELECT_DEVICE(Device);

	return status;
}
Ejemplo n.º 2
0
/**
 * @brief
 * @param	Device: The device to use
 * @retval	None
 */
void NRF24L01_ReadRegister(NRF24L01_Device* Device, uint8_t Register, uint8_t* Buffer, uint8_t BufferSize)
{
	SELECT_DEVICE(Device);
	uint8_t status = SPI_WriteRead(Device->SPIDevice, R_REGISTER | Register);

	/* R_REGISTER command only have 5 data bytes, datasheet page 51 */
	if (BufferSize > 5)
		BufferSize = 5;

	/* LSByte first, datasheet page 50 */
	for (int32_t i = BufferSize-1; i >= 0; i--)
	{
		Buffer[i] = SPI_WriteRead(Device->SPIDevice, NOP);
	}
	DESELECT_DEVICE(Device);
}
Ejemplo n.º 3
0
/**
 * @brief
 * @param	Device: The device to use
 * @retval	None
 */
void NRF24L01_WriteRegister(NRF24L01_Device* Device, uint8_t Register, uint8_t* Buffer, uint8_t BufferSize)
{
	DISABLE_DEVICE(Device);	 /* W_REGISTER is executable in power down or standby modes only */
	SELECT_DEVICE(Device);
	uint8_t status = SPI_WriteRead(Device->SPIDevice, W_REGISTER | Register);

	/* W_REGISTER command only have 5 data bytes, datasheet page 51 */
	if (BufferSize > 5)
		BufferSize = 5;

	/* LSByte first, datasheet page 50 */
	for (int32_t i = BufferSize-1; i >= 0; i--)
	{
		/* Have to do WriteRead for some reason, otherwise one byte will be lost */
		status = SPI_WriteRead(Device->SPIDevice, Buffer[i]);
	}
	DESELECT_DEVICE(Device);
	ENABLE_DEVICE(Device);
}
Ejemplo n.º 4
0
bool HMC5883L::readRawAxis()
{
	SELECT_DEVICE(*fd, HMC5883L_ADDRESS, deviceName);
    
//	readBlockData(*fd, HMC5883L_DATA_REGISTER_BEGIN, 6, u8Buffer);

	readReg8( *fd, 0x03, &iBuffer[ 0 ]);
	readReg8( *fd, 0x04, &iBuffer[ 1 ]);
	readReg8( *fd, 0x05, &iBuffer[ 2 ]);
	readReg8( *fd, 0x06, &iBuffer[ 3 ]);
	readReg8( *fd, 0x07, &iBuffer[ 4 ]);
	readReg8( *fd, 0x08, &iBuffer[ 5 ]);
   
  	raw.XAxis = (int)(int16_t) ((iBuffer[0] << 8) | iBuffer[1]);
  	raw.ZAxis = (int)(int16_t) ((iBuffer[2] << 8) | iBuffer[3]);
  	raw.YAxis = (int)(int16_t) ((iBuffer[4] << 8) | iBuffer[5]);
    
  	return true;
}
Ejemplo n.º 5
0
/**
 * @brief	Get data from the RX buffer
 * @param	Device: The device to use
 * @param	Storage: Pointer to where the data should be stored
 * @retval	The amount of data received
 */
uint8_t NRF24L01_GetDataFromRxBuffer(NRF24L01_Device* Device, uint8_t* Buffer)
{
	SELECT_DEVICE(Device);
	SPI_WriteRead(Device->SPIDevice, R_RX_PAYLOAD);
	uint8_t dataCount = SPI_WriteRead(Device->SPIDevice, NOP);

	/*
	 * Only get the maximum amount of data which can be stored in one payload (MAX_DATA_COUNT)
	 * When dataCount was used as a limit we got a hardfault because there is no control if
	 * dataCount is > MAX_DATA_COUNT and the data where Buffer exist might become corrupt
	 */
	for (uint32_t i = 0; i < MAX_DATA_COUNT; i++)
	{
		Buffer[i] = SPI_WriteRead(Device->SPIDevice, NOP);
	}
	DESELECT_DEVICE(Device);

	/*
	 * Flush just in case
	 */
	NRF24L01_FlushRxBuffer(Device);

	return dataCount;
}
Ejemplo n.º 6
0
/**
 * @brief	Write data and send it to the address specified in TX_ADDR
 * @param	Device: The device to use
 * @param	Data: Pointer to where the data is stored
 * @param	ByteCount: The number of bytes in Data
 * @retval	None
 */
ErrorStatus NRF24L01_WritePayload(NRF24L01_Device* Device, uint8_t* Data, uint8_t DataCount)
{
	/* You can only send the amount of data specified in MAX_DATA_COUNT */
	if (DataCount > MAX_DATA_COUNT)
		return ERROR;

	/* Try to take the semaphore */
	if (xSemaphoreTake(Device->xTxSemaphore, 100 / portTICK_PERIOD_MS) == pdTRUE)
	{
		/* Semaphore was taken so we can proceed with sending new data */
		DISABLE_DEVICE(Device);				/* Disable the device while sending data to TX buffer */
		NRF24L01_PowerUpInTxMode(Device);	/* Power up in TX mode */
		NRF24L01_FlushTxBuffer(Device);		/* Flush the TX buffer */

		SELECT_DEVICE(Device);

		SPI_WriteRead(Device->SPIDevice, W_TX_PAYLOAD);	/* We want to write the TX payload */
		SPI_WriteRead(Device->SPIDevice, DataCount);	/* Write the data count */
		uint32_t i;
		for (i = 0; i < DataCount; i++)
		{
			SPI_WriteRead(Device->SPIDevice, Data[i]);	/* Write the data */
		}
		for (i++; i <= MAX_DATA_COUNT; i++)
		{
			SPI_WriteRead(Device->SPIDevice, PAYLOAD_FILLER_DATA);	/* Fill the rest of the payload with filler data */
		}

		DESELECT_DEVICE(Device);
	    ENABLE_DEVICE(Device);

	    return SUCCESS;
	}
	else
		return ERROR;
}
Ejemplo n.º 7
0
/**
 * @brief	Flush the RX Buffer
 * @param	Device: The device to use
 * @retval	None
 */
void NRF24L01_FlushRxBuffer(NRF24L01_Device* Device)
{
	SELECT_DEVICE(Device);
	SPI_WriteRead(Device->SPIDevice, FLUSH_RX);
	DESELECT_DEVICE(Device);
}
Ejemplo n.º 8
0
bool HMC5883L::setScale(float gauss)
{
	__u8 regValue = 0x00;
	
	SELECT_DEVICE(*fd, HMC5883L_ADDRESS, deviceName);
	
	if(gauss == 0.88f)
	{				
		regValue 	= 0x00;
		scale 		= 0.73f;
	}
	
	else if(gauss == 1.3f)
	{
		regValue 	= 0x01;
		scale 		= 0.92f;
	}
	
	else if(gauss == 1.9f)
	{
		regValue 	= 0x02;
		scale 		= 1.22;
	}
	
	else if(gauss == 2.5f)
	{
		regValue 	= 0x03;
		scale 		= 1.52f;
	}
	
	else if(gauss == 4.0f)
	{
		regValue 	= 0x04;
		scale 		= 2.27f;
	}
	
	else if(gauss == 4.7f)
	{
		regValue 	= 0x05;
		scale 		= 2.56f;
	}
	
	else if(gauss == 5.6f)
	{
		regValue 	= 0x06;
		scale 		= 3.03f;
	}
	
	else if(gauss == 8.1f)
	{
		regValue 	= 0x07;
		scale 		= 4.35f;
	}
	
	else {
		printf("Switching to default scale values in %s\n", deviceName );
		
		regValue 	= 0x01;
		scale 		= 0.92f;
	}
	
	// Setting is in the top 3 bits of the register.
	regValue = regValue << 5;
		
	return writeReg8(*fd, HMC5883L_CONFIGURATION_REGISTER_B, regValue);
}
Ejemplo n.º 9
0
bool HMC5883L::setMeasurementMode(__u8 mode) 
{
	SELECT_DEVICE(*fd, HMC5883L_ADDRESS, deviceName);
	
	return writeReg8(*fd, HMC5883L_MODE_REGISTER, mode);//writeByte(*fd, HMC5883L_MODE_REGISTER, mode);
}