/**@brief Function for executing and switching state. * */ static void switch_state(void) { switch (m_spi_master_ex_state) { #ifdef SPI_MASTER_0_ENABLE case TEST_STATE_SPI0_LSB: spi_master_init(SPI_MASTER_0, spi_master_0_event_handler, true); spi_send_recv(SPI_MASTER_0, m_tx_data_spi, m_rx_data_spi, TX_RX_MSG_LENGTH); m_spi_master_ex_state = TEST_STATE_SPI0_MSB; break; case TEST_STATE_SPI0_MSB: spi_master_init(SPI_MASTER_0, spi_master_0_event_handler, false); spi_send_recv(SPI_MASTER_0, m_tx_data_spi, m_rx_data_spi, TX_RX_MSG_LENGTH); #ifdef SPI_MASTER_1_ENABLE m_spi_master_ex_state = TEST_STATE_SPI1_LSB; #else m_spi_master_ex_state = TEST_STATE_SPI0_LSB; #endif /* SPI_MASTER_1_ENABLE */ break; #endif /* SPI_MASTER_0_ENABLE */ #ifdef SPI_MASTER_1_ENABLE case TEST_STATE_SPI1_LSB: spi_master_init(SPI_MASTER_1, spi_master_1_event_handler, true); spi_send_recv(SPI_MASTER_1, m_tx_data_spi, m_rx_data_spi, TX_RX_MSG_LENGTH); m_spi_master_ex_state = TEST_STATE_SPI1_MSB; break; case TEST_STATE_SPI1_MSB: spi_master_init(SPI_MASTER_1, spi_master_1_event_handler, false); spi_send_recv(SPI_MASTER_1, m_tx_data_spi, m_rx_data_spi, TX_RX_MSG_LENGTH); #ifdef SPI_MASTER_0_ENABLE m_spi_master_ex_state = TEST_STATE_SPI0_LSB; #else m_spi_master_ex_state = TEST_STATE_SPI1_LSB; #endif /* SPI_MASTER_0_ENABLE */ break; #endif /* SPI_MASTER_1_ENABLE */ default: break; } nrf_delay_ms(DELAY_MS); }
void main(void){ uint8_t i; spi_master_init(); pwm_dac_init(); mux_init_io(); usart_midi_init(BAUD_PRESCALE); midi_event_stage = event_match; midi_set_listen_event(&midi_listen_event, 0b1001); midi_set_listen_channel(&midi_listen_event, 8); note_offset = 24; //sei(); velocity_list[5] = 0xff; while(1){ _delay_ms(20); spi_transmit_word(0x0); /* To clean it. This is just for debugging! Wont be in final releas. */ // mux_scan_buffer(); for(i = 0; i < MAX_VOICES; i++){ mux_sample(i, 0xff); } } }
/** * \brief Initialize SPI external resource for AT25DFx SerialFlash driver. * * This function initializes the SerialFlash component as well as the SPI service that * the memory is connected to. * \pre The conf_at25dfx.h file should provide the following information: * - Selection of the SPI service the SerialFlash is connected * (AT25DFX_USES_SPI_MASTER_SERVICE or AT25DFX_USES_USART_SPI_SERVICE). * - AT25DFX_MEM_SIZE: The SerialFlash type that the driver is connected to. * - AT25DFX_MEM_CNT: The number of SerialFlash components (number of chipselect). * - AT25DFX_SPI_MODULE: The name of the SPI module used by the SerialFlash driver. * - AT25DFX_SPI_MASTER_SPEED: The SPI bus speed. */ void at25dfx_spi_init(void) { #if defined( AT25DFX_USES_SPI_MASTER_SERVICE) spi_master_init(AT25DFX_SPI_MODULE); #if (AT25DFX_MEM_CNT==1) spi_master_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE1,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>1) spi_master_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE2,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>2) spi_master_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE3,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>3) spi_master_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE4,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif spi_enable(AT25DFX_SPI_MODULE); /* Implementation with USART in SPI mode service */ #elif defined(AT25DFX_USES_USART_SPI_SERVICE) usart_spi_init(AT25DFX_SPI_MODULE); #if (AT25DFX_MEM_CNT==1) usart_spi_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE1,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>1) usart_spi_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE2,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>2) usart_spi_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE3,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #if (AT25DFX_MEM_CNT>3) usart_spi_setup_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE4,SPI_MODE_0,AT25DFX_SPI_MASTER_SPEED,0); #endif #endif }
int acc_init() { // Use SPI0, mode0 with lsb shifted as requested PLACE AT TOP volatile uint32_t counter = 0; spi_ba = spi_master_init(SPI0, SPI_MODE3, false); if (spi_ba == 0) { return -1; } //Put the ADXL345 into StandBy Mode by writing 0x00 // to the POWER_CTL register. write_register(ADXL345_POWER_CTL, 0x00); //Standby mode //Put the ADXL345 into +/- 4G range by writing the value 0x01 // to the DATA_FORMAT register. write_register(ADXL345_DATA_FORMAT, 0x00); // set up sampling rate of 50Hz write_register(ADXL345_BW_RATE, 0x09); fifo_init(); int_init(); //Put the ADXL345 into Measurement Mode by writing 0x08 // to the POWER_CTL register. write_register(ADXL345_POWER_CTL, 0x08); //Measurement mode return 0; }
/*! \brief Main function. */ int main(void) { sysclk_init(); /* Initialize the board. * The board-specific conf_board.h file contains the configuration of * the board initialization. */ board_init(); spi_master_init(SPI_EXAMPLE); spi_master_setup_device(SPI_EXAMPLE, &SPI_DEVICE_EXAMPLE, SPI_MODE_0, SPI_EXAMPLE_BAUDRATE, 0); spi_enable(SPI_EXAMPLE); status = spi_at45dbx_mem_check(); while (true) { if (status==false) { gpio_set_pin_low(SPI_EXAMPLE_LED_PIN_EXAMPLE_1); gpio_set_pin_high(SPI_EXAMPLE_LED_PIN_EXAMPLE_2); } else { gpio_set_pin_low(SPI_EXAMPLE_LED_PIN_EXAMPLE_1); gpio_set_pin_low(SPI_EXAMPLE_LED_PIN_EXAMPLE_2); } } }
uint32_t ads7843_init(void) { volatile uint32_t uDummy; struct spi_device ADS7843_SPI_DEVICE_CFG = { // Board specific chip select configuration #ifdef BOARD_ADS7843_SPI_NPCS .id = BOARD_ADS7843_SPI_NPCS #else #warning The board TouchScreen chip select definition is missing. Default configuration is used. .id = 0 #endif }; spi_master_init(BOARD_ADS7843_SPI_BASE); spi_master_setup_device(BOARD_ADS7843_SPI_BASE, &ADS7843_SPI_DEVICE_CFG, SPI_MODE_0, ADS7843_SPI_BAUDRATE, 0); spi_enable(BOARD_ADS7843_SPI_BASE); for (uDummy = 0; uDummy < 100000; uDummy++) { } ads7843_send_cmd(CMD_ENABLE_PENIRQ); return 0; } /// @cond 0 /**INDENT-OFF**/ #ifdef __cplusplus }
/* * @fn nm_bus_init * @brief Initialize the bus wrapper * @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure */ sint8 nm_bus_init(void *pvinit) { sint8 result = M2M_SUCCESS; #ifdef CONF_WINC_USE_I2C /* Not implemented */ #elif defined CONF_WINC_USE_SPI /* Configure pins */ ioport_configure_pin(CONF_WIFI_M2M_SPI_CS_PIN, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); ioport_configure_pin(CONF_WIFI_M2M_SPI_MOSI_PIN, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); ioport_configure_pin(CONF_WIFI_M2M_SPI_MISO_PIN, IOPORT_DIR_INPUT); ioport_configure_pin(CONF_WIFI_M2M_SPI_SCK_PIN, IOPORT_INIT_LOW | IOPORT_DIR_OUTPUT); struct spi_device spi_device_conf; spi_device_conf.id = CONF_WIFI_M2M_SPI_CS_PIN; /* Configure the SPI master. */ spi_master_init(CONF_WIFI_M2M_SPI_MODULE); spi_master_setup_device(CONF_WIFI_M2M_SPI_MODULE, &spi_device_conf, SPI_MODE_0, CONF_WIFI_M2M_SPI_BAUDRATE, 0); /* Enable the SPI master. */ spi_enable(CONF_WIFI_M2M_SPI_MODULE); nm_bsp_reset(); nm_bsp_sleep(1); #endif return result; }
/** * \brief Initialize the USB interface and the DataFlash block driver. * * This function will initialize the SPI master, an SPI device, an USB * configuration and an USB interface. These instances are then used to setup * the DataFlash device, create a block device and eventually share the block * device through the USB mass-storage interface. */ void dataflash_init(struct app_usb_mode_task *usb_mode_task) { struct udm_config *config; struct udm_interface *iface; struct block_device *bdev; struct spi_master *master = spi_master_get_base(SPI_ID, &usb_mode_task->master); struct spi_device *device = spi_device_get_base(SPI_ID, &usb_mode_task->device); config = udm_create_config(1, 1); spi_enable(SPI_ID); spi_master_init(SPI_ID, master); spi_master_setup_device(SPI_ID, master, device, SPI_MODE_0, CONFIG_CPU_HZ, BOARD_DATAFLASH_SS); bdev = dataflash_blkdev_init(SPI_ID, master, device, &usb_mode_task->task); udm_config_set_bus_powered(config); udm_config_set_max_power(config, 42); iface = udi_msc_create_iface(bdev); udm_config_add_interface(config, iface); }
/** * \internal * \brief Initialize the hardware interface * * Depending on what interface used for interfacing the OLED controller this * function will initialize the necessary hardware. */ static void ssd1306_interface_init(void) { #ifdef SSD1306_SERIAL_INTERFACE spi_flags_t spi_flags = SPI_MODE_0; board_spi_select_id_t spi_select_id = 0; #endif #if defined(SSD1306_USART_SPI_INTERFACE) struct usart_spi_device device = { .id = SSD1306_CS_PIN, }; usart_spi_init(SSD1306_USART_SPI); usart_spi_setup_device(SSD1306_USART_SPI, &device, spi_flags, SSD1306_CLOCK_SPEED, spi_select_id); #elif defined(SSD1306_SPI_INTERFACE) struct spi_device device = { .id = SSD1306_CS_PIN, }; spi_master_init(SSD1306_SPI); spi_master_setup_device(SSD1306_SPI, &device, spi_flags, SSD1306_CLOCK_SPEED, spi_select_id); #ifdef SAM spi_enable(SSD1306_SPI); #endif #endif }
int main() { DDRB |= _BV(PB3); pwm_fast_init(2); spi_master_init(USI_PORTA); // Enable pullups on button inputs PORTA |= 1 << B_DOWN; PORTA |= 1 << B_UP; uint8_t ton = 0x40; uint8_t timer = 0; pwm_set_period(0xFF); pwm_set_on_b(ton); while(1) { if ((PINA & (1 << B_UP)) == 0) { pwm_set_on_b(ton++); } if ((PINA & (1 << B_DOWN)) == 0) { pwm_set_on_b(ton--); } if (timer++ == 1000 / LOOP_DELAY) { spi_master_write(ton); timer = 0; } _delay_ms(50); } }
// ***************************************************************************** // SPI platform interface uint32_t platform_spi_setup( uint8_t id, int mode, unsigned cpol, unsigned cpha, uint32_t clock_div ) { spi_master_init( id, cpol, cpha, clock_div ); // all platform functions assume LSB order for MOSI & MISO buffer spi_mast_byte_order( id, SPI_ORDER_LSB ); return 1; }
void sd_host_init(void) { spi_master_init(); /* SD CS = output */ DDR(SD_CS_PORT) |= (1 << SD_CS_IX); sd_cs_release(); }
/** * @brief Function for application main entry. */ int main(void) { nrf_gpio_cfg_output(SENSORS_ON); nrf_gpio_pin_set(SENSORS_ON); ble_stack_init(); // Initialize Bluetooth stack spi_base_addr = (uint32_t)spi_master_init(SPI0, SPI_MODE0, false); CC110L_setupspibaseaddr(spi_base_addr); setup_cc110l(); advertising_init(); // Start execution. PacketData_Update(); advertising_start(); TWI_init(); MPL3115A2_Init(); HDC1008_Init(); HDC1008_TriggerHumidity(); TWI_powerdown(); ble_radio_notification_init(3, NRF_RADIO_NOTIFICATION_DISTANCE_5500US, radio_notification_evt_handler); // Enter main loop. for (;;) { power_manage(); } }
// Initialize Pin and SPI like specified into config file void nrf24l01_init() { // Init SPI pins ioport_set_pin_dir(CONF_NRF24L01_SS_PIN, IOPORT_DIR_INPUT); ioport_set_pin_mode(CONF_NRF24L01_SS_PIN, IOPORT_MODE_PULLUP); ioport_set_pin_dir(CONF_NRF24L01_MOSI_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_mode(CONF_NRF24L01_MOSI_PIN, IOPORT_MODE_PULLUP); ioport_set_pin_high(CONF_NRF24L01_MOSI_PIN); ioport_set_pin_dir(CONF_NRF24L01_MISO_PIN, IOPORT_DIR_INPUT); ioport_set_pin_dir(CONF_NRF24L01_SCK_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_high(CONF_NRF24L01_SCK_PIN); // Init nrf24l01 pins ioport_set_pin_dir(CONF_NRF24L01_CE_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_dir(CONF_NRF24L01_CSn_PIN, IOPORT_DIR_OUTPUT); ioport_set_pin_dir(CONF_NRF24L01_IRQ_PIN, IOPORT_DIR_INPUT); ioport_set_pin_low(CONF_NRF24L01_CE_PIN); spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf); spi_master_init(&CONF_NRF24L01_SPI); spi_master_setup_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf, SPI_MODE_0, CONF_NRF24L01_CLOCK_SPEED, 0); spi_enable(&CONF_NRF24L01_SPI); // Wait nrf24l01 power on reset delay_ms(Tpor); nrf24l01_power_off(); // Reset registers to default state nrf24l01_write_register(NRF24L01_CONFIG_REG, NRF24L01_CONFIG_REG_DEF); nrf24l01_write_register(NRF24L01_STATUS_REG, NRF24L01_STATUS_REG_DEF); // TODO: reset all registers // Config parameters sets in CONF_NRF24L01 nrf24l01_set_power_amplifier(CONF_NRF24L01_PA); nrf24l01_set_data_rate(CONF_NRF24L01_DATA_RATE); nrf24l01_set_crc(CONF_NRF24L01_CRC); nrf24l01_set_addr_len(CONF_NRF24L01_ADDR_LEN); uint8_t nrf24l01_rx_addr[5] = { CONF_NRF24L01_RX_ADDR }; uint8_t nrf24l01_tx_addr[5] = { CONF_NRF24L01_TX_ADDR }; nrf24l01_set_rx_addr(nrf24l01_rx_addr); nrf24l01_set_tx_addr(nrf24l01_tx_addr); nrf24l01_write_register(NRF24L01_RF_CH_REG, CONF_NRF24L01_RF_CHANNEL); nrf24l01_write_register(NRF24L01_RX_PW_P0_REG, CONF_NRF24L01_PAYLOAD); nrf24l01_write_register(NRF24L01_RX_PW_P1_REG, CONF_NRF24L01_PAYLOAD); // Power-up (Power Down -> Standby-I) uint8_t configReg = nrf24l01_read_register(NRF24L01_CONFIG_REG); nrf24l01_write_register(NRF24L01_CONFIG_REG, configReg | NRF24L01_PWR_UP_BM); delay_us(Tpd2stby); }
/**@brief Function for executing and switching state. * */ static void switch_state(void) { nrf_drv_spi_t const * p_instance; p_instance = &m_spi_master_0; // check output of each function spi_master_init(p_instance, false); // false - MSB first spi_send_recv(p_instance, m_tx_data_spi, m_rx_data_spi , TX_MSG_LENGTH, RX_MSG_LENGTH); }
/** * \brief Initialize EDBG SPI communication for SAM * */ enum status_code adp_interface_init(void) { sysclk_init(); /* Configure the SPI interface */ spi_master_init(EDBG_SPI_MODULE); spi_master_setup_device(EDBG_SPI_MODULE, &SPI_DEVICE, SPI_MODE_0, SPI_BAUDRATE, 0); spi_enable(EDBG_SPI_MODULE); return STATUS_OK; }
/**@brief Function for executing a single SPI transaction. * * @retval true Operation success. * @retval false Operation failure. */ static bool test_spi_tx_rx(void) { uint8_t tx_data[TX_RX_BUF_LENGTH] = {0}; uint8_t rx_data[TX_RX_BUF_LENGTH] = {0}; uint32_t * p_spi_base_address = spi_master_init(SPI0, SPI_MODE0, true); if (p_spi_base_address == NULL) { return false; } return spi_master_tx_rx(p_spi_base_address, TX_RX_BUF_LENGTH, tx_data, rx_data); }
void sd_mmc_spi_init(void) { sd_mmc_spi_err = SD_MMC_SPI_NO_ERR; // Initialize SPI interface and enable it #if defined(SD_MMC_SPI_USES_USART_SPI_SERVICE) usart_spi_init(SD_MMC_SPI); #else if (!spi_is_enabled(SD_MMC_SPI)) { spi_master_init(SD_MMC_SPI); spi_enable(SD_MMC_SPI); } #endif }
////////////////////////////////////////////////////////////////////// //初始化SSD1306 void OLED_Init(void) { spi_base_address = spi_master_init(SPI0, SPI_MODE0, 0); if (spi_base_address == 0) { return ; } nrf_gpio_cfg_output(OLED_RST); // OLED Reset pin nrf_gpio_cfg_output(OLED_RS); // DC control pin OLED_RST_Set(); OLED_RST_Clr(); // delay_ms(100); nrf_delay_ms(100); OLED_RST_Set(); OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示 OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率 OLED_WR_Byte(80,OLED_CMD); //[3:0],分频因子;[7:4],震荡频率 OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数 OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64) OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移 OLED_WR_Byte(0X00,OLED_CMD); //默认为0 OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数. OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置 OLED_WR_Byte(0x14,OLED_CMD); //bit2,开启/关闭 OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式 OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00,列地址模式;01,行地址模式;10,页地址模式;默认10; OLED_WR_Byte(0xA1,OLED_CMD); //段重定义设置,bit0:0,0->0;1,0->127; OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数 OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置 OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置 OLED_WR_Byte(0x81,OLED_CMD); //对比度设置 //OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮) //OLED_WR_Byte(0xFF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮) OLED_WR_Byte(OLED_Contrast,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮) OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期 OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2; OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率 OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc; OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏) OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示 OLED_WR_Byte(0xAF,OLED_CMD); //开启显示 OLED_Clear(); }
int main(void) { DDRB |= _BV(PB3); DDRB |= _BV(PB0); // raw-pwm output spi_master_init(USI_PORTA); // Enable pullups on button inputs PORTA |= 1 << B_DOWN; PORTA |= 1 << B_UP; uint16_t timer = 0; pwm_fast_init(2); pwm_set_period(0xFF); pwm_set_on_b(ton); DDRA |= _BV(PA0); // Force Data in (MISO) to 0 // prescaler: 6 = div/64; fADC = 125kHz; 1 clockcycle = 8uS; 1 conversion=104uS adc_init(VREF_I2_56, 0x12, 6); // Configure timer0 TCCR0A = 0x00; TCCR0B = 0x01; // Enable counter without prescaling OCR0A = 0xFF; // compare at 0xFF TIMSK |= (1 << OCIE0A); // enable interrupt for compare0A sei(); while(1) { if (timer % 100 == 0) { if ((PINA & (1 << B_UP)) == 0 && pwm_t < BPWM_MAX) { pwm_t++; } if ((PINA & (1 << B_DOWN)) == 0 && pwm_t > BPWM_MIN) { pwm_t--; } } if (timer++ == 50000 / LOOP_DELAY) { spi_master_write(pwm_t >> 8); spi_master_write(pwm_t); spi_master_write(ton); spi_master_write((adc & 0xFF00) >> 8); spi_master_write(adc & 0x00FF); timer = 0; } _delay_us(LOOP_DELAY); }
void user_init(void) { os_printf("SDK version:%s\n", system_get_sdk_version()); os_printf("------------------start------------------\n\r"); set_data(); spi_master_init(HSPI); spi_mast_byte_write(HSPI,0xAA); spi_byte_write_espslave(HSPI,0xAA); spi_WR_espslave(HSPI); spi_WR_espslave(HSPI); os_printf("------------------done!------------------\n\r"); os_printf("\n\r"); os_printf("\n\r"); }
/** * \brief Configure SPI */ void epd_spi_init(void) { sysclk_enable_peripheral_clock(EPD_SPI_ID); gpio_configure_pin(EPD_SPI_MISO_PIN, EPD_SPI_MISO_MUX); ioport_disable_pin(EPD_SPI_MISO_PIN); // Disable IO (but enable peripheral mode) gpio_configure_pin(EPD_SPI_MOSI_PIN, EPD_SPI_MOSI_MUX); ioport_disable_pin(EPD_SPI_MOSI_PIN); // Disable IO (but enable peripheral mode) gpio_configure_pin(EPD_SPI_CLK_PIN, EPD_SPI_CLK_MUX); ioport_disable_pin(EPD_SPI_CLK_PIN); // Disable IO (but enable peripheral mode) gpio_configure_pin(EPD_SPI_SS_PIN, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); spi_master_init(EPD_SPI_ID); spi_master_setup_device(EPD_SPI_ID, &epd_device_conf, SPI_MODE_0, EPD_SPI_baudrate, 0); spi_enable(EPD_SPI_ID); delay_ms(5); }
int main(void) { int status; char buf[256]; uint8_t commandbyte; uint8_t responsebyte; cpu_init(DEFAULT_CPU_FREQ); #ifdef CONSOLE_SERIAL serial_stdio(CONSOLE_PORT); #endif #ifdef CONSOLE_SEMIHOSTING semihosting_stdio(CONSOLE_PORT) #endif #ifdef CONSOLE_USB usb_serial_stdio(NULL); getch(); #endif printf("\033[H\033[2J%s SPI Master Test (" __DATE__ " " __TIME__ ")\n\n", MCUFAMILYNAME); puts(revision); printf("\nCPU Freq:%u Hz Compiler:%s %s %s\n\n", (unsigned int) SystemCoreClock, __COMPILER__, __VERSION__, __ABI__); if ((status = spi_master_init(SPI_PORT, 8, 0, 281250, SPI_MSBFIRST))) { printf("ERROR: spi_master_init() failed at line %d, %s\n", status, strerror(errno)); exit(1); } for (;;) { printf("Enter a value to send: "); gets(buf); commandbyte = atoi(buf); if ((status = spi_master_transfer(SPI_PORT, &commandbyte, 1, &responsebyte, 1))) { printf("ERROR: spi_master_transfer() failed at line %d, %s\n", status, strerror(errno)); exit(1); } printf("Response was %02X\n\n", responsebyte); } }
void spi_task_init(void) { //enable the SPI interface in the Power Reduction register spi_master_init(SPI_USB); spi_master_setup_device(SPI_USB, &SPI_DEVICE_USB, SPI_MODE_0, SPI_USB_DEFAULT_BAUDRATE, 0); spi_enable(SPI_USB); /* THIS IS JUST FOR TESTING-DEBUGGING */ // return YES; }
void configure_spi() { SPI_Device_Memory = (struct spi_device *) pvPortMalloc( sizeof (struct spi_device) ); SPI_Device_Memory->id = SPI_DEVICE_MEMORY_CHIP_ID; SPI_Device_CC1120 = (struct spi_device *) pvPortMalloc( sizeof (struct spi_device) ); SPI_Device_CC1120->id = SPI_DEVICE_CC1120_CHIP_ID; spi_master_init(SPI0); spi_master_setup_device(SPI0, SPI_Device_Memory, POLARITY_FLAG, BAUD_RATE, 0); spi_master_setup_device(SPI0, SPI_Device_CC1120, POLARITY_FLAG, BAUD_RATE, 0); spi_enable(SPI0); // spi_enable_interrupt(SPI0, SPI_INTERRUPT_FLAGS); spi_buffer_index = 0; }
uint8_t knock_module_initialize(void) { uint8_t i, response; uint8_t init_data[2] = {KSP_SET_PRESCALER | KSP_PRESCALER_VALUE | KSP_SO_TERMINAL_ACTIVE, KSP_SET_CHANNEL | KSP_CHANNEL_0}; uint8_t _t; _t=_SAVE_INTERRUPT(); _DISABLE_INTERRUPT(); //Setting HOLD mode for integrator and "Run" mode for chip at all. SET_KSP_TEST(1); SET_KSP_INTHOLD(KNOCK_INTMODE_HOLD); SET_KSP_CS(1); spi_master_init(); ksp.ksp_interrupt_state = 0; //init state machine ksp.ksp_error = 0; //set prescaler first SET_KSP_CS(0); spi_master_transmit(init_data[0]); SET_KSP_CS(1); //Setting SO terminal active and perform initialization. For each parameter perform //checking for response and correcntess of received data. for(i = 0; i < 2; ++i) { SET_KSP_CS(0); spi_master_transmit(init_data[i]); SET_KSP_CS(1); response = SPDR; if (response!=init_data[i]) { _RESTORE_INTERRUPT(_t); return 0; //error - chip doesn't respond! } } _RESTORE_INTERRUPT(_t); //Initialization completed successfully return 1; }
void rf230_init(void) { //Setup SPI for Zigbee and Clear power reduction spi_master_init(SPI_ZIGBEE); //Setup SPI speed for Zigbee spi_master_setup_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE, SPI_MODE_0, SPI_ZIGBEE_DEFAULT_BAUDRATE, 0); spi_enable(SPI_ZIGBEE); radio_RF230_init(); turn_ON_CRC(); alarm_new(9, "CRC Started \0"); }
void Radio_Init() { transmit_lock = 0; // disable radio during config ioport_set_pin_low (CE); /* IRQ */ // Enable radio interrupt. This interrupt is triggered when data are received and when a transmission completes. ioport_configure_port_pin(&PORTC, PIN2_bm, IOPORT_PULL_UP | IOPORT_DIR_INPUT | IOPORT_SENSE_FALLING); PORTC.INT0MASK = PIN2_bm; PORTC.INTCTRL = PORT_INT0LVL_LO_gc; PMIC.CTRL |= PMIC_LOLVLEN_bm; /* CE */ ioport_configure_port_pin(&PORTC, PIN3_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); // A 10.3 ms delay is required between power off and power on states (controlled by 3.3 V supply). _delay_ms(11); /* Set up SPI */ /* Slave select */ ioport_configure_port_pin(&PORTC, PIN4_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); /* MOSI, MISO, SCK */ ioport_configure_port_pin(&PORTC, PIN5_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); ioport_configure_port_pin(&PORTC, PIN6_bm, IOPORT_DIR_INPUT); ioport_configure_port_pin(&PORTC, PIN7_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); spi_master_init(&SPID); spi_master_setup_device(&SPID, &spi_device_conf, SPI_MODE_0, 1000000, 0); spi_enable(&SPID); // Configure the radio registers that are not application-dependent. configure_registers(); // A 1.5 ms delay is required between power down and power up states (controlled by PWR_UP bit in CONFIG) _delay_ms(2); // enable radio as a receiver ioport_set_pin_high (CE); }
void spi_sensor_init(void) { uint8_t data_buffer[3] = {0x0, 0x0, 0x0}; spi_init_pins(); spi_master_init(&SPIC); spi_master_setup_device(&SPIC, &SPI_ADC, SPI_MODE_3, 500000, 0); spi_enable(&SPIC); spi_select_device(&SPIC, &SPI_ADC); spi_write_packet(&SPIC, resetdata, 5); //clock reg data_buffer[0] = 0x20; spi_write_packet(&SPIC, data_buffer, 1); //data_buffer[0] = 0x00; data_buffer[0] = clockreg; spi_write_packet(&SPIC, data_buffer, 1); //setup reg data_buffer[0] = 0x10; spi_write_packet(&SPIC, data_buffer, 1); //data_buffer[0] = 0x04; data_buffer[0] = setupreg; spi_write_packet(&SPIC, data_buffer, 1); //offset reg data_buffer[0] = 0x60; spi_write_packet(&SPIC, data_buffer, 1); data_buffer[0] = 0x18; data_buffer[1] = 0x3A; data_buffer[2] = 0x00; spi_write_packet(&SPIC, data_buffer, 3); //gain reg data_buffer[0] = 0x70; spi_write_packet(&SPIC, data_buffer, 1); data_buffer[0] = 0x89; data_buffer[1] = 0x78; data_buffer[2] = 0xD7; spi_write_packet(&SPIC, data_buffer, 3); spi_deselect_device(&SPIC, &SPI_ADC); }
/**@brief Function for application main entry. Does not return. */ int main(void) { // Setup bsp module. bsp_configuration(); uint32_t err_code = spi_master_init(); APP_ERROR_CHECK(err_code); // Register SPI master event handler. spi_master_evt_handler_reg(SPI_MASTER_HW, spi_master_event_handler); for (;;) { if (m_transfer_completed) { m_transfer_completed = false; // Set buffers and start data transfer. spi_send_recv(m_tx_data, m_rx_data, TX_RX_BUF_LENGTH); } } }