Example #1
0
/**@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);
}
Example #2
0
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);
		}
	}
}
Example #3
0
/** 
 * \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
}
Example #4
0
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);
		}
	}
}
Example #6
0
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
}
Example #10
0
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);
	}
}
Example #11
0
// *****************************************************************************
// 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;
}
Example #12
0
File: sd.c Project: EUA/libmuc
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();
    }
}
Example #14
0
// 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);
}
Example #15
0
File: main.c Project: JulianYG/WNR
/**@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);
}
Example #16
0
/**
* \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;
}
Example #17
0
/**@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);    
}
Example #18
0
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();	
   

}	
Example #20
0
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);
	}
Example #21
0
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");
}
Example #22
0
/**
* \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);
}
Example #23
0
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);
  }
}
Example #24
0
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;
 }
Example #26
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;
}
Example #27
0
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);
}
Example #29
0
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);
}
Example #30
0
/**@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);
        }
    }
}