static void lcd_display_off_seq(void)
{
spi_write_reg(0xb, 0x30e1);
spi_write_reg(0x7, 0x102);
wait_nr_frames(2);
spi_write_reg(0x7, 0);
spi_write_reg(0x12, 0);
spi_write_reg(0x10, 0x100);
}
/* initialize the accelerometer */
void initializeAccelerometer( ) {
// initialize SPI
spi_init();
// send a soft reset to the accelerometer
uint8_t data[1] = {RESET_CODE};
spi_write_reg(SOFT_RESET, data, 1);
//wait for device to be reset
for (int i = 0; i < 100; i++);
// the accel_init function only configs the 0x2D reg, no others
// SO, configure the rest of the accelerometer settings before
// doing the power control register (which turns measurment on)
// (0x20 - 0x26 regs)
config_accelerometer();
// configure interrupts to be off, default mode (for now) - (0x27 reg)
adxl362_config_interrupt_mode( adxl362_INTERRUPT_DEFAULT, 0, 0 );
// configure FIFO mode to be off so we sample in real-time (0x28, 0x29 regs)
adxl362_config_FIFO( adxl362_DISABLE_FIFO, 0, 0 );
// setup data ready interrupt to int pin 1 (maps data ready status to int1 pin)
// (0x2A, 0x2B registers)
adxl362_interrupt_map_t dataReadyIntMap;
memset(&dataReadyIntMap, 0, sizeof dataReadyIntMap);
dataReadyIntMap.DATA_READY = true;
adxl362_config_INTMAP(&dataReadyIntMap, true);
// set measurement range to 2G (0x2C reg)
adxl362_config_measurement_range( adxl362_MEAS_RANGE_2G );
// initialize accel to measurement mode (with normal noise levels)
//adxl362_accelerometer_init( adxl362_NOISE_NORMAL, 1, 0, 0 );
// DOING IT MANUALLY SO SOFTRESET NOT DONE AT END:
data[0] = MEASUREMENT_MODE;
data[0] = data[0] | (adxl362_NOISE_NORMAL << 4);
spi_write_reg(POWER_CTL, data, 1);
// RANDOM STUFF:
//adxl362_activity_inactivity_interrupt_enable();
// read X axis to clear data ready interrupt
// readAxisX();
}
void ss_unit_spi(void)
{
cu_print("#######################################\n");
cu_print("# Purpose of SS SPI tests : #\n");
cu_print("# BME280 is connected to ss spi0 #\n");
cu_print("# 1 - Read BME280 ID #\n");
cu_print("# 2 - Write BME280 registers #\n");
cu_print("#######################################\n");
init_spi((struct sba_master_cfg_data*)(pf_bus_sba_ss_spi_0.priv),
SPI_SE_1, SPI_BUSMODE_0, 0);
cu_print("read register\n");
spi_read_reg(SPI_SENSING_0, ID_REG, 0x60);
cu_print("write register\n");
spi_write_reg(SPI_SENSING_0, CTRL_MEAS, 0x08);
spi_read_reg(SPI_SENSING_0, CTRL_MEAS, 0x08);
cu_print("write word register\n");
spi_write_word_reg(SPI_SENSING_0, CTRL_MEAS, 0x4004);
cu_print("read word register\n");
spi_read_word_reg(SPI_SENSING_0, CTRL_MEAS, 0x4004);
cu_print("read block\n");
transfer_block_spi(SPI_SENSING_0);
ss_spi_deconfig((struct sba_master_cfg_data*)(pf_bus_sba_ss_spi_0.priv));
}
static void lcd_display_on_seq(void)
{
spi_write_reg(0x7, 1);
wait_nr_frames(1);
spi_write_reg(0x7, 0x101);
wait_nr_frames(2);
spi_write_reg(0x76, 0x2213);
spi_write_reg(0x1c, 0x6650);
spi_write_reg(0xb, 0x33e1);
spi_write_reg(0x76, 0);
spi_write_reg(0x7, 0x103);
}
static void lcd_power_seq(void)
{
spi_write_reg(0x7, 0);
mdelay(10);
spi_write_reg(0x12, 0x1618);
spi_write_reg(0x11, 0x2227);
spi_write_reg(0x13, 0x61d1);
spi_write_reg(0x10, 0x550c);
wait_nr_frames(5);
spi_write_reg(0x12, 0x0c58);
}
int atlas_reg_write (int reg, unsigned int value)
{
return (spi_write_reg (reg, &value));
}
static void lcd_init_seq(void)
{
/* NOTE I don't understand why I have to use BGR, logic would say I should not */
spi_write_reg(0x1, 0x2b1d);// inversion
spi_write_reg(0x2, 0x300);
/* NOTE by default stmp3700 has vsync/hsync active low and data launch
* at negative edge of dotclk, reflect this in the polarity settings */
spi_write_reg(0x3, 0xd040);// polarity (OF uses 0xc040, seems incorrect)
spi_write_reg(0x8, 0); // vsync back porch (0=3H)
spi_write_reg(0x9, 0); // hsync back porhc (0=24clk)
spi_write_reg(0x76, 0x2213);
spi_write_reg(0xb, 0x33e1);
spi_write_reg(0xc, 0x23);
spi_write_reg(0x76, 0);
spi_write_reg(0xd, 7);
spi_write_reg(0xe, 0);
spi_write_reg(0x15, 0x803);
spi_write_reg(0x14, 0);
spi_write_reg(0x16, 0);
spi_write_reg(0x30, 0x706);
spi_write_reg(0x31, 0x406);
spi_write_reg(0x32, 0xc09);
spi_write_reg(0x33, 0x606);
spi_write_reg(0x34, 0x706);
spi_write_reg(0x35, 0x406);
spi_write_reg(0x36, 0xc06);
spi_write_reg(0x37, 0x601);
spi_write_reg(0x38, 0x504);
spi_write_reg(0x39, 0x504);
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Initialize the OLED display and write status.
//
//
// Enable the peripherals used by this example.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//PC5,PC7 EN,CSN
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE,1<<5|1<<7);
//SPI配置
unsigned long ulDataTx[NUM_SSI_DATA];
unsigned long ulDataRx[NUM_SSI_DATA];
unsigned long ulindex;
unsigned long ultemp=0;
SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA2_SSI0CLK);
GPIOPinConfigure(GPIO_PA3_SSI0FSS);
GPIOPinConfigure(GPIO_PA4_SSI0RX);
GPIOPinConfigure(GPIO_PA5_SSI0TX);
GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 |
GPIO_PIN_2);
SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, 4000000, 8);
/*
GPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_DIR_MODE_OUT);
GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_STRENGTH_4MA,
GPIO_PIN_TYPE_STD_WPU);
GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_0 , GPIO_STRENGTH_4MA,
GPIO_PIN_TYPE_STD_WPU);
*/
SSIEnable(SSI0_BASE);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Set GPIO A0 and A1 as UART pins.
//
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//
// Prompt for text to be entered.
//
UARTStdioInit(0);
UARTSend((unsigned char *)"Enter text:\n\r", 12);
UARTSend((unsigned char *)"Enter text:\n\r", 12);
//清零接收缓冲区
while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0]))
{
}
ulDataTx[0] = 's';
ulDataTx[1] = 'p';
ulDataTx[2] = 'i';
set_nrf24l01_csn_l();
/*
for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)
{
UARTprintf("'%c' ", ulDataTx[ulindex]);
SSIDataPut(SSI0_BASE, ulDataTx[ulindex]);
}
*/
set_nrf24l01_csn_h();
_delay_ms(1);
if( setDataRate( RF24_250KBPS ) )
{
p_variant = true ;
}
//初始化NRF24L01
set_module_tx();
nrf_write_reg(NRF_CONFIG,0x0a);
print_byte_register("CONFIG\t",NRF_CONFIG,1);
init_NRF24L01();
set_module_tx();
unsigned char transfer_value[]="EEWORLD_MSP430_00";
//set_module_tx();
//读不出来spi数据的原因是,原来里面有没读取完的数据,需要先清理,再读写.
setChannel(74);
UARTprintf("getchannel:%d\r\n",getChannel());
// setChannel(24);
// UARTprintf("getchannel:%d\r\n",getChannel());
//写地址
nrf_write_buf(TX_ADDR,(uint8_t*)&addresses[0],5);
uint8_t recvbuf[5];
nrf_read_buf(TX_ADDR,&recvbuf[0],5);
for(int i=0;i<5;i++)
{
UARTprintf("%d:%d ",i,recvbuf[i]);
}
UARTprintf("\r\n");
//end of test write address
uint8_t data[32];
for(int i=0;i<32;i++)
{
data[i]=i;
}
UARTprintf("\r\n");
//while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0]))
//{
//}
//重新发送前,避免写缓冲区满
flush_tx();
spi_write_reg(STATUS, ( spi_read_reg(STATUS) ) | _BV(MAX_RT) );
//role=role_ping_out
openWritingPipe(addresses[0]);
openReadingPipe(1,addresses[1]);
nrf_write_buf(RX_ADDR_P0,(uint8_t*)&addresses[0],5);
unsigned char test;
//while(1)
{
test=spi_read_reg(0x05);
UARTprintf("test:%d\r\n",test);
_delay_ms(1000);
}
//调试关闭
//nrf_write_reg(EN_AA,0x00);
nrf_write_reg(EN_RXADDR,0x02);
//nrf_write_reg(SETUP_RETR,0x00);
nrf_write_reg(RX_PW_P1,0x20);
//set_module_tx();
nrf_write_reg(NRF_CONFIG,0x0b);
nrf_write_reg(CONFIG, nrf_read_reg(CONFIG) | _BV(PRIM_RX));
nrf_write_reg(STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
set_nrf24l01_ce_h();
nrf_write_buf(RX_ADDR_P0,(uint8_t*)&addresses[0],5);
set_nrf24l01_ce_h();
if(nrf_read_reg(FEATURE) & _BV(EN_ACK_PAY))
{
flush_tx();
}
flush_rx();
print_status(get_status());
nrf_write_reg(SETUP_AW,0x03);
print_byte_register("SETUP_AW\t",SETUP_AW,1);
print_address_register("RX_ADDR_P0-1",RX_ADDR_P0,2);
print_byte_register("RX_ADDR_P2-5",RX_ADDR_P2,4);
print_address_register("TX_ADDR\t",TX_ADDR,1);
print_byte_register("RX_PW_P0-6",RX_PW_P0,6);
print_byte_register("EN_AA\t",EN_AA,1);
print_byte_register("EN_RXADDR",EN_RXADDR,1);
print_byte_register("RF_CH\t",RF_CH,1);
print_byte_register("RF_SETUP",RF_SETUP,1);
print_byte_register("CONFIG\t",NRF_CONFIG,1);
print_byte_register("DYNPD/FEATURE",DYNPD,2);
UARTprintf("Data Rate\t = %s\r\n", pgm_read_word(&rf24_datarate_e_str_P[getDataRate()]));
UARTprintf("Model\t\t = %s\r\n", pgm_read_word(&rf24_model_e_str_P[isPVariant()]));
UARTprintf("CRC Length\t = %s\r\n",pgm_read_word(&rf24_crclength_e_str_P[getCRCLength()]));
UARTprintf("PA Power\t = %s\r\n", pgm_read_word(&rf24_pa_dbm_e_str_P[getPALevel()]));
Init_Timer_A();
set_nrf24l01_ce_h();
//将业务数据写入:WR_TX_PLOAD
uint8_t fifo_status,status,state,i;
while(1)
{
fifo_status=spi_read_reg(FIFO_STATUS);
if(fifo_status&0x02)
{
status=spi_read_reg(STATUS);
if(status&_BV(RX_DR))
{
state=spi_send_byte(RD_RX_PLOAD);
for(i=0;i<RX_PLOAD_WIDTH;i++)
{
status=spi_send_byte(0xff);
//buf[i]=status;
}
nrf_write_reg(FLUSH_RX,0xFF);
//UARTprintf(".");
counter++;
}
if(status &0x02)
{
nrf_write_reg(FLUSH_RX,0xFF);
//UARTprintf(".");
counter++;
}
nrf_rx_packet(data);
}
}
while(available(0))
{
//UARTprintf(".");
if(nrf_rx_packet(data) == 0)
{
counter++;
}
//UARTprintf(".");
//_delay_ms(50);
/*
set_nrf24l01_ce_l();
nrf_write_buf(WR_TX_PLOAD,data,TX_PLOAD_WIDTH);
set_nrf24l01_ce_h();
_delay_ms(30);
*/
}
}
