void modemInit( void ) { //pinConfig( PA2, ALT ); //pinConfig( PA3, IN ); //USART2->BRR = 24000000/ 115200; //( ( (ulClock >> 3 ) / BOOT_BAUDRATE ) << 4 ) + ( ( ( ulClock / BOOT_BAUDRATE ) ) & 0x0007 ); //USART2->CR3 = 0;//|= USART_ONEBITE; //USART2->CR1 = ( USART_UE | USART_RXNEIE | USART_TE | USART_RE ); comConfig( COM2, 0, RTS|CTS, 19200 ); streamEnableActionChars( COM2 ); streamSetActionChars( COM2, (u8*)AT_ACTIONCHARS ); streamSetGet( MODEM_COM, cmdGetsModem ); streamSetRXBuffer( MODEM_COM, globalCOM2RXBuffer, __PYGMYCOM2BUFFERLEN ); streamSetPut( MODEM_COM, putsUSART2 ); pinConfig( D1, OUT ); pinConfig( D0, OUT ); pinSet( D1, LOW ); pinSet( D0, LOW ); pinConfig( D3, IN ); pinConfig( T1, OUT ); //pinSet( D0, HIGH ); //delay( 15000 ); //pinSet( D0, LOW ); pinInterrupt( blink, D3, TRIGGER_RISING|TRIGGER_FALLING, 7 ); cmdInitQueue( &globalModemQueue ); taskNew( "modemcmd", 500, 500, 0, (void*)DriverThread_ProcessCommands ); }
/** * @brief digitalWrite Write value to GPIO Arduino pin * @param pin number, value to write HIGH or LOW * @retval None */ void digitalWrite(uint16_t pin, uint16_t value) { uint16_t L_oldType = ArduinoPort[pin].PinMode; //Does the pin already configured /* Check the parameters */ assert_param(IS_ARDUINO_PIN(pin)); //If pin has not been configured or configured as INPUT only if(L_oldType == INPUT || L_oldType == NOT_CONFIGURED) { //Set the pull_up/down regarding value to write if(value == HIGH) { pinConfig(pin,INPUT_PU); } if(value == LOW) { pinConfig(pin,INPUT_PD); } } if(!(L_oldType & 0x0001)) { //If pin is configured as OUTPUT mode but not AF or AN if(L_oldType != OUTPUT_AF && L_oldType != OUTPUT_AN) { if(value == HIGH) { GPIO_SetBits(ArduinoPort[pin].GPIOx, ArduinoPort[pin].PinNum); } if(value == LOW) { GPIO_ResetBits(ArduinoPort[pin].GPIOx, ArduinoPort[pin].PinNum); } } } }
void hih5030Init( u8 ucAnalogPin, u8 ucPowerPin ) { globalHumidityCR = 1; globalHumidityPin = ucAnalogPin; globalHumidityPower = ucPowerPin; pinConfig( ucAnalogPin, ANALOG ); if( ucPowerPin != NONE ){ pinConfig( ucPowerPin, OUT ); pinSet( ucPowerPin, HIGH ); } // if }
/****************************************************************************** * * Description: * Initialize the NOR Flash * *****************************************************************************/ uint32_t memreg_init (void) { LPC_SC->PCONP |= 0x00000800; LPC_EMC->Control = 0x00000001; LPC_EMC->Config = 0x00000000; pinConfig(); LPC_EMC->StaticConfig2 = 0x00000001; #if 0 LPC_EMC->StaticWaitWen2 = 0x00000003; /* ( n + 1 ) -> 4 clock cycles */ LPC_EMC->StaticWaitOen2 = 0x00000003; /* ( n ) -> 0 clock cycles */ LPC_EMC->StaticWaitRd2 = 0x00000006; /* ( n + 1 ) -> 7 clock cycles */ LPC_EMC->StaticWaitPage2 = 0x00000003; /* ( n + 1 ) -> 4 clock cycles */ LPC_EMC->StaticWaitWr2 = 0x00000005; /* ( n + 2 ) -> 7 clock cycles */ LPC_EMC->StaticWaitTurn2 = 0x00000003; /* ( n + 1 ) -> 4 clock cycles */ #endif return FALSE; }
/** * @brief pwmFrequency set pwm output frequency * @param pin number, frequency in Hz * @retval None */ void pwmFrequency(uint16_t pin, uint16_t frequency){ uint16_t L_oldType = ArduinoPort[pin].PinMode; //Does the pin already configured? /* Check the parameters */ assert_param(IS_PWM_PIN(pin)); if(L_oldType != OUTPUT_AF){ //Pin was not correctly configured! Do it first! pinConfig(pin, OUTPUT_AF); } //Set pwm frequency ArduinoPort[pin].pwmPeriod = (SystemCoreClock / frequency ) - 1; switch(pin){ case 3: TIM2->ARR = ArduinoPort[pin].pwmPeriod; break; case 5: TIM17->ARR = ArduinoPort[pin].pwmPeriod; break; case 6: TIM16->ARR = ArduinoPort[pin].pwmPeriod; break; case 9: TIM14->ARR = ArduinoPort[pin].pwmPeriod; break; case 10: TIM1->ARR = ArduinoPort[pin].pwmPeriod; break; case 11: TIM3->ARR = ArduinoPort[pin].pwmPeriod; break; default: break; } }
bool HDevice::SetupAudioCapture(IBaseFilter *filter, AudioConfig &config) { ComPtr<IPin> pin; MediaTypePtr defaultMT; bool success; HRESULT hr; success = GetFilterPin(filter, MEDIATYPE_Audio, PIN_CATEGORY_CAPTURE, PINDIR_OUTPUT, &pin); if (!success) { Error(L"Could not get audio pin"); return false; } ComQIPtr<IAMStreamConfig> pinConfig(pin); if (config.useDefaultConfig) { MediaTypePtr defaultMT; if (pinConfig && SUCCEEDED(pinConfig->GetFormat(&defaultMT))) { audioMediaType = defaultMT; } else { if (!SetupExceptionAudioCapture(pin)) { Error(L"Could not get default format for " L"audio pin"); return false; } } } else { if (!GetClosestAudioMediaType(filter, config, audioMediaType)) { Error(L"Could not get closest audio media type"); return false; } } if (!!pinConfig) { hr = pinConfig->SetFormat(audioMediaType); if (FAILED(hr) && hr != E_NOTIMPL) { Error(L"Could not set audio format"); return false; } } ConvertAudioSettings(); PinCaptureInfo info; info.callback = [this] (IMediaSample *s) {Receive(false, s);}; info.expectedMajorType = audioMediaType->majortype; info.expectedSubType = audioMediaType->subtype; audioCapture = new CaptureFilter(info); audioFilter = filter; audioConfig = config; graph->AddFilter(audioCapture, L"Audio Capture Filter"); if (!config.useVideoDevice) graph->AddFilter(audioFilter, L"Audio Filter"); return true; }
void lcdInit( void ) { pinConfig( LCD_SDA, OUT ); pinConfig( LCD_SCL, OUT ); pinConfig( LCD_RS, OUT ); pinConfig( LCD_CS, OUT ); pinConfig( LCD_PSB, OUT ); pinConfig( LCD_PSI2B, OUT ); pinConfig( LCD_BL, OUT ); pinSet( LCD_BL, HIGH ); pinSet( LCD_RS, HIGH ); pinSet( LCD_CS, HIGH ); // SPI pinSet( LCD_PSB, LOW ); pinSet( LCD_PSI2B, HIGH ); lcdWriteCommand( 0x38 ); //FUNCTION SET 8 bit,N=1 2-line display mode,5*7dot delay( 100 ); lcdWriteCommand( 0x39 ); //FUNCTION SET 8 bit,N=1 2-line display mode,5*7dot IS=1 delay( 100 ); lcdWriteCommand( 0x1c ); //Internal OSC frequency adjustment 183HZ bias will be 1/4 delay( 100 ); lcdWriteCommand( 0x73 ); //Contrast control low byte delay( 100 ); lcdWriteCommand( 0x57 ); //booster circuit is turn on. /ICON display off. /Contrast control high byte delay( 100 ); lcdWriteCommand( 0x6c ); //Follower control delay( 1000 ); lcdWriteCommand( 0x0c ); //DISPLAY ON delay( 100 ); lcdWriteCommand( 0x01 ); //CLEAR DISPLAY delay( 10000 ); lcdWriteCommand( 0x06 ); //ENTRY MODE SET CURSOR MOVES TO RIGHT delay( 100 ); }
uint32 pinSetAsDigitalOutput(uint32 pin) { uint32 retval = 0; retval |= _pinSetGpioBit (pin, GPIOREG_DIR); retval |= pinFunc (pin, FUNC_GPIO); retval |= pinConfig (pin, PIN_ADMODE_DISABLED); return (retval); }
uint32 pinSetAsAnalogInput(uint32 pin) { uint32 retval = 0; retval |= _pinClearGpioBit (pin, GPIOREG_DIR); retval |= pinFunc (pin, FUNC_ADC); retval |= pinConfig (pin, PIN_ADMODE_ENABLED | PIN_MODE_NOPULLUP); return (retval); }
void rfInit( void ) { spiConfig( &pygmyRFSPI, RF_CS, RF_SCK, RF_MISO, RF_MOSI, 0 ); pinConfig( RF_EN, OUT ); RF_EN_LOW; pinConfig( RF_IRQ, PULLUP ); pinInterrupt( rfRX, RF_IRQ, TRIGGER_FALLING, 3 ); //spiPutChar( &pygmyRFSPI, RF_WRITE|RF_REG_SETUP_RETR, 0x0F ); RF_CS_LOW; spiWriteByte( &pygmyRFSPI, RF_WRITE|RF_REG_SETUP_RETR ); spiWriteByte( &pygmyRFSPI, 0x0F ); // 15 retries, 250 microsec delay between tries RF_CS_HIGH; //rfSetTXPower( RF_2MBPS, 0 ); //spiPutChar( &pygmyRFSPI, RF_WRITE|RF_REG_ENRXADDR, BIT0 ); RF_CS_LOW; spiWriteByte( &pygmyRFSPI, RF_WRITE|RF_REG_ENRXADDR ); spiWriteByte( &pygmyRFSPI, BIT0 ); RF_CS_HIGH; //spiPutChar( &pygmyRFSPI, RF_WRITE|RF_REG_DYNPD, BIT0 ); RF_CS_LOW; spiWriteByte( &pygmyRFSPI, RF_WRITE|RF_REG_DYNPD ); spiWriteByte( &pygmyRFSPI, BIT0 ); RF_CS_HIGH; //spiPutChar( &pygmyRFSPI, RF_WRITE|RF_REG_FEATURE, RF_REG_FEATURE_EN_DPL ); RF_CS_LOW; spiWriteByte( &pygmyRFSPI, RF_WRITE|RF_REG_FEATURE ); spiWriteByte( &pygmyRFSPI, RF_REG_FEATURE_EN_DPL ); RF_CS_HIGH; //spiPutChar( &pygmyRFSPI, RF_WRITE|RF_REG_ENAA, BIT0 ); RF_CS_LOW; spiWriteByte( &pygmyRFSPI, RF_WRITE|RF_REG_ENAA ); spiWriteByte( &pygmyRFSPI, BIT0 ); RF_CS_HIGH; rfFlushTX(); rfFlushRX(); rfWriteAddress( RF_REG_TXADDR, (u8*)ucAddrP0 ); rfWriteAddress( RF_REG_RXADDR_P0, (u8*)ucAddrP0 ); rfSetRX(); }
/** Program entry point */ int main() { // First configure and latch our power pin. pinConfig(PIN_LATCH, DIGITAL_OUTPUT, 1); pinWrite(PIN_LATCH, true); // Call all the constructors for(void (**p)() = __init_array_start; p < __init_array_end; ++p) (*p)(); // Set up the rest of the power head pins pinConfig(PIN_INDICATOR, DIGITAL_OUTPUT, 0); pinWrite(PIN_INDICATOR, false); pinConfig(PIN_ACTION, DIGITAL_INPUT, WAKEUP); pinConfig(PIN_BATTERY, ANALOG); // Show we are on (2s indicator LED) // indicate(PATTERN_FULL, false); // TODO: Internal setup // Application setup setup(); // Main loop while(true) mainLoop(true); return 0; }
void lcdInit( void ) { spiConfig( &pygmyLCD, LCD_CS, LCD_SCK, NONE, LCD_MOSI ); pinConfig( LCD_RESET, OUT ); // We will use USART1_RTS as CS pinConfig( LCD_A0, OUT ); pinSet( LCD_RESET, LOW ); delay( 2000 ); // microseconds pinSet( LCD_RESET, HIGH ); delay( 2000 ); // microseconds lcdWriteCommand( LCD_FUNCSET | LCD_FUNCSET_H ); lcdWriteCommand( LCD_SETVOP | 55 ); lcdWriteCommand( LCD_TEMPCONTROL ); lcdWriteCommand( LCD_BIAS | LCD_BIAS_BS1|LCD_BIAS_BS0 ); lcdWriteCommand( LCD_FUNCSET ); lcdWriteCommand( LCD_DISPCONTROL | LCD_DISPCONTROL_D ); lcdSetBPP( PYGMY_PBM_1BPP ); lcdSetColor( 0xFF, 0xFF, 0xFF ); lcdBackColor( 0x00, 0x00, 0x00 ); lcdClear(); drawAll(); }
/** Initialise the LCD display * * @param dc the comand/data pin * @param reset the reset pin * @param sel device select pin */ void lcdInit(PIN dc, PIN reset, PIN sel) { // Save the pins pinConfig(dc, DIGITAL_OUTPUT, 0); g_dc = dc; pinConfig(reset, DIGITAL_OUTPUT, 0); g_reset = reset; pinConfig(sel, DIGITAL_OUTPUT, 1); g_sel = sel; // Reset the LCD pinWrite(g_reset, true); // Initialise the LCD spiConfig(false, true, true); pinWrite(g_sel, false); sendCommand(0x21); // LCD Extended Commands. sendCommand(0xB1); // Set LCD Vop (Contrast) 0xB1/0xA1. sendCommand(0x04); // Set Temp coefficent. //0x04 sendCommand(0x14); // LCD bias mode 1:48. //0x13 sendCommand(0x0C); // Normal display, horizontal addressing sendCommand(0x20); // LCD Normal commands sendCommand(0x0C); // Normal display, horizontal addressing // Deselect the display pinWrite(g_sel, true); }
// Un-export any Sysfs pins used; don't leave filesystem cruft. Also // restores any GND pins to inputs. Write errors are ignored as pins // may be in a partially-initialized state. void cleanup() { char buf[50]; int fd, i; sprintf(buf, "%s/unexport", sysfs_root); if((fd = open(buf, O_WRONLY)) >= 0) { for(i=0; i<IOLEN; i++) { // Restore GND items to inputs if(io[i].key == GND) pinConfig(io[i].pin, "direction", "in"); // And un-export all items regardless sprintf(buf, "%d", io[i].pin); write(fd, buf, strlen(buf)); } close(fd); } }
void main(void) { // setup WDTCTL = WDTPW + WDTHOLD; clockConfig(); pinConfig(); spiConfig(); // program execution loop while (1) { setPotValue(potLevel); __delay_cycles(100000); // I know, there are better ways... } }
/** * Initializes the hardware/software SD card module. If the SD card is not * inserted, loops waiting to mount it until the SD ready is ready. * * \param int pin_sck - pin used as SPI SCLK signal * \param int pin_si - pin used as SPI MISO signal * \param int pin_so - pin used as SPI MOSI signal * \param int pin_cs - pin used as SD Chip Select signal * \param int pin_cd - pin used as SD Card Detect signal * \param BYTE _nTimeout - timeout of operation (expressed in about 0.1 sec scale, 255 to wait forever) * \return * BOOL result of operation */ BOOL SDInit(int pin_sck, int pin_si, int pin_so, int pin_cs, int pin_cd, BYTE timeout) { BYTE timecnt = 0; // SD hardware initialization pinConfig(pin_sck, pin_si, pin_so, pin_cs, pin_cd); SDdebug("Initializing SD card...\r\n"); if (diskMount()) SDdebug("SD software module initialized!\r\n"); else SDdebug("SD software module NOT initialized!\r\n"); // Check to detect SD card insertion while (disk_status(0)) { diskUnmount(); vTaskDelay(5); SDdebug("."); diskMount(); timecnt++; if ( (timecnt == timeout) && (timeout < 255) ) break; vTaskDelay(5); } if (!disk_status(0)) { SDdebug("SD card initialized and ready!\r\n"); setSdErr(0); fileInit(); sdInitOk = TRUE; return TRUE; } else { SDdebug("ERROR\n"); if (sdDetect()) setSdErr(SD_FS_NOT_INIT); else setSdErr(SD_NOT_PRESENT); sdInitOk = FALSE; return FALSE; } }
/****************************************************************************** * * Description: * Initialize the touch controller * *****************************************************************************/ void touch_init (void) { uint8_t data[3]; //SSP_CFG_Type SSP_ConfigStruct; //SSP_DATA_SETUP_Type sspCfg; pinConfig(); CS_OFF; // initialize SSP configuration structure to default //SSP_ConfigStructInit(&SSP_ConfigStruct); // set clock rate // SSP_ConfigStruct.ClockRate = SSP_CLOCK; // SSP_ConfigStruct.CPHA = SSP_CPHA_SECOND; // SSP_ConfigStruct.CPOL = SSP_CPOL_LO; // // // Initialize SSP peripheral with parameter given in structure above // SSP_Init(SSP_PORT, &SSP_ConfigStruct); // // // Enable SSP peripheral // SSP_Cmd(SSP_PORT, ENABLE); // initialize SSP Chip_SSP_Init(SSP_ID); Chip_SSP_SetMaster(SSP_ID, true); Chip_SSP_SetBitRate(SSP_ID, SSP_CLOCK); Chip_SSP_SetFormat(SSP_ID, SSP_BITS_8, SSP_FRAMEFORMAT_SPI, SSP_CLOCK_MODE3); Chip_SSP_Enable(SSP_ID); data[0] = REF_ON; data[1] = (READ_12BIT_SER(ADS_A2A1A0_vaux) | ADS_PD10_ALL_ON); data[2] = PWRDOWN; CS_ON; //sspCfg.tx_data = data; //sspCfg.rx_data = NULL; //sspCfg.length = 3; //SSP_ReadWrite (SSP_PORT, &sspCfg, SSP_TRANSFER_POLLING); Chip_SSP_WriteFrames_Blocking(SSP_ID, data, 3); CS_OFF; }
/** * @brief analogWrite generate pwm output based on value * @param pin number, value = % of max possible output * @retval None */ void analogWrite(uint16_t pin, uint16_t value){ uint16_t L_oldType = ArduinoPort[pin].PinMode; //Does the pin already configured? uint16_t ChannelPulse; /* Check the parameters */ assert_param(IS_PWM_PIN(pin)); if(L_oldType != OUTPUT_AF){ //Pin was not correctly configured! Do it first! pinConfig(pin, OUTPUT_AF); } ChannelPulse = (uint16_t) (((uint32_t)value * (ArduinoPort[pin].pwmPeriod - 1)) / 100); switch(pin){ case 3: TIM2->CCR4 = ChannelPulse; break; case 5: TIM17->CCR1 = ChannelPulse; break; case 6: TIM16->CCR1 = ChannelPulse; break; case 9: TIM14->CCR1 = ChannelPulse; break; case 10: TIM1->CCR4 = ChannelPulse; break; case 11: TIM3->CCR2 = ChannelPulse; break; default: break; } }
/** * \brief SAMD21 SAM-BA Main loop. * \return Unused (ANSI-C compatibility). */ int main(void) { #if SAM_BA_INTERFACE == SAM_BA_USBCDC_ONLY || SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES P_USB_CDC pCdc; #endif DEBUG_PIN_HIGH; /* Jump in application if condition is satisfied */ check_start_application(); /* We have determined we should stay in the monitor. */ /* System initialization */ board_init(); __enable_irq(); /* Initialize LEDs */ LED_init(); #if !defined(BOARD_LED_FADE_ENABLED) LED_on(); #endif LEDRX_init(); LEDRX_off(); LEDTX_init(); LEDTX_off(); /* Start the sys tick (20 us) */ SysTick_Config(VARIANT_MCK / 50000); /* If SDCARD_ENABLED defined, read optional external pins and run SD Card bootloader (if enabled). */ #if defined(SDCARD_ENABLED) uint8_t bootloaderMode = SD_BOOTLOADER_MODE_NO_UPDATE; #if defined(SAM_BA_INTERFACE_USE_PIN) uint8_t sdcardStatus = SD_BOOTLOADER_NOT_CALLED; #endif #if defined(SDCARD_USE_PIN1) pinConfig(SDCARD_PIN1_PORT, SDCARD_PIN1_PIN, SDCARD_PIN1_CONFIG); #endif #if defined(SDCARD_USE_PIN2) #if !defined(SDCARD_USE_PIN1) #error "main.c: When SDCARD_USE_PIN2 is defined, SDCARD_USE_PIN1 must also be defined" #endif pinConfig(SDCARD_PIN2_PORT, SDCARD_PIN2_PIN, SDCARD_PIN2_CONFIG); #endif #if (defined(SDCARD_USE_PIN1) && defined(SDCARD_USE_PIN2)) bool pin1 = isPinActive(SDCARD_PIN1_PORT, SDCARD_PIN1_PIN, SDCARD_PIN1_POLARITY); bool pin2 = isPinActive(SDCARD_PIN2_PORT, SDCARD_PIN2_PIN, SDCARD_PIN2_POLARITY); if (pin1) { bootloaderMode = SD_BOOTLOADER_MODE_UPDATE; } else if (pin2) { bootloaderMode = SD_BOOTLOADER_MODE_UPDATE2; } #elif defined(SDCARD_USE_PIN1) if (isPinActive(SDCARD_PIN1_PORT, SDCARD_PIN1_PIN, SDCARD_PIN1_POLARITY)) { bootloaderMode = SD_BOOTLOADER_MODE_UPDATE; } #else bootloaderMode = SD_BOOTLOADER_MODE_UPDATE; #endif if (bootloaderMode != SD_BOOTLOADER_MODE_NO_UPDATE) { #if defined(SAM_BA_INTERFACE_USE_PIN) sdcardStatus = sdBootloader(bootloaderMode); #else sdBootloader(bootloaderMode); #endif } #endif /* When using SAM_BA_INTERFACE_USE_PIN, check the pin to determine which SAM-BA interface to use. */ #if defined(SAM_BA_INTERFACE_USE_PIN) uint8_t sambaInterface = SAM_BA_NONE; pinConfig(SAM_BA_INTERFACE_PIN_PORT, SAM_BA_INTERFACE_PIN_PIN, SAM_BA_INTERFACE_PIN_CONFIG); if (isPinActive(SAM_BA_INTERFACE_PIN_PORT, SAM_BA_INTERFACE_PIN_PIN, PIN_POLARITY_ACTIVE_LOW)) { // pin is low #if ((SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_USBCDC_LOW)) sambaInterface = SAM_BA_USBCDC_ONLY; #elif ((SAM_BA_INTERFACE == SAM_BA_USBCDC_ONLY) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_ACTIVE_LOW)) sambaInterface = SAM_BA_USBCDC_ONLY; #elif ((SAM_BA_INTERFACE == SAM_BA_UART_ONLY) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_ACTIVE_LOW)) sambaInterface = SAM_BA_UART_ONLY; #endif } else { // pin is high #if ((SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_USBCDC_HIGH)) sambaInterface = SAM_BA_USBCDC_ONLY; #elif ((SAM_BA_INTERFACE == SAM_BA_USBCDC_ONLY) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_ACTIVE_HIGH)) sambaInterface = SAM_BA_USBCDC_ONLY; #elif ((SAM_BA_INTERFACE == SAM_BA_UART_ONLY) && (SAM_BA_INTERFACE_PIN_POLARITY == PIN_POLARITY_ACTIVE_HIGH)) sambaInterface = SAM_BA_UART_ONLY; #endif } #endif /* Check if we should continue with a SAM-BA interface (if compiled and enabled). * Only show LED_STATUS_FILE_NOT_FOUND if a SAM-BA interface is not available. * LED_STATUS_FILE_NOT_FOUND occurs if there is no SD Card, no FAT16/FAT32 * filesystem, or no file (UPDATE.BIN or UPDATE2.BIN) in the root directory. */ #if defined(SAM_BA_INTERFACE_USE_PIN) #if defined(SDCARD_ENABLED) if (sambaInterface == SAM_BA_NONE) { if (sdcardStatus == SD_BOOTLOADER_FILE_NOT_FOUND) { LED_status(LED_STATUS_FILE_NOT_FOUND); } else if (sdcardStatus == SD_BOOTLOADER_NOT_CALLED) { LED_status(LED_STATUS_NO_SAM_BA_INTERFACE); } } #else #if (SAM_BA_INTERFACE == SAM_BA_NONE) LED_status(LED_STATUS_NO_SAM_BA_INTERFACE); #else if (sambaInterface == SAM_BA_NONE) { LED_status(LED_STATUS_NO_SAM_BA_INTERFACE); } #endif #endif #else #if (SAM_BA_INTERFACE == SAM_BA_NONE) LED_status(LED_STATUS_NO_SAM_BA_INTERFACE); #endif #endif /* Enable the appropriate SAM-BA interfaces. When using SAM_BA_INTERFACE_USE_PIN, * the peripheral and pins are only setup for the selected/enabled interface. */ #if defined(SAM_BA_INTERFACE_USE_PIN) if (sambaInterface == SAM_BA_UART_ONLY) { #endif #if SAM_BA_INTERFACE == SAM_BA_UART_ONLY || SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES /* UART is enabled in all cases */ serial_open(); #endif #if defined(SAM_BA_INTERFACE_USE_PIN) } else if (sambaInterface == SAM_BA_USBCDC_ONLY) { #endif #if SAM_BA_INTERFACE == SAM_BA_USBCDC_ONLY || SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES pCdc = usb_init(); #endif #if defined(SAM_BA_INTERFACE_USE_PIN) } #endif ledDirection = 4; DEBUG_PIN_LOW; /* Wait for a complete enum on usb or a '#' char on serial line */ while (1) { #if defined(SAM_BA_INTERFACE_USE_PIN) if (sambaInterface == SAM_BA_USBCDC_ONLY) { #endif #if SAM_BA_INTERFACE == SAM_BA_USBCDC_ONLY || SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES if (pCdc->IsConfigured(pCdc) != 0) { main_b_cdc_enable = true; } /* Check if a USB enumeration has succeeded and if comm port has been opened */ if (main_b_cdc_enable) { sam_ba_monitor_init(SAM_BA_INTERFACE_USBCDC); /* SAM-BA on USB loop */ while( 1 ) { sam_ba_monitor_run(); } } #endif #if defined(SAM_BA_INTERFACE_USE_PIN) } else if (sambaInterface == SAM_BA_UART_ONLY) { #endif #if SAM_BA_INTERFACE == SAM_BA_UART_ONLY || SAM_BA_INTERFACE == SAM_BA_BOTH_INTERFACES /* Check if a '#' has been received */ if (!main_b_cdc_enable && serial_sharp_received()) { sam_ba_monitor_init(SAM_BA_INTERFACE_USART); /* SAM-BA on Serial loop */ while(1) { sam_ba_monitor_run(); } } #endif #if defined(SAM_BA_INTERFACE_USE_PIN) } #endif } }
/** * @brief pinMode Arduino pin configuration * @param INPUT or OUTPUT * @retval None */ void pinMode(uint16_t pin, uint16_t mode){ /* Check the parameters */ assert_param(IS_ARDUINO_PIN(pin)); assert_param(IS_ARDUINO_MODE(mode)); pinConfig(pin, mode); }
bool HDevice::SetupVideoCapture(IBaseFilter *filter, VideoConfig &config) { ComPtr<IPin> pin; HRESULT hr; bool success; if (config.name.find(L"C875") != std::string::npos || config.name.find(L"C835") != std::string::npos) return SetupEncodedVideoCapture(filter, config, AV_LGP); else if (config.name.find(L"IT9910") != std::string::npos) return SetupEncodedVideoCapture(filter, config, HD_PVR_Rocket); else if (config.name.find(HD_PVR1_NAME) != std::string::npos) return SetupEncodedVideoCapture(filter, config, HD_PVR1); success = GetFilterPin(filter, MEDIATYPE_Video, PIN_CATEGORY_CAPTURE, PINDIR_OUTPUT, &pin); if (!success) { if (SetupExceptionVideoCapture(filter, config)) { return true; } else { Error(L"Could not get video pin"); return false; } } ComQIPtr<IAMStreamConfig> pinConfig(pin); if (pinConfig == NULL) { Error(L"Could not get IAMStreamConfig for device"); return false; } if (config.useDefaultConfig) { MediaTypePtr defaultMT; hr = pinConfig->GetFormat(&defaultMT); if (hr == E_NOTIMPL) { if (!GetPinMediaType(pin, videoMediaType)) { Error(L"Couldn't get pin media type"); return false; } } else if (FAILED(hr)) { ErrorHR(L"Could not get default format for video", hr); return false; } else { videoMediaType = defaultMT; } ConvertVideoSettings(); config.format = config.internalFormat = VideoFormat::Any; } if (!GetClosestVideoMediaType(filter, config, videoMediaType)) { Error(L"Could not get closest video media type"); return false; } hr = pinConfig->SetFormat(videoMediaType); if (FAILED(hr) && hr != E_NOTIMPL) { ErrorHR(L"Could not set video format", hr); return false; } ConvertVideoSettings(); PinCaptureInfo info; info.callback = [this] (IMediaSample *s) {Receive(true, s);}; info.expectedMajorType = videoMediaType->majortype; /* attempt to force intermediary filters for these types */ if (videoConfig.format == VideoFormat::XRGB) info.expectedSubType = MEDIASUBTYPE_RGB32; else if (videoConfig.format == VideoFormat::ARGB) info.expectedSubType = MEDIASUBTYPE_ARGB32; else if (videoConfig.format == VideoFormat::YVYU) info.expectedSubType = MEDIASUBTYPE_YVYU; else if (videoConfig.format == VideoFormat::YUY2) info.expectedSubType = MEDIASUBTYPE_YUY2; else if (videoConfig.format == VideoFormat::UYVY) info.expectedSubType = MEDIASUBTYPE_UYVY; else info.expectedSubType = videoMediaType->subtype; videoCapture = new CaptureFilter(info); videoFilter = filter; graph->AddFilter(videoCapture, L"Video Capture Filter"); graph->AddFilter(videoFilter, L"Video Filter"); return true; }
int main(int argc, char *argv[]) { // A few arrays here are declared with 32 elements, even though // values aren't needed for io[] members where the 'key' value is // GND. This simplifies the code a bit -- no need for mallocs and // tests to create these arrays -- but may waste a handful of // bytes for any declared GNDs. char buf[50], // For sundry filenames c, // Pin input value ('0'/'1') board; // 0=Pi1Rev1, 1=Pi1Rev2, 2=Pi2 int fd, // For mmap, sysfs, uinput i, j, // Asst. counter bitmask, // Pullup enable bitmask timeout = -1, // poll() timeout intstate[32], // Last-read state extstate[32], // Debounced state lastKey = -1; // Last key down (for repeat) unsigned long bitMask, bit; // For Vulcan pinch detect volatile unsigned char shortWait; // Delay counter struct input_event keyEv, synEv; // uinput events struct pollfd p[32]; // GPIO file descriptors progName = argv[0]; // For error reporting signal(SIGINT , signalHandler); // Trap basic signals (exit cleanly) signal(SIGKILL, signalHandler); //not needed /* // Select io[] table for Cupcade (TFT) or 'normal' project. io = (access("/etc/modprobe.d/adafruit.conf", F_OK) || access("/dev/fb1", F_OK)) ? ioStandard : ioTFT; */ io = ioStandard; // If this is a "Revision 1" Pi board (no mounting holes), // remap certain pin numbers in the io[] array for compatibility. // This way the code doesn't need modification for old boards. board = boardType(); if(board == 0) { for(i=0; io[i].pin >= 0; i++) { if( io[i].pin == 2) io[i].pin = 0; else if(io[i].pin == 3) io[i].pin = 1; else if(io[i].pin == 27) io[i].pin = 21; } } // ---------------------------------------------------------------- // Although Sysfs provides solid GPIO interrupt handling, there's // no interface to the internal pull-up resistors (this is by // design, being a hardware-dependent feature). It's necessary to // grapple with the GPIO configuration registers directly to enable // the pull-ups. Based on GPIO example code by Dom and Gert van // Loo on elinux.org if((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) err("Can't open /dev/mem"); gpio = mmap( // Memory-mapped I/O NULL, // Any adddress will do BLOCK_SIZE, // Mapped block length PROT_READ|PROT_WRITE, // Enable read+write MAP_SHARED, // Shared with other processes fd, // File to map (board == 2) ? PI2_GPIO_BASE : // -> GPIO registers PI1_GPIO_BASE); close(fd); // Not needed after mmap() if(gpio == MAP_FAILED) err("Can't mmap()"); // Make combined bitmap of pullup-enabled pins: for(bitmask=i=0; io[i].pin >= 0; i++) if(io[i].key != GND) bitmask |= (1 << io[i].pin); gpio[GPPUD] = 2; // Enable pullup for(shortWait=150;--shortWait;); // Min 150 cycle wait gpio[GPPUDCLK0] = bitmask; // Set pullup mask for(shortWait=150;--shortWait;); // Wait again gpio[GPPUD] = 0; // Reset pullup registers gpio[GPPUDCLK0] = 0; (void)munmap((void *)gpio, BLOCK_SIZE); // Done with GPIO mmap() // ---------------------------------------------------------------- // All other GPIO config is handled through the sysfs interface. sprintf(buf, "%s/export", sysfs_root); if((fd = open(buf, O_WRONLY)) < 0) // Open Sysfs export file err("Can't open GPIO export file"); for(i=j=0; io[i].pin >= 0; i++) { // For each pin of interest... sprintf(buf, "%d", io[i].pin); write(fd, buf, strlen(buf)); // Export pin pinConfig(io[i].pin, "active_low", "0"); // Don't invert if(io[i].key == GND) { // Set pin to output, value 0 (ground) if(pinConfig(io[i].pin, "direction", "out") || pinConfig(io[i].pin, "value" , "0")) err("Pin config failed (GND)"); } else { // Set pin to input, detect rise+fall events if(pinConfig(io[i].pin, "direction", "in") || pinConfig(io[i].pin, "edge" , "both")) err("Pin config failed"); // Get initial pin value sprintf(buf, "%s/gpio%d/value", sysfs_root, io[i].pin); // The p[] file descriptor array isn't necessarily // aligned with the io[] array. GND keys in the // latter are skipped, but p[] requires contiguous // entries for poll(). So the pins to monitor are // at the head of p[], and there may be unused // elements at the end for each GND. Same applies // to the intstate[] and extstate[] arrays. if((p[j].fd = open(buf, O_RDONLY)) < 0) err("Can't access pin value"); intstate[j] = 0; if((read(p[j].fd, &c, 1) == 1) && (c == '0')) intstate[j] = 1; extstate[j] = intstate[j]; p[j].events = POLLPRI; // Set up poll() events p[j].revents = 0; j++; } } // 'j' is now count of non-GND items in io[] table close(fd); // Done exporting // ---------------------------------------------------------------- // Set up uinput #if 1 // Retrogame normally uses /dev/uinput for generating key events. // Cupcade requires this and it's the default. SDL2 (used by // some newer emulators) doesn't like it, wants /dev/input/event0 // instead. Enable that code by changing to "#if 0" above. if((fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK)) < 0) err("Can't open /dev/uinput"); if(ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0) err("Can't SET_EVBIT"); for(i=0; io[i].pin >= 0; i++) { if(io[i].key != GND) { if(ioctl(fd, UI_SET_KEYBIT, io[i].key) < 0) err("Can't SET_KEYBIT"); } } if(ioctl(fd, UI_SET_KEYBIT, vulcanKey) < 0) err("Can't SET_KEYBIT"); struct uinput_user_dev uidev; memset(&uidev, 0, sizeof(uidev)); snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "retrogame"); uidev.id.bustype = BUS_USB; uidev.id.vendor = 0x1; uidev.id.product = 0x1; uidev.id.version = 1; if(write(fd, &uidev, sizeof(uidev)) < 0) err("write failed"); if(ioctl(fd, UI_DEV_CREATE) < 0) err("DEV_CREATE failed"); #else // SDL2 prefers this event methodology if((fd = open("/dev/input/event0", O_WRONLY | O_NONBLOCK)) < 0) err("Can't open /dev/input/event0"); #endif // Initialize input event structures memset(&keyEv, 0, sizeof(keyEv)); keyEv.type = EV_KEY; memset(&synEv, 0, sizeof(synEv)); synEv.type = EV_SYN; synEv.code = SYN_REPORT; synEv.value = 0; // 'fd' is now open file descriptor for issuing uinput events // ---------------------------------------------------------------- // Monitor GPIO file descriptors for button events. The poll() // function watches for GPIO IRQs in this case; it is NOT // continually polling the pins! Processor load is near zero. while(running) { // Signal handler can set this to 0 to exit // Wait for IRQ on pin (or timeout for button debounce) if(poll(p, j, timeout) > 0) { // If IRQ... for(i=0; i<j; i++) { // Scan non-GND pins... if(p[i].revents) { // Event received? // Read current pin state, store // in internal state flag, but // don't issue to uinput yet -- // must wait for debounce! lseek(p[i].fd, 0, SEEK_SET); read(p[i].fd, &c, 1); if(c == '0') intstate[i] = 1; else if(c == '1') intstate[i] = 0; p[i].revents = 0; // Clear flag } } timeout = debounceTime; // Set timeout for debounce c = 0; // Don't issue SYN event // Else timeout occurred } else if(timeout == debounceTime) { // Button debounce timeout // 'j' (number of non-GNDs) is re-counted as // it's easier than maintaining an additional // remapping table or a duplicate key[] list. bitMask = 0L; // Mask of buttons currently pressed bit = 1L; for(c=i=j=0; io[i].pin >= 0; i++, bit<<=1) { if(io[i].key != GND) { // Compare internal state against // previously-issued value. Send // keystrokes only for changed states. if(intstate[j] != extstate[j]) { extstate[j] = intstate[j]; keyEv.code = io[i].key; keyEv.value = intstate[j]; if ((keyEv.code==KEY_0)&&(keyEv.value==1)) { system("sudo halt"); //system("echo \"that works\""); } else { write(fd, &keyEv, sizeof(keyEv)); } //write(fd, &keyEv, //sizeof(keyEv)); c = 1; // Follow w/SYN event if(intstate[j]) { // Press? // Note pressed key // and set initial // repeat interval. lastKey = i; timeout = repTime1; } else { // Release? // Stop repeat and // return to normal // IRQ monitoring // (no timeout). lastKey = timeout = -1; } } j++; if(intstate[i]) bitMask |= bit; } } // If the "Vulcan nerve pinch" buttons are pressed, // set long timeout -- if this time elapses without // a button state change, esc keypress will be sent. if((bitMask & vulcanMask) == vulcanMask) timeout = vulcanTime; } else if(timeout == vulcanTime) { // Vulcan timeout occurred // Send keycode (MAME exits or displays exit menu) keyEv.code = vulcanKey; for(i=1; i>= 0; i--) { // Press, release keyEv.value = i; write(fd, &keyEv, sizeof(keyEv)); usleep(10000); // Be slow, else MAME flakes write(fd, &synEv, sizeof(synEv)); usleep(10000); } timeout = -1; // Return to normal processing c = 0; // No add'l SYN required } else if(lastKey >= 0) { // Else key repeat timeout if(timeout == repTime1) timeout = repTime2; else if(timeout > 30) timeout -= 5; // Accelerate c = 1; // Follow w/SYN event keyEv.code = io[lastKey].key; keyEv.value = 2; // Key repeat event write(fd, &keyEv, sizeof(keyEv)); } if(c) write(fd, &synEv, sizeof(synEv)); } // ---------------------------------------------------------------- // Clean up ioctl(fd, UI_DEV_DESTROY); // Destroy and close(fd); // close uinput cleanup(); // Un-export pins puts("Done."); return 0; }
int main(int argc, char *argv[]) { // A few arrays here are declared with IOLEN elements, even though // values aren't needed for io[] members where the 'key' value is // GND. This simplifies the code a bit -- no need for mallocs and // tests to create these arrays -- but may waste a handful of // bytes for any declared GNDs. char buf[50], // For sundry filenames c; // Pin input value ('0'/'1') int fd, // For mmap, sysfs, uinput i, j, // Asst. counter bitmask, // Pullup enable bitmask timeout = -1, // poll() timeout intstate[IOLEN], // Last-read state extstate[IOLEN]; // Debounced state volatile unsigned char shortWait; // Delay counter struct uinput_user_dev uidev; // uinput device struct input_event keyEv, synEv; // uinput events struct pollfd p[IOLEN]; // GPIO file descriptors progName = argv[0]; // For error reporting signal(SIGINT , signalHandler); // Trap basic signals (exit cleanly) signal(SIGKILL, signalHandler); // ---------------------------------------------------------------- // Although Sysfs provides solid GPIO interrupt handling, there's // no interface to the internal pull-up resistors (this is by // design, being a hardware-dependent feature). It's necessary to // grapple with the GPIO configuration registers directly to enable // the pull-ups. Based on GPIO example code by Dom and Gert van // Loo on elinux.org if((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) err("Can't open /dev/mem"); gpio = mmap( // Memory-mapped I/O NULL, // Any adddress will do BLOCK_SIZE, // Mapped block length PROT_READ|PROT_WRITE, // Enable read+write MAP_SHARED, // Shared with other processes fd, // File to map GPIO_BASE ); // Offset to GPIO registers close(fd); // Not needed after mmap() if(gpio == MAP_FAILED) err("Can't mmap()"); // Make combined bitmap of pullup-enabled pins: for(bitmask=i=0; i<IOLEN; i++) if(io[i].key != GND) bitmask |= (1 << io[i].pin); gpio[GPPUD] = 2; // Enable pullup for(shortWait=150;--shortWait;); // Min 150 cycle wait gpio[GPPUDCLK0] = bitmask; // Set pullup mask for(shortWait=150;--shortWait;); // Wait again gpio[GPPUD] = 0; // Reset pullup registers gpio[GPPUDCLK0] = 0; (void)munmap((void *)gpio, BLOCK_SIZE); // Done with GPIO mmap() // ---------------------------------------------------------------- // All other GPIO config is handled through the sysfs interface. sprintf(buf, "%s/export", sysfs_root); if((fd = open(buf, O_WRONLY)) < 0) // Open Sysfs export file err("Can't open GPIO export file"); for(i=j=0; i<IOLEN; i++) { // For each pin of interest... sprintf(buf, "%d", io[i].pin); write(fd, buf, strlen(buf)); // Export pin pinConfig(io[i].pin, "active_low", "0"); // Don't invert if(io[i].key == GND) { // Set pin to output, value 0 (ground) if(pinConfig(io[i].pin, "direction", "out") || pinConfig(io[i].pin, "value" , "0")) err("Pin config failed (GND)"); } else { // Set pin to input, detect rise+fall events if(pinConfig(io[i].pin, "direction", "in") || pinConfig(io[i].pin, "edge" , "both")) err("Pin config failed"); // Get initial pin value sprintf(buf, "%s/gpio%d/value", sysfs_root, io[i].pin); // The p[] file descriptor array isn't necessarily // aligned with the io[] array. GND keys in the // latter are skipped, but p[] requires contiguous // entries for poll(). So the pins to monitor are // at the head of p[], and there may be unused // elements at the end for each GND. Same applies // to the intstate[] and extstate[] arrays. if((p[j].fd = open(buf, O_RDONLY)) < 0) err("Can't access pin value"); intstate[j] = 0; if((read(p[j].fd, &c, 1) == 1) && (c == '0')) intstate[j] = 1; extstate[j] = intstate[j]; p[j].events = POLLPRI; // Set up poll() events p[j].revents = 0; j++; } } // 'j' is now count of non-GND items in io[] table close(fd); // Done exporting // ---------------------------------------------------------------- // Set up uinput if((fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK)) < 0) err("Can't open /dev/uinput"); if(ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0) err("Can't SET_EVBIT"); for(i=0; i<IOLEN; i++) { if(io[i].key != GND) { if(ioctl(fd, UI_SET_KEYBIT, io[i].key) < 0) err("Can't SET_KEYBIT"); } } memset(&uidev, 0, sizeof(uidev)); snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "retrogame"); uidev.id.bustype = BUS_USB; uidev.id.vendor = 0x1; uidev.id.product = 0x1; uidev.id.version = 1; if(write(fd, &uidev, sizeof(uidev)) < 0) err("write failed"); if(ioctl(fd, UI_DEV_CREATE) < 0) err("DEV_CREATE failed"); // Initialize input event structures memset(&keyEv, 0, sizeof(keyEv)); keyEv.type = EV_KEY; memset(&synEv, 0, sizeof(synEv)); synEv.type = EV_SYN; synEv.code = SYN_REPORT; synEv.value = 0; // 'fd' is now open file descriptor for issuing uinput events // ---------------------------------------------------------------- // Monitor GPIO file descriptors for button events. The poll() // function watches for GPIO IRQs in this case; it is NOT // continually polling the pins! Processor load is near zero. while(running) { // Signal handler can set this to 0 to exit // Wait for IRQ on pin (or timeout for button debounce) if(poll(p, j, timeout) > 0) { // If IRQ... for(i=0; i<j; i++) { // Scan non-GND pins... if(p[i].revents) { // Event received? // Read current pin state, store // in internal state flag, but // don't issue to uinput yet -- // must wait for debounce! lseek(p[i].fd, 0, SEEK_SET); read(p[i].fd, &c, 1); if(c == '0') intstate[i] = 1; else if(c == '1') intstate[i] = 0; p[i].revents = 0; // Clear flag } } timeout = 20; // Set timeout for debounce } else { // Else timeout occurred; input is debounced // 'j' (number of non-GNDs) is re-counted as // it's easier than maintaining an additional // remapping table or a duplicate key[] list. for(c=i=j=0; i<IOLEN; i++) { if(io[i].key != GND) { // Compare internal state against // previously-issued value. Send // keystrokes only for changed states. if(intstate[j] != extstate[j]) { extstate[j] = intstate[j]; keyEv.code = io[i].key; keyEv.value = intstate[j]; write(fd, &keyEv, sizeof(keyEv)); c = 1; // Follow w/SYN event } j++; } } if(c) write(fd, &synEv, sizeof(synEv)); timeout = -1; // Return to normal IRQ monitoring } } // ---------------------------------------------------------------- // Clean up ioctl(fd, UI_DEV_DESTROY); // Destroy and close(fd); // close uinput cleanup(); // Un-export pins puts("Done."); return 0; }
int main(void) { // uint8_t test_comms = 'z'; // uint8_t setupState = 1; // uint8_t *setupData; // Pointer to hold setup data USART_Init(BAUD_PRESCALE); // Initialise USART pinConfig(); // Initialize Pin Configuration // Main loop while(1) { // while(setupState) // Wait in this while loop while waiting for user conig // { // setupData = getSetup(); // if ((*setupData + 0) == 1) // 3rd Element of pointer is init flag. If true break while loop and start. // { // setupState = 0; // } // } // PORTB |= (1<<PB3); // _delay_ms(1000); // PORTB &= ~(1<<PB3); if (PINC & (1<<PC0)) { PORTB |= (1<<PB3); // u8temp = running_count == 0? 't' : 'm'; if (tst_count < 1) { for(uint8_t i = RxBuffer.index; i > 0; i--) { u8test = RxBuffer.buffer[i-1]; TxBufferWrite(&TxBuffer, u8test); tst_count++; } } running_count++; } else { PORTB &= ~(1<<PB3); tst_count = 0; } if (PINC & (1<<PC7)) { if(tst_count_2 < 1){ PORTB |= (1<<PB3); // uint8_t test_data = 8; // USART_Test_Transmit(tst_value); USART_Transmit(&TxBuffer); RxBufferReset(&RxBuffer); // USART_Transmit(&RxBuffer); tst_count_2++; } } else { PORTB &= ~(1<<PB3); tst_count_2 = 0; } // if (receivedByte == 'k') { // PORTB |= (1<<PB3); // } // else { // PORTB &= ~(1<<PB3); // } } }
/** * \brief Check the application startup condition * */ static void check_start_application(void) { #if (!defined DEBUG) || ((defined DEBUG) && (DEBUG == 0)) uint32_t* pulSketch_Start_Address; #endif /* * Test sketch stack pointer @ &__sketch_vectors_ptr * Stay in SAM-BA if value @ (&__sketch_vectors_ptr) == 0xFFFFFFFF (Erased flash cell value) */ if (__sketch_vectors_ptr == 0xFFFFFFFF) { /* Stay in bootloader */ return; } /* * Load the sketch Reset Handler address * __sketch_vectors_ptr is exported from linker script and point on first 32b word of sketch vector table * Remember, variables exported from a linker script are different than normal variables (only address, no value) * First 32b word is sketch stack * Second 32b word is sketch entry point: Reset_Handler() */ pulSketch_Start_Address = &__sketch_vectors_ptr ; pulSketch_Start_Address++ ; /* * Test vector table address of sketch @ &__sketch_vectors_ptr * Stay in SAM-BA if this function is not aligned enough, ie not valid */ if ( ((uint32_t)(&__sketch_vectors_ptr) & ~SCB_VTOR_TBLOFF_Msk) != 0x00) { /* Stay in bootloader */ return; } #if defined(BOOT_LOAD_PIN_ENABLED) pinConfig(BOOT_LOAD_PIN_PORT, BOOT_LOAD_PIN, BOOT_LOAD_PIN_CONFIG); /* Allow time for debouncing capacitor (if using a button) to charge (10ms) */ delayUs(10000UL); // Read the BOOT_LOAD_PIN status if (isPinActive(BOOT_LOAD_PIN_PORT, BOOT_LOAD_PIN, BOOT_LOAD_PIN_POLARITY)) { // Stay in bootloader return; } #endif #if defined(BOOT_DOUBLE_TAP_ENABLED) #define DOUBLE_TAP_MAGIC 0x07738135 #if (SAMD21 || SAMD11) if (PM->RCAUSE.bit.POR) #elif (SAML21 || SAMC21 || SAMD51) if (RSTC->RCAUSE.bit.POR) #else #error "main.c: Missing dependency or unsupported chip. Please install CMSIS-Atmel from MattairTech (see Prerequisites for Building in README.md)." #endif { /* On power-on initialize double-tap */ BOOT_DOUBLE_TAP_DATA = 0; } else { if (BOOT_DOUBLE_TAP_DATA == DOUBLE_TAP_MAGIC) { /* Second tap, stay in bootloader */ BOOT_DOUBLE_TAP_DATA = 0; return; } /* First tap */ BOOT_DOUBLE_TAP_DATA = DOUBLE_TAP_MAGIC; /* Wait 0.5sec to see if the user tap reset again */ delayUs(500000UL); /* Timeout happened, continue boot... */ BOOT_DOUBLE_TAP_DATA = 0; } #endif /* Rebase the Stack Pointer */ __set_MSP( (uint32_t)(__sketch_vectors_ptr) ); /* Rebase the vector table base address */ SCB->VTOR = ((uint32_t)(&__sketch_vectors_ptr) & SCB_VTOR_TBLOFF_Msk); /* Jump to application Reset Handler in the application */ asm("bx %0"::"r"(*pulSketch_Start_Address)); }
void main( void ) { u8 i, ucChar, *ucEeproms, ucBuffer[ 40 ]; sysInit(); socketInit(); rfInit(); print( COM3, "\rV2 RFID: 0x%X", socketGetID()); //mpl115a2Init( TX1, RX1, NONE, NONE ); //print( COM3, "\rPressure: %f", mpl115a2ReadkPa() ); //print( COM3, "\rTemp: %f", mpl115a2ReadTemp() ); //i2cConfig( &globalGasSensorDigipot, DIGIPOT_BASEADDRESS|3, TX1, RX1, I2CSPEEDFAST ); //digipotSetWiper( &globalGasSensorDigipot, 2, 0 ); //eepromOpen( 0x2F, TX1, RX1, NONE ); //eepromPutString( 0, "Test" ); pinConfig( MCO, OUT ); pinSet( MCO, HIGH ); gasSensorInit(); //print( COM3, "\rGas Sensor: %f", gasSensorRead() ); //gasSensorSetGain( 0,0 ); //print( COM3, "\rGas Sensor: %f", gasSensorRead() ); //gasSensorSetGain( 200,200 ); //print( COM3, "\rGas Sensor: %f", gasSensorRead() ); //eepromGetBuffer( 0, ucBuffer, len( "test" ) ); //print( COM3, "\rEeprom: ucBuffer ); //print( COM3, "\rEEPROM Direct Read: " ); /*for( i = 0; i < len( "test" ); i++ ){ ucChar = eepromGetChar( i ); if( isAlphaOrNumeric( ucChar ) ) { print( COM3, "%c", ucChar ); } else{ print( COM3, "(%d)", ucChar );//ucBuffer, len( "humidity" ) ); } // else } // for */ /* // Test for LCD code if( isStringSame( ucBuffer, "<shield lcd>" ) ){ print( COM3, "\rLCD Shield Detected" ); fileOpenResource( &fileFont, (u8*)PYGMY_orbitron18 ); fontLoad( &fileFont, &fontOrbitron18 ); fontSetAll( &fontOrbitron18 ); pinConfig( A0, PULLUP ); pinConfig( D3, PULLUP ); pinConfig( TA0, PULLUP ); pinConfig( DAC1, PULLUP ); pinConfig( DAC2, PULLUP ); pinConfig( TX2, PULLUP ); pinConfig( RX2, PULLUP ); drawMainMenu(); } else{ hih5030Init( A2, A3 ); } // else */ //taskNewSimple( "humidity", 1000, (void*)threadRFHumiditySave ); //gemInit(); //fileOpen( &pygmyFile, "picon128", READ ); //drawImage( 0,0, &pygmyFile, 0 ); /*ucBuffer = sysAllocate( 5 ); copyString( "Test", ucBuffer ); ucBuffer = sysReallocate( ucBuffer, 20 ); appendString( "ThisToo", ucBuffer ); print( COM3, "\rTest String: %s", ucBuffer );*/ //pinConfig( SHIELD_CENTER, PULLUP ); //pinInterrupt( gemClickMenu, SHIELD_CENTER, TRIGGER_RISING|TRIGGER_FALLING ); //drawRect( 0, 20, 127, 40, VISIBLE|BORDER|ROUNDED, 8); //gemDrawMenu(); //drawWidget( &btnOK ); //gemInit(); //sysFree( ucBuffer ); //fileOpen( &pygmyFile, "jpeg", READ ); //drawJPEG( &pygmyFile, 0, 0 ); //drawPNG( &pygmyFile, 0, 0 ); /*mstatsTemp mstats(); print( COM3, "\rbytes_total: %d", bytes_total ); print( COM3, "\rchunks_used: %d", chunks_used ); print( COM3, "\rbytes_used: %d", bytes_used ); print( COM3, "\rchunks_free: %d", chunks_free ); print( COM3, "\rbytes_free: %d", bytes_free );*/ while(1){;} }