/** * \internal * \brief Test initializing SPI master & slave. * * This initializes the SPI master & slave. * * Test passes if initialization succeeds fails otherwise. * * \param test Current test case. */ static void run_spi_init_test(const struct test_case *test) { enum status_code status = STATUS_ERR_IO; /* Structure for SPI configuration */ struct spi_config config; struct spi_slave_inst_config slave_config; /* Select SPI slave SS pin */ spi_slave_inst_get_config_defaults(&slave_config); slave_config.ss_pin = CONF_SPI_SLAVE_SS_PIN; spi_attach_slave(&slave_inst, &slave_config); /* Configure the SPI master */ spi_get_config_defaults(&config); config.mux_setting = CONF_SPI_MASTER_SPI_MUX; config.pinmux_pad0 = CONF_SPI_MASTER_DATA_IN_PIN_MUX; config.pinmux_pad1 = PINMUX_UNUSED; config.pinmux_pad2 = CONF_SPI_MASTER_DATA_OUT_PIN_MUX; config.pinmux_pad3 = CONF_SPI_MASTER_SCK_PIN_MUX; config.mode_specific.master.baudrate = TEST_SPI_BAUDRATE; status = spi_init(&master, CONF_SPI_MASTER_MODULE, &config); test_assert_true(test, status == STATUS_OK, "SPI master initialization failed"); /* Enable the SPI master */ spi_enable(&master); status = STATUS_ERR_IO; /* Configure the SPI slave */ spi_get_config_defaults(&config); config.mode = SPI_MODE_SLAVE; config.mux_setting = CONF_SPI_SLAVE_SPI_MUX; config.pinmux_pad0 = CONF_SPI_SLAVE_DATA_IN_PIN_MUX; config.pinmux_pad1 = CONF_SPI_SLAVE_SS_PIN_MUX; config.pinmux_pad2 = CONF_SPI_SLAVE_DATA_OUT_PIN_MUX; config.pinmux_pad3 = CONF_SPI_SLAVE_SCK_PIN_MUX; config.mode_specific.slave.frame_format = SPI_FRAME_FORMAT_SPI_FRAME; config.mode_specific.slave.preload_enable = true; status = spi_init(&slave, CONF_SPI_SLAVE_MODULE, &config); test_assert_true(test, status == STATUS_OK, "SPI slave initialization failed"); /* Enable the SPI slave */ spi_enable(&slave); if (status == STATUS_OK) { spi_init_success = true; } }
/** * \internal * \brief Setup function: Send & receive 9-bit data by polling. * * This function configures the SPI master & slave in 9-bit mode. * * \param test Current test case. */ static void setup_transfer_9bit_test(const struct test_case *test) { enum status_code status = STATUS_ERR_IO; spi_init_success = false; /* Structure for SPI configuration */ struct spi_config config; spi_disable(&master); spi_disable(&slave); /* Configure the SPI master */ spi_get_config_defaults(&config); config.mux_setting = CONF_SPI_MASTER_SPI_MUX; config.pinmux_pad0 = CONF_SPI_MASTER_DATA_IN_PIN_MUX; config.pinmux_pad1 = PINMUX_UNUSED; config.pinmux_pad2 = CONF_SPI_MASTER_DATA_OUT_PIN_MUX; config.pinmux_pad3 = CONF_SPI_MASTER_SCK_PIN_MUX; config.mode_specific.master.baudrate = TEST_SPI_BAUDRATE; config.character_size = SPI_CHARACTER_SIZE_9BIT; status = spi_init(&master, CONF_SPI_MASTER_MODULE, &config); test_assert_true(test, status == STATUS_OK, "SPI master initialization failed for 9-bit configuration"); /* Enable the SPI master */ spi_enable(&master); status = STATUS_ERR_IO; /* Configure the SPI slave */ spi_get_config_defaults(&config); config.mode = SPI_MODE_SLAVE; config.mux_setting = CONF_SPI_SLAVE_SPI_MUX; config.pinmux_pad0 = CONF_SPI_SLAVE_DATA_IN_PIN_MUX; config.pinmux_pad1 = CONF_SPI_SLAVE_SS_PIN_MUX; config.pinmux_pad2 = CONF_SPI_SLAVE_DATA_OUT_PIN_MUX; config.pinmux_pad3 = CONF_SPI_SLAVE_SCK_PIN_MUX; config.mode_specific.slave.frame_format = SPI_FRAME_FORMAT_SPI_FRAME; config.mode_specific.slave.preload_enable = true; config.character_size = SPI_CHARACTER_SIZE_9BIT; status = spi_init(&slave, CONF_SPI_SLAVE_MODULE, &config); test_assert_true(test, status == STATUS_OK, "SPI slave initialization failed for 9-bit configuration"); /* Enable the SPI slave */ spi_enable(&slave); if (status == STATUS_OK) { spi_init_success = true; } }
/** * \brief Initialize EDBG SPI communication for SAM0 * */ bool adp_interface_init(void) { enum status_code return_value; system_init(); struct spi_slave_inst_config slave_dev_config; struct spi_config config; spi_slave_inst_get_config_defaults(&slave_dev_config); slave_dev_config.ss_pin = EDBG_SPI_SS_PIN; spi_attach_slave(&slave, &slave_dev_config); spi_get_config_defaults(&config); config.mode_specific.master.baudrate = 1000000; config.mux_setting = EDBG_SPI_SERCOM_MUX_SETTING; config.pinmux_pad0 = EDBG_SPI_SERCOM_PINMUX_PAD0; config.pinmux_pad1 = PINMUX_UNUSED; config.pinmux_pad2 = EDBG_SPI_SERCOM_PINMUX_PAD2; config.pinmux_pad3 = EDBG_SPI_SERCOM_PINMUX_PAD3; return_value = spi_init(&edbg_spi, EDBG_SPI, &config); spi_enable(&edbg_spi); return return_value; }
void sd_mmc_spi_init(void) { sd_mmc_spi_err = SD_MMC_SPI_NO_ERR; // Initialize card detect pin struct port_config pin_conf; port_get_config_defaults(&pin_conf); // Set card detect pin as inputs pin_conf.direction = PORT_PIN_DIR_INPUT; pin_conf.input_pull = PORT_PIN_PULL_UP; port_pin_set_config(SD_MMC_0_CD_GPIO, &pin_conf); // Initialize SPI interface and enable it struct spi_config config; spi_get_config_defaults(&config); config.mux_setting = SD_MMC_SPI_PINMUX_SETTING; config.pinmux_pad0 = SD_MMC_SPI_PINMUX_PAD0; config.pinmux_pad1 = SD_MMC_SPI_PINMUX_PAD1; config.pinmux_pad2 = SD_MMC_SPI_PINMUX_PAD2; config.pinmux_pad3 = SD_MMC_SPI_PINMUX_PAD3; config.generator_source = SD_MMC_SPI_SOURCE_CLOCK; config.mode_specific.master.baudrate = SDMMC_CLOCK_INIT; spi_init(&sd_mmc_master, SD_MMC_SPI, &config); spi_enable(&sd_mmc_master); spi_slave_inst_get_config_defaults(&slave_configs[0]); slave_configs[0].ss_pin = ss_pins[0]; spi_attach_slave(&sd_mmc_spi_devices[0], &slave_configs[0]); }
/** * \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) { struct spi_config config; struct spi_slave_inst_config slave_config; spi_slave_inst_get_config_defaults(&slave_config); slave_config.ss_pin = SSD1306_CS_PIN; spi_attach_slave(&ssd1306_slave, &slave_config); spi_get_config_defaults(&config); config.mux_setting = SSD1306_SPI_PINMUX_SETTING; config.pinmux_pad0 = SSD1306_SPI_PINMUX_PAD0; config.pinmux_pad1 = SSD1306_SPI_PINMUX_PAD1; config.pinmux_pad2 = SSD1306_SPI_PINMUX_PAD2; config.pinmux_pad3 = SSD1306_SPI_PINMUX_PAD3; config.mode_specific.master.baudrate = SSD1306_CLOCK_SPEED; spi_init(&ssd1306_master, SSD1306_SPI, &config); spi_enable(&ssd1306_master); struct port_config pin; port_get_config_defaults(&pin); pin.direction = PORT_PIN_DIR_OUTPUT; port_pin_set_config(SSD1306_DC_PIN, &pin); port_pin_set_config(SSD1306_RES_PIN, &pin); }
/** * \internal * \brief Initialize the hardware interface. */ static void ksz8851snl_interface_init(void) { struct spi_config config; struct spi_slave_inst_config slave_config; spi_slave_inst_get_config_defaults(&slave_config); slave_config.ss_pin = KSZ8851SNL_CS_PIN; spi_attach_slave(&ksz8851snl_slave, &slave_config); spi_get_config_defaults(&config); config.mux_setting = KSZ8851SNL_SPI_PINMUX_SETTING; config.pinmux_pad0 = KSZ8851SNL_SPI_PINMUX_PAD0; config.pinmux_pad1 = KSZ8851SNL_SPI_PINMUX_PAD1; config.pinmux_pad2 = KSZ8851SNL_SPI_PINMUX_PAD2; config.pinmux_pad3 = KSZ8851SNL_SPI_PINMUX_PAD3; config.mode_specific.master.baudrate = KSZ8851SNL_CLOCK_SPEED; spi_init(&ksz8851snl_master, KSZ8851SNL_SPI, &config); spi_enable(&ksz8851snl_master); /* Configure RSTN pin. */ struct port_config pin; port_get_config_defaults(&pin); pin.direction = PORT_PIN_DIR_OUTPUT; port_pin_set_config(KSZ8851SNL_RSTN_PIN, &pin); }
/*============================================================================== hal_spiInit() =============================================================================*/ void * hal_spiInit(void) { //! [slave_config] struct spi_slave_inst_config st_slaveDevConf; //! [slave_config] //! [master_config] struct spi_config st_masterConf; //! [master_config] /* Configure and initialize software device instance of peripheral slave */ //! [slave_conf_defaults] spi_slave_inst_get_config_defaults(&st_slaveDevConf); //! [slave_conf_defaults] //! [ss_pin] st_slaveDevConf.ss_pin = st_ss; //! [ss_pin] //! [slave_init] spi_attach_slave(&st_spi, &st_slaveDevConf); //! [slave_init] /* Configure, initialize and enable SERCOM SPI module */ //! [conf_defaults] spi_get_config_defaults(&st_masterConf); //! [conf_defaults] //! [mux_setting] st_masterConf.mux_setting = SAMD20_SPI0_SERCOM_MUX_SETTING; //! [mux_setting] /* Configure pad 0 for data in */ //! [di] st_masterConf.pinmux_pad0 = SAMD20_SPI0_SERCOM_PMUX0; //! [di] /* Configure pad 1 as unused */ //! [ss] st_masterConf.pinmux_pad1 = PINMUX_UNUSED; //! [ss] /* Configure pad 2 for data out */ //! [do] st_masterConf.pinmux_pad2 = SAMD20_SPI0_SERCOM_PMUX2; //! [do] /* Configure pad 3 for SCK */ //! [sck] st_masterConf.pinmux_pad3 = SAMD20_SPI0_SERCOM_PMUX3; //! [sck] //! [init] spi_init(&st_masterInst, SAMD20_SPI0_SERCOM, &st_masterConf); //! [init] //! [enable] spi_enable(&st_masterInst); //! [enable] return ((void *)&st_spi); } /* hal_spiInit() */
//! [configure_spi] void configure_spi_master(void) { //! [config] struct spi_config config_spi_master; //! [config] //! [slave_config] struct spi_slave_inst_config slave_dev_config; //! [slave_config] /* Configure and initialize software device instance of peripheral slave */ //! [slave_conf_defaults] spi_slave_inst_get_config_defaults(&slave_dev_config); //! [slave_conf_defaults] //! [ss_pin] slave_dev_config.ss_pin = SLAVE_SELECT_PIN; //! [ss_pin] //! [slave_init] spi_attach_slave(&slave, &slave_dev_config); //! [slave_init] /* Configure, initialize and enable SERCOM SPI module */ //! [conf_defaults] spi_get_config_defaults(&config_spi_master); //! [conf_defaults] //! [mux_setting] config_spi_master.mux_setting = EXT1_SPI_SERCOM_MUX_SETTING; //! [mux_setting] /* Configure pad 0 for data in */ //! [di] config_spi_master.pinmux_pad0 = EXT1_SPI_SERCOM_PINMUX_PAD0; //! [di] /* Configure pad 1 as unused */ //! [ss] config_spi_master.pinmux_pad1 = PINMUX_UNUSED; //! [ss] /* Configure pad 2 for data out */ //! [do] config_spi_master.pinmux_pad2 = EXT1_SPI_SERCOM_PINMUX_PAD2; //! [do] /* Configure pad 3 for SCK */ //! [sck] config_spi_master.pinmux_pad3 = EXT1_SPI_SERCOM_PINMUX_PAD3; //! [sck] //! [init] spi_init(&spi_master_instance, EXT1_SPI_MODULE, &config_spi_master); //! [init] //! [enable] spi_enable(&spi_master_instance); //! [enable] }
/* * @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 /* Initialize config structure and software module. */ struct i2c_master_config config_i2c_master; i2c_master_get_config_defaults(&config_i2c_master); /* Change buffer timeout to something longer. */ config_i2c_master.buffer_timeout = 1000; /* Initialize and enable device with config. */ i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master); i2c_master_enable(&i2c_master_instance); #elif defined CONF_WINC_USE_SPI /* Structure for SPI configuration. */ struct spi_config config; struct spi_slave_inst_config slave_config; /* Select SPI slave CS pin. */ /* This step will set the CS high */ spi_slave_inst_get_config_defaults(&slave_config); slave_config.ss_pin = CONF_WINC_SPI_CS_PIN; spi_attach_slave(&slave_inst, &slave_config); /* Configure the SPI master. */ spi_get_config_defaults(&config); config.mux_setting = CONF_WINC_SPI_SERCOM_MUX; config.pinmux_pad0 = CONF_WINC_SPI_PINMUX_PAD0; config.pinmux_pad1 = CONF_WINC_SPI_PINMUX_PAD1; config.pinmux_pad2 = CONF_WINC_SPI_PINMUX_PAD2; config.pinmux_pad3 = CONF_WINC_SPI_PINMUX_PAD3; config.master_slave_select_enable = false; config.mode_specific.master.baudrate = CONF_WINC_SPI_CLOCK; if (spi_init(&master, CONF_WINC_SPI_MODULE, &config) != STATUS_OK) { return M2M_ERR_BUS_FAIL; } /* Enable the SPI master. */ spi_enable(&master); nm_bsp_reset(); nm_bsp_sleep(1); #endif return result; }
/*======================================================================*/ void spi_configureLED( void ) { struct spi_config config_led_spi; spi_get_config_defaults(&config_led_spi); config_led_spi.mode_specific.master.baudrate = SPI_BAUDRATE; config_led_spi.mux_setting = LED_SPI_SERCOM_MUX_SETTING; config_led_spi.pinmux_pad0 = LED_SPI_SERCOM_PINMUX_PAD0; config_led_spi.pinmux_pad1 = LED_SPI_SERCOM_PINMUX_PAD1; config_led_spi.pinmux_pad2 = LED_SPI_SERCOM_PINMUX_PAD2; config_led_spi.pinmux_pad3 = LED_SPI_SERCOM_PINMUX_PAD3; spi_init(&spi_instanceLED, LED_SPI_MODULE, &config_led_spi); spi_enable(&spi_instanceLED); }
//! [configure_spi] void configure_spi_slave(void) { //! [config] struct spi_config config_spi_slave; //! [config] /* Configure, initialize and enable SERCOM SPI module */ //! [conf_defaults] spi_get_config_defaults(&config_spi_slave); //! [conf_defaults] //! [conf_spi_slave_instance] config_spi_slave.mode = SPI_MODE_SLAVE; //! [conf_spi_slave_instance] //! [conf_preload] config_spi_slave.mode_specific.slave.preload_enable = true; //! [conf_preload] //! [conf_format] config_spi_slave.mode_specific.slave.frame_format = SPI_FRAME_FORMAT_SPI_FRAME; //! [conf_format] //! [mux_setting] config_spi_slave.mux_setting = EXT1_SPI_SERCOM_MUX_SETTING; //! [mux_setting] /* Configure pad 0 for data in */ //! [di] config_spi_slave.pinmux_pad0 = EXT1_SPI_SERCOM_PINMUX_PAD0; //! [di] /* Configure pad 1 as unused */ //! [ss] config_spi_slave.pinmux_pad1 = EXT1_SPI_SERCOM_PINMUX_PAD1; //! [ss] /* Configure pad 2 for data out */ //! [do] config_spi_slave.pinmux_pad2 = EXT1_SPI_SERCOM_PINMUX_PAD2; //! [do] /* Configure pad 3 for SCK */ //! [sck] config_spi_slave.pinmux_pad3 = EXT1_SPI_SERCOM_PINMUX_PAD3; //! [sck] //! [init] spi_init(&spi_slave_instance, EXT1_SPI_MODULE, &config_spi_slave); //! [init] //! [enable] spi_enable(&spi_slave_instance); //! [enable] }
/** * \internal * \brief Test: Sends data at different baud rates. * * This test sends (writes) a byte to the slave and receives the data * at different baudrate testing up to the maximum allowed level. * * Transmission and reception are carried out by polling. * * \param test Current test case. */ static void run_baud_test(const struct test_case *test) { uint32_t test_baud = 1000000; uint8_t txd_data = 0x55; uint8_t rxd_data = 0; bool max_baud = true; /* Skip test if initialization failed */ test_assert_true(test, spi_init_success, "Skipping test due to failed initialization"); /* Structure for SPI configuration */ struct spi_config config; /* Configure the SPI master */ spi_get_config_defaults(&config); config.mux_setting = CONF_SPI_MASTER_SPI_MUX; config.pinmux_pad0 = CONF_SPI_MASTER_DATA_IN_PIN_MUX; config.pinmux_pad1 = PINMUX_UNUSED; config.pinmux_pad2 = CONF_SPI_MASTER_DATA_OUT_PIN_MUX; config.pinmux_pad3 = CONF_SPI_MASTER_SCK_PIN_MUX; do { spi_disable(&master); config.mode_specific.master.baudrate = test_baud; spi_init(&master, CONF_SPI_MASTER_MODULE, &config); spi_enable(&master); /* Send data to slave */ spi_select_slave(&master, &slave_inst, true); spi_write_buffer_wait(&master, &txd_data, 1); spi_read_buffer_wait(&slave, &rxd_data, 1, 0); spi_select_slave(&master, &slave_inst, false); if (txd_data != rxd_data) { max_baud = false; break; } test_baud += 1000000; } while (test_baud <= 24000000); /* Output the result */ test_assert_true(test, max_baud, "Test failed at baudrate: %lu", test_baud); }
//! [configure_spi] void configure_spi_slave(void) { //! [config] struct spi_config config_spi_slave; //! [config] /* Configure, initialize and enable SPI module */ //! [conf_defaults] spi_get_config_defaults(&config_spi_slave); //! [conf_defaults] //! [conf_spi_slave_instance] config_spi_slave.mode = SPI_MODE_SLAVE; //! [conf_spi_slave_instance] //! [transfer_mode] config_spi_slave.transfer_mode = CONF_SPI_TRANSFER_MODE; //! [transfer_mode] /* Configure pad 0 */ //! [sck] config_spi_slave.pin_number_pad[0] = CONF_SPI_PIN_SCK; config_spi_slave.pinmux_sel_pad[0] = CONF_SPI_MUX_SCK; //! [sck] /* Configure pad 1 */ //! [mosi] config_spi_slave.pin_number_pad[1] = CONF_SPI_PIN_MOSI; config_spi_slave.pinmux_sel_pad[1] = CONF_SPI_MUX_MOSI; //! [mosi] /* Configure pad 2 */ //! [ssn] config_spi_slave.pin_number_pad[2] = CONF_SPI_PIN_SSN; config_spi_slave.pinmux_sel_pad[2] = CONF_SPI_MUX_SSN; //! [ssn] /* Configure pad 3 */ //! [miso] config_spi_slave.pin_number_pad[3] = CONF_SPI_PIN_MISO; config_spi_slave.pinmux_sel_pad[3] = CONF_SPI_MUX_MISO; //! [miso] //! [init] spi_init(&spi_slave_instance, CONF_SPI, &config_spi_slave); //! [init] //! [enable] spi_enable(&spi_slave_instance); //! [enable] }
/*---------------------------------------------------------------------------*/ void esd_spi_master_init(void) { if (!initialized) { struct spi_config config_spi_master; spi_get_config_defaults(&config_spi_master); config_spi_master.mode_specific.master.baudrate = ESD_SPI_BAUDRATE; config_spi_master.mux_setting = ESD_SPI_SERCOM_MUX_SETTING; config_spi_master.pinmux_pad0 = ESD_SPI_SERCOM_PINMUX_PAD0; config_spi_master.pinmux_pad1 = ESD_SPI_SERCOM_PINMUX_PAD1; config_spi_master.pinmux_pad2 = ESD_SPI_SERCOM_PINMUX_PAD2; config_spi_master.pinmux_pad3 = ESD_SPI_SERCOM_PINMUX_PAD3; spi_init(&esd_spi_master_instance, ESD_SPI_MODULE, &config_spi_master); spi_enable(&esd_spi_master_instance); INFO("ESD SPI master interface initialized"); initialized = true; } }
void configure_spi_master_ADXL(void) { struct spi_config config_spi_master_adxl; struct spi_slave_inst_config slave_dev_config_adxl; spi_slave_inst_get_config_defaults(&slave_dev_config_adxl); slave_dev_config_adxl.ss_pin = PIN_PA06; slave_dev_config_adxl.address_enabled = false; spi_attach_slave(&slave_ADXL, &slave_dev_config_adxl); spi_get_config_defaults(&config_spi_master_adxl); config_spi_master_adxl.mux_setting = SPI_SIGNAL_MUX_SETTING_D; config_spi_master_adxl.pinmux_pad0 = PINMUX_PA04D_SERCOM0_PAD0; config_spi_master_adxl.pinmux_pad1 = PINMUX_PA05D_SERCOM0_PAD1; config_spi_master_adxl.pinmux_pad2 = PINMUX_UNUSED; config_spi_master_adxl.pinmux_pad3 = PINMUX_PA07D_SERCOM0_PAD3; config_spi_master_adxl.mode = SPI_MODE_MASTER; config_spi_master_adxl.data_order = SPI_DATA_ORDER_MSB; config_spi_master_adxl.transfer_mode = SPI_TRANSFER_MODE_3; config_spi_master_adxl.character_size = SPI_CHARACTER_SIZE_8BIT; config_spi_master_adxl.run_in_standby = false; config_spi_master_adxl.receiver_enable = true; config_spi_master_adxl.generator_source = GCLK_GENERATOR_2; config_spi_master_adxl.mode_specific.master.baudrate = 4000000; config_spi_master_adxl.master_slave_select_enable = true; config_spi_master_adxl.select_slave_low_detect_enable = false; spi_init(&spi_master_instance_ADXL, SERCOM0, &config_spi_master_adxl); spi_enable(&spi_master_instance_ADXL); }
/** * \brief Function for configuring SPI slave module * * This function will configure the SPI slave module with * the SERCOM module to be used and pinmux settings */ static void configure_spi(void) { /* Create and initialize config structure */ struct spi_config config_spi; spi_get_config_defaults(&config_spi); /* Change SPI settings to slave */ config_spi.mode = SPI_MODE_SLAVE; config_spi.mux_setting = BOOT_SPI_MUX; config_spi.mode_specific.slave.preload_enable = true; config_spi.mode_specific.slave.frame_format = SPI_FRAME_FORMAT_SPI_FRAME; config_spi.pinmux_pad0 = BOOT_SPI_PAD0; config_spi.pinmux_pad1 = BOOT_SPI_PAD1; config_spi.pinmux_pad2 = BOOT_SPI_PAD2; config_spi.pinmux_pad3 = BOOT_SPI_PAD3; /* Initialize and enable device with config */ spi_init(&slave, BOOT_SERCOM, &config_spi); spi_enable(&slave); }
void cph_deca_spi_init(void) { struct spi_config config_spi_master; struct spi_slave_inst_config slave_dev_config; spi_slave_inst_get_config_defaults(&slave_dev_config); slave_dev_config.ss_pin = DW_SPI_SS_PIN; spi_attach_slave(&spi_slave, &slave_dev_config); spi_get_config_defaults(&config_spi_master); // DOPO: 0x00 DIPO: 0x03 // PA16/SERCOM1[0]: MOSI PA19/SERCOM1[]3: MISO config_spi_master.mux_setting = DW_SPI_MUX; config_spi_master.pinmux_pad0 = DW_SPI_PAD0; config_spi_master.pinmux_pad1 = DW_SPI_PAD1; config_spi_master.pinmux_pad2 = DW_SPI_PAD2; config_spi_master.pinmux_pad3 = DW_SPI_PAD3; config_spi_master.transfer_mode = DW_SPI_TRANSFER_MODE; spi_init(&spi_master_instance, DW_SPI_HW, &config_spi_master); spi_enable(&spi_master_instance); }
void configure_spi_master_AD5421(void) { //! [config] struct spi_config config_spi_master; //! [config] //! [slave_config] struct spi_slave_inst_config slave_dev_config; //! [slave_config] /* Configure and initialize software device instance of peripheral slave */ //! [slave_conf_defaults] spi_slave_inst_get_config_defaults(&slave_dev_config); //! [slave_conf_defaults] //! [ss_pin] slave_dev_config.ss_pin = PIN_PA18; slave_dev_config.address_enabled = false; //! [ss_pin] //! [slave_init] spi_attach_slave(&slave_AD5421, &slave_dev_config); //! [slave_init] /* Configure, initialize and enable SERCOM SPI module */ //! [conf_defaults] spi_get_config_defaults(&config_spi_master); //! [conf_defaults] //! [mux_setting] config_spi_master.mux_setting = SPI_SIGNAL_MUX_SETTING_D; //! [mux_setting] /* Configure pad 0 for MOSI */ //! [di] config_spi_master.pinmux_pad0 = PINMUX_PA16D_SERCOM3_PAD0; //! [di] /* Configure pad 1 for CLOCK */ //! [ss] config_spi_master.pinmux_pad1 = PINMUX_PA17D_SERCOM3_PAD1; //! [ss] /* Configure pad 2 for CS */ //! [do] config_spi_master.pinmux_pad2 = PINMUX_UNUSED; //! [do] /* Configure pad 3 for MISO */ //! [sck] config_spi_master.pinmux_pad3 = PINMUX_PA19D_SERCOM3_PAD3; //! [sck] config_spi_master.mode = SPI_MODE_MASTER; config_spi_master.data_order = SPI_DATA_ORDER_MSB; config_spi_master.transfer_mode = SPI_TRANSFER_MODE_2; config_spi_master.character_size = SPI_CHARACTER_SIZE_8BIT; config_spi_master.run_in_standby = false; config_spi_master.receiver_enable = true; config_spi_master.generator_source = GCLK_GENERATOR_2; config_spi_master.mode_specific.master.baudrate = 1000000; config_spi_master.master_slave_select_enable = true; config_spi_master.select_slave_low_detect_enable = false; //! [init] spi_init(&spi_master_instance_AD5421, SERCOM3, &config_spi_master); //! [init] //! [enable] spi_enable(&spi_master_instance_AD5421); //! [enable] }