コード例 #1
0
ファイル: spi.c プロジェクト: J65mesW/RedPitaya
int main(void){

	/* Sample data */
	char *data = "REDPITAYA SPI TEST";

	/* Init the spi resources */
	if(init_spi() < 0){
		printf("Initialization of SPI failed. Error: %s\n", strerror(errno));
		return -1;
	}

	/* Write some sample data */
	if(write_spi(data, strlen(data)) < 0){
		printf("Write to SPI failed. Error: %s\n", strerror(errno));
		return -1;
	}

	/* Read flash ID and some sample loopback data */
	if(read_flash_id(spi_fd) < 0){
		printf("Error reading from SPI bus : %s\n", strerror(errno));
		return -1;
	}

	/* Release resources */
	if(release_spi() < 0){
		printf("Relase of SPI resources failed, Error: %s\n", strerror(errno));
		return -1;
	}

	return 0;
}
コード例 #2
0
static void __init omnia_II_machine_init(void)
{

//	system_rev = 0x20;
	s3c_config_gpio_table(ARRAY_SIZE(omnia_II_init_gpio_table),
		omnia_II_init_gpio_table);
	
	s3c_i2c0_set_platdata(NULL);
	s3c_i2c1_set_platdata(NULL);

	s3c_ts_set_platdata(&s3c_ts_platform);

	init_spi();

	i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
	i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
	i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2));
	i2c_register_board_info(3, i2c_devs3, ARRAY_SIZE(i2c_devs3));

	s3c6410_add_mem_devices (&pmem_setting);

	platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
	s3c6410_pm_init();
	omnia_II_set_qos();
	s3c6410_wdt_io_map();
	omnia_II_switch_init();
	wake_lock_init(&wlan_wakelock, WAKE_LOCK_SUSPEND, "wlan");
}
コード例 #3
0
ファイル: spi_api.c プロジェクト: fenrir-naru/mbed
void spi_frequency(spi_t *obj, int hz) {
    // Note: The frequencies are obtained with SPI clock = 48 MHz (APB1 & APB2 clocks)
    if (hz < 300000) {
        obj->br_presc = SPI_BaudRatePrescaler_256; // 188 kHz
    }
    else if ((hz >= 300000) && (hz < 700000)) {
        obj->br_presc = SPI_BaudRatePrescaler_128; // 375 kHz
    }
    else if ((hz >= 700000) && (hz < 1000000)) {
        obj->br_presc = SPI_BaudRatePrescaler_64; // 750 kHz
    }
    else if ((hz >= 1000000) && (hz < 3000000)) {
        obj->br_presc = SPI_BaudRatePrescaler_32; // 1.5 MHz
    }
    else if ((hz >= 3000000) && (hz < 6000000)) {
        obj->br_presc = SPI_BaudRatePrescaler_16; // 3 MHz
    }
    else if ((hz >= 6000000) && (hz < 12000000)) {
        obj->br_presc = SPI_BaudRatePrescaler_8; // 6 MHz
    }
    else if ((hz >= 12000000) && (hz < 24000000)) {
        obj->br_presc = SPI_BaudRatePrescaler_4; // 12 MHz
    }
    else { // >= 24000000
        obj->br_presc = SPI_BaudRatePrescaler_2; // 24 MHz
    }
    init_spi(obj);
}
コード例 #4
0
ファイル: RW_ExtFlash.c プロジェクト: zhangh2009/umassmoo
void main(void)
{
  unsigned char rcv_data;
  unsigned long fadd;

  WDTCTL = WDTPW+WDTHOLD;                   // Stop watchdog timer

  P2SEL = 0;
  P2IFG = 0;
  
  init_spi();       // Initialize the flash memory
  Chip_Erase();     // Erase the chip
  
  rcv_data = Read_Status_Register();
  while(rcv_data & 0x9C)
  {
    WRSR(0x02);
  }
  
  fadd = 0x100;    // Start address: 256, end address: 65535
  rcv_data = 0;

  while(fadd < 0x010000 ) // end address: 65535
  { 
    Byte_Program(fadd, rcv_data); // Write
    rcv_data = Read(fadd); // Read
    rcv_data = rcv_data + 1;
    fadd = fadd + 1;
  }
}
コード例 #5
0
ファイル: encodertest.c プロジェクト: erin-pierce/elecanisms
int16_t main(void) {
    init_clock();
    init_ui();
    init_pin();
    init_spi();

    ENC_MISO = &D[1];
    ENC_MOSI = &D[0];
    ENC_SCK = &D[2];
    ENC_NCS = &D[3];

    pin_digitalOut(ENC_NCS);
    pin_set(ENC_NCS);

    spi_open(&spi1, ENC_MISO, ENC_MOSI, ENC_SCK, 2e8);


    InitUSB();                              // initialize the USB registers and serial interface engine
    while (USB_USWSTAT!=CONFIG_STATE) {     // while the peripheral is not configured...
        ServiceUSB();                       // ...service USB requests
    }
    while (1) {
        ServiceUSB();                       // service any pending USB requests
    }
}
コード例 #6
0
ファイル: spi_api.c プロジェクト: AlessandroA/mbed
void spi_format(spi_t *obj, int bits, int mode, int slave) {
    // Save new values
    if (bits == 16) {
        obj->bits = SPI_DATASIZE_16BIT;
    } else {
        obj->bits = SPI_DATASIZE_8BIT;
    }

    switch (mode) {
        case 0:
            obj->cpol = SPI_POLARITY_LOW;
            obj->cpha = SPI_PHASE_1EDGE;
            break;
        case 1:
            obj->cpol = SPI_POLARITY_LOW;
            obj->cpha = SPI_PHASE_2EDGE;
            break;
        case 2:
            obj->cpol = SPI_POLARITY_HIGH;
            obj->cpha = SPI_PHASE_1EDGE;
            break;
        default:
            obj->cpol = SPI_POLARITY_HIGH;
            obj->cpha = SPI_PHASE_2EDGE;
            break;
    }

    if (obj->nss != SPI_NSS_SOFT) {
        obj->nss = (slave) ? SPI_NSS_HARD_INPUT : SPI_NSS_HARD_OUTPUT;
    }

    obj->mode = (slave) ? SPI_MODE_SLAVE : SPI_MODE_MASTER;

    init_spi(obj);
}
コード例 #7
0
int main() {


    int x = 0;
    
    init_hardware();
    
    init_spi();
    init_nrf();///////////////
    while(1)
    { 
        
        
        x++;
        if(x==10000)
        {        
            x = 0;
            LED2 = !LED2;
            LED1 = !LED1;
            
            tx_mode();
            txdat[0] = 'A';
            txdat[1] = '1';
            TXpayload (txdat);
            
        }
    }
    
    
}
コード例 #8
0
ファイル: haptic_damper.c プロジェクト: gubbatuba/elecanisms
void setup(void) {
    // Initialize PIC24 modules.
    init_clock();
    init_ui();
    init_timer();
    init_pin();
    init_oc();
    init_spi();
    init_uart();

    // Configure single SPI comms. system
    pin_digitalOut(SPI_CS);
    pin_set(SPI_CS);
    spi_open(spi_inst, SPI_MISO, SPI_MOSI, SPI_SCK, spi_freq, spi_mode);

    // Configure & start timers used.
    timer_setPeriod(&timer1, 1);
    timer_setPeriod(&timer2, 1);  // Timer for LED operation/status blink
    timer_setPeriod(&timer3, LOOP_TIME); // Timer for main control loop
    timer_start(&timer1);
    timer_start(&timer2);
    timer_start(&timer3);

    // Configure dual PWM signals for bidirectional motor control
    oc_pwm(&oc1, PWM_I1, NULL, pwm_freq, pwm_duty);
    oc_pwm(&oc2, PWM_I2, NULL, pwm_freq, pwm_duty);

    InitUSB();                              // initialize the USB registers and
                                            // serial interface engine
    while (USB_USWSTAT != CONFIG_STATE) {   // while periph. is not configured,
        ServiceUSB();                       // service USB requests
    }
}
コード例 #9
0
int main(void)
{
	DDRC |= (1 << DDRC7);
	PORTC |= (1 << PORTC7);
	_delay_ms(2);
	PORTC &= ~(1 << PORTC7);
	
 	init_power();
 	init_timeout_timer();
	init_switch();
	init_ref_clock();
	init_spi(2);
	init_buttons();
	init_serial(2400);
	init_adc();
	init_i2c();
	//Turn on interrupts
	sei();
	play_sounds();
	//Debug: Never Gets here
    while(1)
    {
		_delay_ms(1000);
		get_POT_set_TWIPOT();
	}
}
コード例 #10
0
ファイル: spi_api.c プロジェクト: AlessandroA/mbed
void spi_frequency(spi_t *obj, int hz)
{
    int spi_hz = 0;
	uint8_t prescaler_rank = 0;

	/* Get source clock depending on SPI instance */
    switch ((int)obj->spi) {
        case SPI_1:
			/* SPI_1. Source CLK is PCKL2 */
			spi_hz = HAL_RCC_GetPCLK2Freq();
			break;
		case SPI_2:
			/* SPI_2. Source CLK is PCKL1 */
			spi_hz = HAL_RCC_GetPCLK1Freq();
			break;
		default:
			error("SPI instance not set");
    }

	/* Define pre-scaler in order to get highest available frequency below requested frequency */
	while ((spi_hz > hz) && (prescaler_rank < sizeof(baudrate_prescaler_table)/sizeof(baudrate_prescaler_table[0]))){
		spi_hz = spi_hz / 2;
		prescaler_rank++;
	}

	if (prescaler_rank <= sizeof(baudrate_prescaler_table)/sizeof(baudrate_prescaler_table[0])) {
		obj->br_presc = baudrate_prescaler_table[prescaler_rank-1];
	} else {
		error("Couldn't setup requested SPI frequency");
	}

    init_spi(obj);
}
コード例 #11
0
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));
}
コード例 #12
0
void main(){

	WDTCTL = WDTPW + WDTHOLD;       // Stop watchdog timer
	BCSCTL1 = CALBC1_8MHZ;			// 8Mhz calibration for clock
  	DCOCTL  = CALDCO_8MHZ;

  	adc_val = 0;   // most recent result is stored in photo.whole_int
  	updates=0; 		//update counter for debugger
  	last_updates=0; // initialize last_update to 0 like updates value
  	data_send = 0;
  	counter = COUNTER_VAL;
  	low = 29;
  	med = 46;
  	high = 53;
  	light_range = high - low;
  	light_to_pot_factor = (double)light_range / 128.0;
  	state = high_state;
  	beat_count = 0;
  	reached_high = 0;	// set to false
  	reached_low = 0;	// set to false

  	init_spi();
  	init_wdt();
  	init_adc();
  	init_timer();

  	start_conversion();		// do a conversion so that updates > last_updates
  	TACCTL0 |= OUTMOD_4; // turn on speaker
 	_bis_SR_register(GIE+LPM0_bits);

}
コード例 #13
0
int main() {
    printf("Hello, CC3000!\r\n");

    board_init();

    /* Initialise the module */
    printf("Initializing...\r\n");

    init_spi();

    printf("init\r\n");
    wlan_init(CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch,
              sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable,
              WlanInterruptDisable, WriteWlanPin);
    printf("start\r\n");

    wlan_start(0);

    printf("ioctl\n\r");

    while(1) {
        // myled = 1;
        // wait(0.2);
        // myled = 0;
        // wait(0.2);
    }
}
コード例 #14
0
ファイル: spi_api.c プロジェクト: GvoOjeda/mbed
void spi_frequency(spi_t *obj, int hz) {
    // Note: The frequencies are obtained with SPI1 clock = 84 MHz (APB2 clock)
    if (hz < 600000) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_256; // 330 kHz
    }
    else if ((hz >= 600000) && (hz < 1000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_128; // 656 kHz
    }
    else if ((hz >= 1000000) && (hz < 2000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_64; // 1.3 MHz
    }
    else if ((hz >= 2000000) && (hz < 5000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_32; // 2.6 MHz
    }
    else if ((hz >= 5000000) && (hz < 10000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_16; // 5.25 MHz
    }
    else if ((hz >= 10000000) && (hz < 21000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_8; // 10.5 MHz
    }
    else if ((hz >= 21000000) && (hz < 42000000)) {
        obj->br_presc = SPI_BAUDRATEPRESCALER_4; // 21 MHz
    }
    else { // >= 42000000
        obj->br_presc = SPI_BAUDRATEPRESCALER_2; // 42 MHz
    }
    init_spi(obj);
}
コード例 #15
0
ファイル: main.c プロジェクト: Exchizz/Projekt-2014
int main(void)
{
	disable_global_int();
	init_clk_system();
	init_gpio();
	init_status_led();
	init_spi();
	systick_init();
	enable_global_int();
	INT8U counter = 0;

	while(1)
	{
		/* System part of the super loop. */
		while(!ticks);
		// The following will be executed every 5mS
		ticks--;
		
		if (!--alive_timer)
		{
			alive_timer = TIM_500_MSEC;
			GPIO_PORTF_DATA_R ^= 0x01;
			SSI0_DR_R = counter++;		// Send this through SPI
		}
		/* Application part of the super loop. */
		//counter = SSI0_SR_R;
	}
	return (0);
}
コード例 #16
0
ファイル: main.c プロジェクト: AkeelAli/microprocessorsystems
int main(void){
	
	//initialize Accelerometer	and Gyroscope
	initAccGyro();
	//initialize the Timer Interrupt
	initTIM();
	//initialize SPI & RF
	init_timer();
	init_protocol();
	init_spi();
//	slave_acknowledge_send();
	//master_move_wait();
go_wait();
//master_sync_send();
//master_result_send(RF_CMD_PAPER);	
//	 while(1) move_m = get_move();
	//rf_wait_command();		
	/*					
	while(1){
	  if(newData){
		 update_Orientation();
	
		 if (updateGesture(accelX, accelY, accelZ, roll_fuse, &move) == SUCCESS);
		
		 //write_byte (0x2C, 0x56);
		 //readout = read_byte (0x2C);
		 //rf_send_byte(0x17);					 

		 newData = 0;
	 } } 
	   */
	 
		 

}
コード例 #17
0
ファイル: mp2.c プロジェクト: jacobkingery/elecanisms_mp2
int16_t main(void) {
    init_clock();
    init_timer();
    init_ui();
    init_pin();
    init_spi();
    init_oc();
    init_md();

    // Current measurement pin
    pin_analogIn(&A[0]);

    // SPI pin setup
    ENC_MISO = &D[1];
    ENC_MOSI = &D[0];
    ENC_SCK = &D[2];
    ENC_NCS = &D[3];
    pin_digitalOut(ENC_NCS);
    pin_set(ENC_NCS);

    // Open SPI in mode 1
    spi_open(&spi1, ENC_MISO, ENC_MOSI, ENC_SCK, 2e6, 1);

    // Motor setup
    md_velocity(&md1, 0, 0);

    // Get initial angle offset
    uint8_t unset = 1;
    while (unset) {
        ANG_OFFSET = enc_readReg((WORD) REG_ANG_ADDR);
        unset = parity(ANG_OFFSET.w);
    }
    ANG_OFFSET.w &= ENC_MASK;

    // USB setup
    InitUSB();
    while (USB_USWSTAT!=CONFIG_STATE) {
        ServiceUSB();
    }

    // Timers
    timer_setFreq(&timer2, READ_FREQ);
    timer_setFreq(&timer3, CTRL_FREQ);
    timer_start(&timer2);
    timer_start(&timer3);

    // Main loop
    while (1) {
        ServiceUSB();
        if (timer_flag(&timer2)) {
            timer_lower(&timer2);
            get_readings();
        }
        if (timer_flag(&timer3)) {
            timer_lower(&timer3);
            set_velocity();
        }
    }
}
コード例 #18
0
//*****************************************************************************
//
//! initDriver
//!
//!  @param  None
//!
//!  @return none
//!
//!  @brief  The function initializes a CC3000 device and triggers it to 
//!          start operation
//
//*****************************************************************************
int
initDriver(void)
{
	
	// Init GPIO's
	pio_init();
	
	//Init Spi
	init_spi();
	
	DispatcherUARTConfigure();
	
	// WLAN On API Implementation
	wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
	
	// Trigger a WLAN device
	wlan_start(0);
	
	// Turn on the LED 5 to indicate that we are active and initiated WLAN successfully
	turnLedOn(5);
	
	// Mask out all non-required events from CC3000
	wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
	
	// Generate the event to CLI: send a version string
	{
		char cc3000IP[50];
		char *ccPtr;
		unsigned short ccLen;
		
		DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString, sizeof(pucUARTExampleAppString));
		
		
		ccPtr = &cc3000IP[0];
		ccLen = my_itoa(PALTFORM_VERSION, ccPtr);
		ccPtr += ccLen;
		*ccPtr++ = '.';
		ccLen = my_itoa(APPLICATION_VERSION, ccPtr);
		ccPtr += ccLen;
		*ccPtr++ = '.';
		ccLen = my_itoa(SPI_VERSION_NUMBER, ccPtr);
		ccPtr += ccLen;
		*ccPtr++ = '.';
		ccLen = my_itoa(DRIVER_VERSION_NUMBER, ccPtr);
		ccPtr += ccLen;
		*ccPtr++ = '\f';
		*ccPtr++ = '\r';
		*ccPtr++ = '\0';
		
		DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
	}
	
	wakeup_timer_init();
	
	ucStopSmartConfig   = 0;
	
	return(0);
}
コード例 #19
0
ファイル: spring.c プロジェクト: erin-pierce/elecanisms
int16_t main(void) {
    init_clock();
    init_ui();
    init_pin();
    init_spi();

    init_timer();
    init_oc();
    init_md();

    led_off(&led2);
    led_off(&led3);

    ENC_MISO = &D[1];
    ENC_MOSI = &D[0];
    ENC_SCK = &D[2];
    ENC_NCS = &D[3];


    read_angle.w=0x3FFF;
    Pscale.w=1;
    Iscale.w=0;
    direction.w=1;
    speed.w=0;
    angle_now.i=180;
    angle_prev.i=180;
    angle.w=10;
    uint8_t loop = 0;

    pin_digitalOut(ENC_NCS);
    pin_set(ENC_NCS);

    spi_open(&spi1, ENC_MISO, ENC_MOSI, ENC_SCK, 2e8,1);

    timer_setPeriod(&timer1, 0.05);
    timer_start(&timer1);

    InitUSB();  
                              // initialize the USB registers and serial interface engine
    while (USB_USWSTAT!=CONFIG_STATE) {     // while the peripheral is not configured...
        ServiceUSB();                       // ...service USB requests
    }  

   while(1){
    ServiceUSB();
        if (timer_flag(&timer1)) {
            timer_lower(&timer1);
            angle_prev=angle_now; 
            angle_prev_con=angle;                // service any pending USB requests
            angle_now = enc_readReg(read_angle);
            angle_now = mask_angle(angle_now);
            angle=convert_Angle(angle_prev,angle_now,&loop);

            spring_simple(angle);
        }
    }    
}
コード例 #20
0
ファイル: spi_api.c プロジェクト: ElAbbassi/mbed
void spi_frequency(spi_t *obj, int hz) {
    // Values depend of PCLK1 and PCLK2: 32 MHz if HSI is used, 24 MHz if HSE is used
    if (SystemCoreClock == 32000000) { // HSI
        if (hz < 250000) {
            obj->br_presc = SPI_BaudRatePrescaler_256; // 125 kHz
        }
        else if ((hz >= 250000) && (hz < 500000)) {
            obj->br_presc = SPI_BaudRatePrescaler_128; // 250 kHz
        }
        else if ((hz >= 500000) && (hz < 1000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_64; // 500 kHz
        }
        else if ((hz >= 1000000) && (hz < 2000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_32; // 1 MHz
        }
        else if ((hz >= 2000000) && (hz < 4000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_16; // 2 MHz
        }
        else if ((hz >= 4000000) && (hz < 8000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_8; // 4 MHz
        }
        else if ((hz >= 8000000) && (hz < 16000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_4; // 8 MHz
        }
        else { // >= 16000000
            obj->br_presc = SPI_BaudRatePrescaler_2; // 16 MHz
        }
    }
    else { // 24 MHz - HSE
        if (hz < 180000) {
            obj->br_presc = SPI_BaudRatePrescaler_256; // 94 kHz
        }
        else if ((hz >= 180000) && (hz < 350000)) {
            obj->br_presc = SPI_BaudRatePrescaler_128; // 188 kHz
        }
        else if ((hz >= 350000) && (hz < 750000)) {
            obj->br_presc = SPI_BaudRatePrescaler_64; // 375 kHz
        }        
        else if ((hz >= 750000) && (hz < 1000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_32; // 750 kHz
        }
        else if ((hz >= 1000000) && (hz < 3000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_16; // 1.5 MHz
        }
        else if ((hz >= 3000000) && (hz < 6000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_8; // 3 MHz
        }
        else if ((hz >= 6000000) && (hz < 12000000)) {
            obj->br_presc = SPI_BaudRatePrescaler_4; // 6 MHz
        }
        else { // >= 12000000
            obj->br_presc = SPI_BaudRatePrescaler_2; // 12 MHz
        }      
    }
    init_spi(obj);
}
コード例 #21
0
ファイル: mmc.c プロジェクト: Aliandrana/uzebox
DSTATUS disk_initialize (void)
{
	BYTE n, cmd, ty, ocr[4];
	UINT tmr;

#if _PF_USE_WRITE
	if (CardType && MMC_SEL) disk_writep(0, 0);	/* Finalize write process if it is in progress */
#endif

	init_spi();		/* Initialize ports to control MMC */
	DESELECT();
	for (n = 100; n; n--) rcv_spi();	/* 80*10 dummy clocks with CS=H */

	ty = 0;
	if (send_cmd(CMD0, 0) == 1) {			/* Enter Idle state */

		if (send_cmd(CMD8, 0x1AA) == 1) {	/* SDv2 */

			for (n = 0; n < 4; n++) ocr[n] = rcv_spi();		/* Get trailing return value of R7 resp */
		
			if (ocr[2] == 0x01 && ocr[3] == 0xAA) {			/* The card can work at vdd range of 2.7-3.6V */
				for (tmr = 10000; tmr && send_cmd(ACMD41, 1UL << 30); tmr--) dly_100us();	/* Wait for leaving idle state (ACMD41 with HCS bit) */
				
			
				if (tmr && send_cmd(CMD58, 0) == 0) {		/* Check CCS bit in the OCR */


					for (n = 0; n < 4; n++) ocr[n] = rcv_spi();

					ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;	/* SDv2 (HC or SC) */
				}
			}
		} else {							/* SDv1 or MMCv3 */
			if (send_cmd(ACMD41, 0) <= 1) 	{
				ty = CT_SD1; cmd = ACMD41;	/* SDv1 */
			} else {
				ty = CT_MMC; cmd = CMD1;	/* MMCv3 */
			}
			for (tmr = 10000; tmr && send_cmd(cmd, 0); tmr--) dly_100us();	/* Wait for leaving idle state */
			if (!tmr || send_cmd(CMD16, 512) != 0)			/* Set R/W block length to 512 */
				ty = 0;
		}

	}
	CardType = ty;
	DESELECT();
	rcv_spi();

	//full speed SPI
	SPCR = (1<<MSTR)|(1<<SPE);
	SPSR = 0x01;				/* SPI clk 2X */


	return ty ? 0 : STA_NOINIT;
}
コード例 #22
0
ファイル: spi_api.c プロジェクト: allankliu/mbed
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) {
    // Determine the SPI to use
    SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI);
    SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO);
    SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK);
    SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL);

    SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso);
    SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel);

    obj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl);

    if (obj->spi == (SPIName)NC) {
        error("SPI error: pinout mapping failed.");
    }

    // Enable SPI clock
    if (obj->spi == SPI_1) {
        __SPI1_CLK_ENABLE();
    }
    if (obj->spi == SPI_2) {
        __SPI2_CLK_ENABLE();
    }
    if (obj->spi == SPI_3) {
        __SPI3_CLK_ENABLE();
    }

    // Configure the SPI pins
    pinmap_pinout(mosi, PinMap_SPI_MOSI);
    pinmap_pinout(miso, PinMap_SPI_MISO);
    pinmap_pinout(sclk, PinMap_SPI_SCLK);

    // Save new values
    obj->bits = SPI_DATASIZE_8BIT;
    obj->cpol = SPI_POLARITY_LOW;
    obj->cpha = SPI_PHASE_1EDGE;
    obj->br_presc = SPI_BAUDRATEPRESCALER_256;

    obj->pin_miso = miso;
    obj->pin_mosi = mosi;
    obj->pin_sclk = sclk;
    obj->pin_ssel = ssel;

    if (ssel == NC) { // SW NSS Master mode
        obj->mode = SPI_MODE_MASTER;
        obj->nss = SPI_NSS_SOFT;
    } else { // Slave
        pinmap_pinout(ssel, PinMap_SPI_SSEL);
        obj->mode = SPI_MODE_SLAVE;
        obj->nss = SPI_NSS_HARD_INPUT;
    }

    init_spi(obj);
}
コード例 #23
0
ファイル: board_specific.c プロジェクト: symplex/SHD
void
init_board (void)
{
  la_trace_init ();
  init_spi ();

  SMINI_PC &= ~bmPC_nRESET;	// active low reset
  SMINI_PC |= bmPC_nRESET;

  power_down_9862s ();
}
コード例 #24
0
/* read clock time from DS1306 and return it in *tmp */
int rtc_get (struct rtc_time *tmp)
{
	volatile immap_t *immap = (immap_t *) CFG_IMMR;
	unsigned char spi_byte;	/* Data Byte */

	init_spi ();		/* set port B for software SPI */

	/* Now we can enable the DS1306 RTC */
	immap->im_cpm.cp_pbdat |= PB_SPI_CE;
	udelay (10);

	/* Shift out the address (0) of the time in the Clock Chip */
	soft_spi_send (0);

	/* Put the clock readings into the rtc_time structure */
	tmp->tm_sec = bcd2bin (soft_spi_read ());	/* Read seconds */
	tmp->tm_min = bcd2bin (soft_spi_read ());	/* Read minutes */

	/* Hours are trickier */
	spi_byte = soft_spi_read ();	/* Read Hours into temporary value */
	if (spi_byte & 0x40) {
		/* 12 hour mode bit is set (time is in 1-12 format) */
		if (spi_byte & 0x20) {
			/* since PM we add 11 to get 0-23 for hours */
			tmp->tm_hour = (bcd2bin (spi_byte & 0x1F)) + 11;
		} else {
			/* since AM we subtract 1 to get 0-23 for hours */
			tmp->tm_hour = (bcd2bin (spi_byte & 0x1F)) - 1;
		}
	} else {
		/* Otherwise, 0-23 hour format */
		tmp->tm_hour = (bcd2bin (spi_byte & 0x3F));
	}

	soft_spi_read ();	/* Read and discard Day of week */
	tmp->tm_mday = bcd2bin (soft_spi_read ());	/* Read Day of the Month */
	tmp->tm_mon = bcd2bin (soft_spi_read ());	/* Read Month */

	/* Read Year and convert to this century */
	tmp->tm_year = bcd2bin (soft_spi_read ()) + 2000;

	/* Now we can disable the DS1306 RTC */
	immap->im_cpm.cp_pbdat &= ~PB_SPI_CE;	/* Disable DS1306 Chip */
	udelay (10);

	GregorianDay (tmp);	/* Determine the day of week */

	debug ("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
	       tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
	       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);

	return 0;
}
コード例 #25
0
ファイル: main.c プロジェクト: cjduffett/MSP430-Projects
// ===== Main Program =====
void main(){

    WDTCTL = WDTPW + WDTHOLD;       // Stop watchdog timer
    BCSCTL1 = CALBC1_8MHZ;          // 8Mhz calibration for clock
    DCOCTL  = CALDCO_8MHZ;

    init_spi();
    init_wdt();
    init_7seg();

    _bis_SR_register(GIE+LPM0_bits);
}
コード例 #26
0
//*****************************************************************************
//
//! initDriver
//!
//!  \param  None
//!
//!  \return none
//!
//!  \brief  The function initializes a CC3000 device and triggers it to start operation
//
//*****************************************************************************
int
initDriver(void)
{



    pio_init(); // Init GPIO's
    init_spi();
    wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
    wlan_start(0);

	if (IP_ALLOC_METHOD == USE_STATIC_IP){// The DHCP setting shave been removed.

		pucSubnetMask[0] = 0xFF;// Subnet mask is assumed to be 255.255.255.0
		pucSubnetMask[1] = 0xFF;
		pucSubnetMask[2] = 0xFF;
		pucSubnetMask[3] = 0x0;


		pucIP_Addr[0] = STATIC_IP_OCT1;    // CC3000's IP
		pucIP_Addr[1] = STATIC_IP_OCT2;
		pucIP_Addr[2] = STATIC_IP_OCT3;
		pucIP_Addr[3] = STATIC_IP_OCT4;

		pucIP_DefaultGWAddr[0] = STATIC_IP_OCT1;// Default Gateway/Router IP
		pucIP_DefaultGWAddr[1] = STATIC_IP_OCT2;
		pucIP_DefaultGWAddr[2] = STATIC_IP_OCT3;
		pucIP_DefaultGWAddr[3] = 1;

		pucDNS[0] = STATIC_IP_OCT1;// We assume the router is also a DNS server
		pucDNS[1] = STATIC_IP_OCT2;
		pucDNS[2] = STATIC_IP_OCT3;
		pucDNS[3] = 1;

		netapp_dhcp((unsigned long *)pucIP_Addr, (unsigned long *)pucSubnetMask,
					(unsigned long *)pucIP_DefaultGWAddr, (unsigned long *)pucDNS);

		// reset the CC3000 to apply Static Setting
		wlan_stop();
		__delay_cycles(6000000);
		wlan_start(0);
	}
    
    // Mask out all non-required events from CC3000
    wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
    
    unsolicicted_events_timer_init();
    
    // CC3000 has been initialized
    setCC3000MachineState(CC3000_INIT);
    
    return(0);
}
コード例 #27
0
ファイル: slavemain.c プロジェクト: tim7398/ec450
//main program
void main() {

	WDTCTL = WDTPW + WDTHOLD;       // Stop watchdog timer
	BCSCTL1 = CALBC1_1MHZ;
	DCOCTL = CALDCO_1MHZ;

	P1DIR |= RED;					//LED initialization
	P1OUT &= ~RED;

	init_spi();
	_bis_SR_register(GIE + LPM0_bits);
}
コード例 #28
0
ファイル: diskio.c プロジェクト: AlonsoKJ/cow_bell_repo
//This function assumes the SD card has been powered for at least a second before being called
DSTATUS disk_initialize (void)
{
	unsigned i;

	init_spi();
	init_card_select_pin();

	//pull CS high, then send at least 74 clock pulses to the module with SIMO high
	deselect_card();
	for(i = 0; i <= 10; i++){
		rec_byte();
	}

	//pull CS low and send CMD0 to reset card and put it in SPI mode
	select_card();
	if (send_cmd(CMD_0, 0x00000000, 0x95) != 1){
		deselect_card();
		return RES_ERROR;
	}

	if(send_cmd(CMD_8, 0x000001AA, 0x87) == 1){ //Check voltage range on card. If a non-one value is returned, card is not sd v.2

		if(get_r7_resp(0xAA) != RES_OK){ //returns 1 if card works at 2.7-3.3V and check_pattern is valid
			deselect_card();
			return RES_ERROR;
		}

		if(check_ocr_voltage_range() != RES_OK){
			deselect_card();
			return RES_ERROR;
		}

		if(wait_for_card_to_finish_init() != RES_OK){
			deselect_card();
			return RES_ERROR;
		}

		if(check_card_type() != RES_OK){
			deselect_card();
			return RES_ERROR;
		}

	}//close if cmd_8
	//else{



	//}//Version 1.0 or earlier

	deselect_card();
	return RES_OK;
}
コード例 #29
0
ファイル: cc3000.c プロジェクト: bharat2085/lmc_cpds
signed int
init_wifiDriver(void)
{
    signed char ret;

    //
	// Init GPIO's
	//
	if(!wifi_SPI_gpio_init_Done)
	{
		return -1;  //error
	}

		//
        //initialize SPI bus.
		//
		// Must be done to establish SimpleLink between microcontroller and cc3000.
		// all  cc3000 api will work only after successful SPI initialization /enabling SimpleLink .
		//	All CC3000 api() {except wlan_init()api }  wait for SimpleLinkWaitEvent(HCI_Cmd_Name, &retval).
        //
        ret=init_spi();
        if(ret)
        {
        	return -2;
        }

	//
	// Register various callback with HostDriver framework  for
    //		1.	 processing  not masked asynchronous Event.
    //		2.	 msp430 bsp functions for cc3000 interrupt pin and wlan_Enable pin
   //
       wlan_init( CC3000_AsyncEventCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);

	//
	// Starts the CC3000 Wifi chip  to become enabled for wifi operations.
     //blocks till wifi chip doesnt get UP.
	//
	wlan_start(0);

	//
	// Mask out all non-required asynchronous events from CC3000
	//
	ret=	wlan_set_event_mask( HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT);
	if(ret){

			return -3;
		  }


    return(0);
}
コード例 #30
0
ファイル: spi_tester.c プロジェクト: joeylmaalouf/CA15-Labs
int main()
{
	xil_printf("Program Started\n\r");
    init_platform();
    init_spi(&SpiInstance);
    init_gpio(&GpioInstance);

    u8 LED_data = 0x1;
    XGpio_DiscreteWrite(&GpioInstance, LED_CHANNEL, LED_data);
    xil_printf("Tests started.\n\r");
    LED_data |= 0x1<<1;
    XGpio_DiscreteWrite(&GpioInstance, LED_CHANNEL, LED_data);

    // Test for proper initial read/write
    int addr = 0;
    int value = 10;
	spi_write(&SpiInstance, addr, value);
	u8 res = spi_read(&SpiInstance, addr);
	xil_printf("Wrote to %X. %d transmitted. %d read back. The send and received values should match.\n\r", addr, value, res);
	// Test for proper overwriting of same address with new value
	value = 16;
	spi_write(&SpiInstance, addr, value);
	res = spi_read(&SpiInstance, addr);
	xil_printf("Wrote to %X again. %d transmitted. %d read back. The received value should be updated to the new sent value.\n\r", addr, value, res);
	// Test for making sure multiple addresses work
	addr = 1;
	value = 20;
	spi_write(&SpiInstance, addr, value);
	res = spi_read(&SpiInstance, addr);
	xil_printf("Wrote to %X. %d transmitted. %d read back. The new address should function as well as the old one.\n\r", addr, value, res);
	// Test to make sure every address works
	xil_printf("Writing and reading to all 32 memory addresses:\r\n(sent and received values should match, value + address should sum to 32)\n\r");
	int i;
	for (i = 0; i < 32; ++i){
		addr = i;
		value = 32 - i;
		spi_write(&SpiInstance, addr, value);
		res = spi_read(&SpiInstance, addr);
		xil_printf("Wrote to %X. %d transmitted. %d read back.\n\r", addr, value, res);
	}


    LED_data |= 0x1<<2;
    xil_printf("Tests complete. Please review results.\n\r");

    XGpio_DiscreteWrite(&GpioInstance, LED_CHANNEL, LED_data);
    LED_data |= 0x1<<3;
    XGpio_DiscreteWrite(&GpioInstance, LED_CHANNEL, LED_data);
    cleanup_platform();
    return 0;
}