int8_t spi_transfer_block(const uint8_t *out_buf, uint8_t *in_buf, uint16_t len)
{
uint16_t i;
if (in_buf && out_buf) {
for (i = 0; i < len; i++) {
in_buf[i] = spi_transfer(out_buf[i]);
}
}
else if (!in_buf && out_buf) {
for (i = 0; i < len; i++) {
spi_transfer(out_buf[i]);
}
}
else if (in_buf && !out_buf) {
for (i = 0; i < len; i++) {
in_buf[i] = spi_transfer(0xff);
}
}
else if (!in_buf && !out_buf) {
/* No in or out buffer; just move the clock line. */
for (i = 0; i < len; i++) {
spi_transfer(0xff);
}
}
return 0;
}
void OSD::ClosePanel(void)
{
spi_transfer(MAX7456_DMDI_reg);
spi_transfer(MAX7456_END_string); //This is needed "trick" to finish auto increment
DeSelect();;
row++; //only after finish the auto increment the new row will really act as desired
}
void spi_write_eeprom(unsigned int addr, unsigned char data_in)
{
unsigned char temp;
EE_NCS = 0;
delay1();
spi_transfer(WRITE_ENABLE);
EE_NCS = 1;
delay_us(300);
EE_NCS = 0;
delay1();
if((addr & 0x0100) == 0x0100)
{
temp = (WRITE_DATA | 0x08);
}
else
{
temp = WRITE_DATA;
}
spi_transfer(temp);
delay1();
spi_transfer((unsigned char)addr);
delay1();
spi_transfer(data_in);
delay1();
EE_NCS = 1;
}
// Checks if MAX_RT has been reached
uint8_t mirf_max_rt_reached(void) {
mirf_CSN_lo; // Pull down chip select
spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));
uint8_t status = spi_transfer(NOP); // Read status register
mirf_CSN_hi; // Pull up chip select
return status & (1<<MAX_RT);
}
// Sends a data package to the default address. Be sure to send the correct
// amount of bytes as configured as payload on the receiver.
void nrf24_send(uint8_t* value)
{
/* Go to Standby-I first */
nrf24_ce_digitalWrite(LOW);
/* Set to transmitter mode , Power up if needed */
nrf24_powerUpTx();
/* Do we really need to flush TX fifo each time ? */
#if 1
/* Pull down chip select */
nrf24_csn_digitalWrite(LOW);
/* Write cmd to flush transmit FIFO */
spi_transfer(NRF24L01P_CMD_FLUSH_TX, 1);
/* Pull up chip select */
nrf24_csn_digitalWrite(HIGH);
#endif
/* Pull down chip select */
nrf24_csn_digitalWrite(LOW);
/* Write cmd to write payload */
spi_transfer(NRF24L01P_CMD_W_TX_PAYLOAD, 0);
/* Write payload */
nrf24_transmitSync(value,payload_len);
/* Pull up chip select */
nrf24_csn_digitalWrite(HIGH);
/* Start the transmission */
nrf24_ce_digitalWrite(HIGH);
}
// Checks if data is available for reading
uint8_t mirf_data_ready(void) {
mirf_CSN_lo; // Pull down chip select
spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));
uint8_t status = spi_transfer(NOP); // Read status register
mirf_CSN_hi; // Pull up chip select
return status & (1<<RX_DR);
}
void cmd_spirom_id() {
unsigned long recv1;
unsigned short recv2;
// spi_init();
spi_set_port(SPI_PORT_NONE); // CSを自分で制御する
spi_set_bit_order(SPI_MSBFIRST);
gpio_set_pinmode(SPI_ROM_PORT,1);
gpio_write_port(SPI_ROM_PORT,0); // CSを下げる
spi_set_bit_length(8);
spi_transfer(0x9f); // コマンド送信
spi_set_bit_length(24);
recv1 = spi_transfer(0) & 0xffffff;
printf("SPI ROM JEDEC ID=%08lx, ",recv1);
// gpio_write_port(SPI_ROM_PORT,1); // CSを上げる
gpio_write_port(SPI_ROM_PORT,0); // CSを下げる
spi_set_bit_length(32);
recv2 = spi_transfer(0x90000000) & 0xffff; // コマンド送信
printf("ID=%04x\n",recv2);
gpio_write_port(SPI_ROM_PORT,1); // CSを上げる
gpio_set_pinmode(SPI_ROM_PORT,0);
// spi_terminate();
}
void xhide(void)
{
spi_transfer(low_byte(400));
spi_transfer(high_byte(400));
spi_transfer(low_byte(400));
spi_transfer(high_byte(400));
//spr++;
}
void wr16(unsigned int addr, unsigned int v)
{
__wstart(addr);
spi_transfer(low_byte(v));
spi_transfer(high_byte(v));
__end();
}
unsigned char accel_read(unsigned char address) {
unsigned char result;
pin_clear(&ACCEL_CS);
spi_transfer(&spi1, (address&0x3F)<<1);
result = spi_transfer(&spi1, 0x00);
pin_set(&ACCEL_CS);
return result;
}
unsigned char gyro_read(unsigned char address) {
unsigned char result;
pin_clear(&GYRO_CS);
spi_transfer(&spi1, 0x80|(address&0x3F));
result = spi_transfer(&spi1, 0x00);
pin_set(&GYRO_CS);
return result;
}
//null args for some cmd's
void sd_send_null_args(void)
{
spi_transfer(0x00);
spi_transfer(0x00);
spi_transfer(0x00);
spi_transfer(0x00);
spi_transfer(0x95);
}
static void nrf24_write_reg(uint8_t addr, uint8_t value) {
nrf24_csn(0);
spi_transfer(addr | W_REGISTER);
spi_transfer(value);
nrf24_csn(1);
}
uint8_t rx_fifo_empty() {
uint8_t status = 0x00;
NRF_CS_LOW;
spi_transfer(FIFO_STATUS);
status = spi_transfer(0);
NRF_CS_HIGH;
return (status & (1 << RX_EMPTY));
}
/*! \fn int spi_write(int pin, uint8_t reg, uint8_t data)
* \brief Write 8 address bits to an spi device then writes 8 data bits to the spi device
* @param[in] pin the chipselect pin to toggle
* @param[in] reg the address bits to send to the spi device
* @param[in] the data to send to the spi device
* \return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned
*/
int spi_write(int pin, uint8_t reg, uint8_t data)
{
int ret = spi_begin(pin);
if (ret < 0)
return ret;
spi_transfer(reg);
spi_transfer(data);
return spi_end();
}
/*! \fn int spi_read(int pin, uint8_t reg, uint8_t *data)
* \brief Write 8 address bits to an spi device then read 8 bits from spi device
* @param[in] pin the chipselect pin to toggle
* @param[in] reg the address bits to send to the spi device
* @param[out] the data the spi device sent back
* \return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned
*/
int spi_read(int pin, uint8_t reg, uint8_t *data)
{
int ret = spi_begin(pin);
if (ret < 0)
return ret;
spi_transfer(reg|0x80);
*data = spi_transfer(0);
return spi_end();
}
/* Returns the length of data waiting in the RX fifo */
uint8_t nrf24_payloadLength()
{
uint8_t status;
nrf24_csn_digitalWrite(LOW);
spi_transfer(NRF24L01P_CMD_R_RX_PL_WID, 0);
status = spi_transfer(0x00, 1);
nrf24_csn_digitalWrite(HIGH);
return status;
}
void can_w_bit(uint8_t addr, uint8_t mask, uint8_t val)
{
CAN_CS_LOW;
spi_transfer(MCP2515_SPI_BITMOD);
spi_transfer(addr);
spi_transfer(mask);
spi_transfer(val);
CAN_CS_HIGH;
}
void spi_setRegister(
uint8_t reg,
uint8_t value)
{
nrf24_csn_digitalWrite(LOW);
spi_transfer(W_REGISTER | (REGISTER_MASK & reg));
spi_transfer(value);
nrf24_csn_digitalWrite(HIGH);
}
/* Returns the length of data waiting in the RX fifo */
uint8_t nrf24_payloadLength()
{
uint8_t status;
nrf24_csn_digitalWrite(LOW);
spi_transfer(R_RX_PL_WID);
status = spi_transfer(0x00);
nrf24_csn_digitalWrite(HIGH);
return status;
}
static int rtc_get_temperature(void)
{
CS_ON();
spi_transfer(RTC_TEMPERATURE | RTC_READ);
uint8_t data = spi_transfer(0);
CS_OFF();
return map(data, 0, 250, -60, 190);
}
uint8_t spi_read_auto(uint8_t address)
{
uint8_t response;
SPI_CS_LOW
spi_transfer(address | 0x80);
response = spi_transfer(0xFF);
SPI_CS_HIGH
return response;
}
uint8_t spi_write_auto(uint8_t address,uint8_t data)
{
uint8_t response;
SPI_CS_LOW
spi_transfer(address);
response = spi_transfer(data);
SPI_CS_HIGH
return response;
}
static void cmd_write_flash(const char *filename)
{
FILE *fd;
// maximum hexfile data per line is 255, plus 3 bytes for cmd and addr
uint8_t buffer[255 + 3] = {0};
uint8_t orig[255 + 3] = {0};
uint8_t comp[255 + 3] = {0};
int count;
uint16_t address;
if (check_rdismb()) {
fprintf(stderr, "flash memory is protected\n");
exit(EXIT_FAILURE);
}
disable_infen();
fd = fopen(filename, "r");
if (!fd) {
fprintf(stderr, "can't open %s to read\n", filename);
exit(EXIT_FAILURE);
}
while ((count = hexfile_getline(fd, &address, buffer + 3,
sizeof(buffer) - 3)) > 0) {
enable_wen();
memcpy(orig, buffer + 3, count);
buffer[0] = PROGRAM;
buffer[1] = address >> 8;
buffer[2] = address & 0xff;
printf("writing %i bytes at 0x%04hx...\n", count, address);
if (!spi_transfer(buffer, count + 3)) {
fprintf(stderr, "SPI error\n");
fclose(fd);
exit(EXIT_FAILURE);
}
wait_ready();
comp[0] = READ;
comp[1] = address >> 8;
comp[2] = address & 0xff;
if (!spi_transfer(comp, count + 3)) {
fprintf(stderr, "SPI error\n");
fclose(fd);
exit(EXIT_FAILURE);
}
if (memcmp(orig, comp + 3, count)) {
fprintf(stderr, "error checking memory\n");
fclose(fd);
exit(EXIT_FAILURE);
}
}
fclose(fd);
}
// Flush RX and TX FIFO
void mirf_flush_rx_tx(void) {
mirf_CSN_lo; // Pull down chip select
spi_transfer(FLUSH_RX); // Flush RX
mirf_CSN_hi; // Pull up chip select
mirf_CSN_lo; // Pull down chip select
spi_transfer(FLUSH_TX); // Write cmd to flush tx fifo
mirf_CSN_hi; // Pull up chip select
}
/* send multiple bytes over SPI */
void nrf24_transmitSync(uint8_t* dataout,uint8_t len)
{
uint8_t i;
for(i=0;i<len-1;i++)
{
spi_transfer(dataout[i], 0);
}
spi_transfer(dataout[len-1], 1);
}
/* send and receive multiple bytes over SPI */
void nrf24_transferSync(uint8_t* dataout,uint8_t* datain,uint8_t len)
{
uint8_t i;
for(i=0;i<len-1;i++)
{
datain[i] = spi_transfer(dataout[i], 0);
}
datain[len-1] = spi_transfer(dataout[len-1], 1);
}
uint8_t can_spi_query(uint8_t cmd)
{
uint8_t ret;
CAN_CS_LOW;
spi_transfer(cmd);
ret = spi_transfer(0xFF);
CAN_CS_HIGH;
return ret;
}
static void nrf24_write_addr_reg(uint8_t addr, uint8_t value[3]) {
nrf24_csn(0);
spi_transfer(addr | W_REGISTER);
spi_transfer(value[0]);
spi_transfer(value[1]);
spi_transfer(value[2]);
nrf24_csn(1);
}
void write_register(char register_name, char register_value)
{
register_name <<= 2;
register_name |= B00000010; //Write command
digitalWrite(SLAVESELECT,LOW); //Select SPI device
spi_transfer(register_name); //Send register location
spi_transfer(register_value); //Send value to record into register
digitalWrite(SLAVESELECT,HIGH);
}
