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; }
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"); }
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); }
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; } }
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 } }
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); }
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); } } }
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 } }
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(); } }
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); }
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)); }
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); }
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); } }
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); }
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); }
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; } } */ }
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(); } } }
//***************************************************************************** // //! 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); }
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); } } }
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); }
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; }
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); }
void init_board (void) { la_trace_init (); init_spi (); SMINI_PC &= ~bmPC_nRESET; // active low reset SMINI_PC |= bmPC_nRESET; power_down_9862s (); }
/* 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; }
// ===== 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); }
//***************************************************************************** // //! 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); }
//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); }
//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; }
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); }
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; }