/** * Function to stop a SPI transaction on the given device. * This is used to set the SlaveSelect to idle after a transaction occurred thus releasing the bus. * \param pointer - SPIContext pointer * \return none */ void SPIStop(SPIContext * obj) { vTaskSuspendAll(); #ifndef SPI2_FLASH #ifdef SPI_DBG uartwrite(1,"[SPI_DBG] SPI stop, checking SS\n"); #endif if(obj->ss_pin != SPI_OPT_NO_SS) { #ifdef SPI_DBG uartwrite(1,"[SPI_DBG] Pulling SS up\n"); #endif if(SPI2STATbits.SPITBF) Delay10us(obj->delay); IOPut(obj->ss_pin,on); } #else if(SPI2STATbits.SPITBF) Delay10us(obj->delay); LATDbits.LATD6=1; #endif xTaskResumeAll(); }
//----------------------------------------------------------------------------- // Envoi des données au LCD // aData: les données à transmettre au LCD //----------------------------------------------------------------------------- static void mLcd_SendLcdData(UINT8 aData) { // E inactif Delay10us(1); mLCD_E=1; mLCD_RW=0; mLCD_RS=1; // écriture des données //iDio_SetPortB(aData); mLCD_D0= aData & 0x01; mLCD_D1= (aData & 0x02)>>1; mLCD_D2= (aData & 0x04)>>2; mLCD_D3= (aData & 0x08)>>3; mLCD_D4= (aData & 0x10)>>4; mLCD_D5= (aData & 0x20)>>5; mLCD_D6= (aData & 0x40)>>6; mLCD_D7= (aData & 0x80)>>7; Delay10us(1); // Bit E (start data read/write) à 1 // le bits E doit être à 1 pendant au moins 230nsec //iDio_SetPortK(kMaskIo0,kIoOn); mLCD_E=0; Delay10us(1); // Bit E (start data read/write) à 0 // les data sont latchés à ce moment là //iDio_SetPortK(kMaskIo0,kIoOff); mLCD_E=1; mLCD_RW=0; mLCD_RS=0; }
//----------------------------------------------------------------------------- // Ouverture de l'interface (init du display) //----------------------------------------------------------------------------- void mLcd_Open(void) { unsigned long i = 0 ; //power supply of LCD mLCD_VDD=1; mLCD_V0=1; DelayMs(40); // Selection du mode 2 lignes + display on mLcd_SendLcdCmd(0x3C); Delay10us(4); // attendre ~39us // Selection du mode pas curseur + display on mLcd_SendLcdCmd(0x0C); Delay10us(4); // attendre ~39us //Display clear mLcd_SendLcdCmd(0x01); DelayMs(2); // attendre ~1.53ms mLcd_SendLcdCmd(0x06); Delay10us(4); }
static void writeToDisplayPort( UINT8 value ) { UINT8 shift = 0x01; DIGIT_PORT_1 = ~(0XFF); //switch off display DIGIT_PORT_2 = ~(0XFF); DIGIT_PORT_3 = ~(0XFF); DIGIT_PORT_4 = ~(0XFF); Delay10us(1); DATA_PORT = value; if(digitDisplay.digitIndex < 8) { shift <<= digitDisplay.digitIndex; DIGIT_PORT_1 = shift; DIGIT_PORT_2 = shift; DIGIT_PORT_3 = shift; DIGIT_PORT_4 = shift; } Delay10us(1); }
/******************************************************************************* * PUBLIC FUNCTION: Disp_GLCDCommand * * PARAMETERS: * ~ command byte * * RETURN: * ~ void * * DESCRIPTIONS: * Send command byte to the GLCD controller. * Please refer to the datasheet for the list of commands. *******************************************************************************/ void Disp_GLCDCommand(unsigned char command) { RS = 0; //Delay10us(2); E = 1; Delay10us(2); // Move higher nibble first DB4 = (command & (1 << 4)) >> 4; DB5 = (command & (1 << 5)) >> 5; DB6 = (command & (1 << 6)) >> 6; DB7 = (command & (1 << 7)) >> 7; Delay10us(2); E = 0; E = 1; Delay10us(2); // Then move the lower nibble DB4 = (command & (1 << 0)) >> 0; DB5 = (command & (1 << 1)) >> 1; DB6 = (command & (1 << 2)) >> 2; DB7 = (command & (1 << 3)) >> 3; Delay10us(2); E = 0; Delay10us(2); // Please increase this delay if the screen is not showing things correctly. }
void KT_I2C_Start(void) { SDA_1; Delay10us(); SCL_1; Delay10us(); SDA_0; Delay10us(); SCL_0; Delay10us(); }
void KT_I2C_Stop(void) { SCL_0; Delay10us(); SDA_0; Delay10us(); SCL_1; Delay10us(); SDA_1; Delay10us(); }
void display_row (unsigned char p_byRow) { unsigned char i,j; unsigned char k; if(p_byRow == 1) // if row is same as saying if row is non zero, in our case its row = 1 { // Set the address to the second line lcd_cmd(0xC0); Delay10us(5); // Output second line for(i = 0; i < 16u; i++) { // Erase the rest of the line if a null char is // encountered (good for printing strings directly) if(LCDText[i] == 0u) { for(j=i; j < 16u; j++) { LCDText[j] = ' '; } } lcd_dat(LCDText[i]); Delay10us(5); } } else { lcd_cmd(0x80); DelayMs(2); // Output first line for(i = 0; i < 16u; i++) { // Erase the rest of the line if a null char is // encountered (good for printing strings directly) if(LCDText[i] == 0u) { for(j=i; j < 16u; j++) { LCDText[j] = ' '; } } lcd_dat(LCDText[i]); Delay10us(5); } } }
uint8_t KT_I2C_Write(uint8_t u8Data) { uint8_t i, ret; for(i=0; i<8; ++i) { if(u8Data&0x80) { SDA_1; } else { SDA_0; } Delay10us(); SCL_1; Delay10us(); Delay10us(); SCL_0; Delay10us(); u8Data<<=1; } //kiem tra ack SDA_1; Delay10us(); SCL_1; Delay10us(); if(SDA_VAL) { ret=1; } else { ret=0; } Delay10us(); SCL_0; Delay10us(); return ret; }
uint8_t KT_I2C_Read(uint8_t u8Ack) { uint8_t i, ret; for(i=0; i<8; ++i) { ret<<=1; Delay10us(); SCL_1; Delay10us(); if(SDA_VAL) { ret|=0x01; } Delay10us(); SCL_0; Delay10us(); } //kiem tra ack if(u8Ack) { SDA_1; } else { SDA_0; } Delay10us(); SCL_1; Delay10us(); Delay10us(); SCL_0; Delay10us(); return ret; }
void ConsoleInit(void) { #if defined(ENABLE_CONSOLE) unsigned long i = 0; // Don't attempt anything if not connected if (!USB_BUS_SENSE) return; USBInitializeSystem(); USBDeviceAttach(); // This will only work in an interrupt driven USB system - exits on button press, only exits after enumeration is usb is detected while (USBDeviceState < CONFIGURED_STATE) { #ifndef USB_INTERRUPT USBDeviceTasks(); // Interrupt or polling method. If using polling, must call #endif USBProcessIO(); Delay10us(1); // Timed-out starting connection (perhaps a charger or disconnected?) if (i++ >= 1000000ul) { // The USB connection has failed -- if we're not using the PLL when the radio is on, turn it off now USBDeviceDetach(); return; } } // Gives host time to assign CDC port i = 0; while (USBDeviceState >= CONFIGURED_STATE && i++ < 600000ul) { MRF_LED = 1; #ifndef USB_INTERRUPT USBDeviceTasks(); // Interrupt or polling method. If using polling, must call #endif USBProcessIO(); Delay10us(10); if (usb_haschar()) { break; } } MRF_LED = 0; #endif return; }
/* *------------------------------------------------------------------------------ * void PutrsUART(const rom char *data) * * Summary : Send the rom character string through UART * * Input : const rom char *data - pointer to the null terminated string rom. * * Output : None *------------------------------------------------------------------------------ */ void PutrsUART(const rom char *data) { TX_EN = 1; //enable the tx control for rs485 communication Delay10us(1); do { // Wait till the last bit trasmision while(BusyUSART()); // Transmit a byte putcUSART(*data++); } while( *data != '\0'); TX_EN = 0; //disable the tx control for rs485 communication Delay10us(1); }
void KT_I2C_Init(void) { GPIO_InitPara GPIO_InitStructure; RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_GPIOB,ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7; GPIO_InitStructure.GPIO_Speed = GPIO_SPEED_50MHZ; GPIO_InitStructure.GPIO_Mode = GPIO_MODE_OUT_OD; GPIO_Init(GPIOB,&GPIO_InitStructure); SDA_1; SCL_1; Delay10us(); Delay10us(); }
/** * Delays for the given time. * @param ms Time to delay = given time x 1ms */ void DelayMs(unsigned char ms) { while (ms--) { Delay10us(99); } }
void KT_I2C_Init(void) { //GPIO_InitTypeDef GPIO_InitStructure; //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE); //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD; //GPIO_Init(GPIOB,&GPIO_InitStructure); GPIO_Init(GPIOD, GPIO_PIN_4, GPIO_MODE_OUT_OD_LOW_FAST); GPIO_Init(GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_OD_LOW_FAST); SDA_1; SCL_1; Delay10us(); Delay10us(); }
/****************************************************************************** * Function: void LCDUpdate(void) * * PreCondition: LCDInit() must have been called once * * Input: LCDText[] * * Output: None * * Side Effects: None * * Overview: Copies the contents of the local LCDText[] array into the * LCD's internal display buffer. Null terminators in * LCDText[] terminate the current line, so strings may be * printed directly to LCDText[]. * * Note: None *****************************************************************************/ void LCDUpdate(void) { BYTE i, j; // Go home LCDWrite(0, 0x02); DelayMs(2); // Output first line for(i = 0; i < 16u; i++) { // Erase the rest of the line if a null char is // encountered (good for printing strings directly) if(LCDText[0][i] == 0u) { for(j=i; j < 16u; j++) { LCDText[0][j] = ' '; } } LCDWrite(1, LCDText[0][i]); Delay10us(5); } // Set the address to the second line LCDWrite(0, 0xC0); Delay10us(5); // Output second line // for(i = 16; i < 32u; i++) for(i = 0; i < 16u; i++) { // Erase the rest of the line if a null char is // encountered (good for printing strings directly) if(LCDText[1][i] == 0u) { //for(j=i; j < 32u; j++) for(j=i; j < 16u; j++) { LCDText[1][j] = ' '; } } LCDWrite(1, LCDText[1][i]); Delay10us(5); } }
/**************************************************************************** Function: void DelayMs( UINT16 ms ) Description: This routine performs a software delay in intervals of 1 millisecond. Precondition: None Parameters: UINT16 ms - number of one millisecond delays to perform at once. Returns: None Remarks: None ***************************************************************************/ void DelayMs( UINT16 ms ) { volatile UINT8 i; while (ms--) { i = 4; while (i--){Delay10us( 25 );} } }
// *-------------------------------------------* UINT16 ADC_Conversion(void){ AD1CON1bits.SAMP=1; // Inicia adquisicion Delay10us(5); AD1CON1bits.SAMP=0; // Inicia conversion Nop(); while(AD1CON1bits.DONE==0); // Esperamos conversion return(ADC1BUF0); }
void DelayMs(WORD ms){ unsigned char i; while(ms--){ i=4; while(i--){ Delay10us(25); } } }
void DelayPreServo(void) { unsigned char i; i=4; while(i--) { Delay10us(18); } }
// Purpose: Write a BYTE of data // Inputs: The BYTE of data to write void s1d13700_SendByte(BYTE data) { S1D13700_TRIS_DATA &= 0xFFFFFF00; //S1D13700_WR = 0; S1D13700_A0 = 0; S1D13700_CS = 0; Delay10us(); S1D13700_E = 1; Delay10us(); S1D13700_WR_DATA = data; Delay10us(); S1D13700_E = 0; Delay10us(); //S1D13700_WR = 1; S1D13700_CS = 1; S1D13700_E = 1; }
// Purpose: Send an 8 bit command // Inputs: The command to send void s1d13700_SendCMD(BYTE cmd) { S1D13700_TRIS_DATA &= 0xFFFFFF00; //S1D13700_WR = 0; S1D13700_A0 = 1; S1D13700_CS = 0; Delay10us(); S1D13700_E = 1; Delay10us(); S1D13700_WR_DATA = cmd; Delay10us(); S1D13700_E = 0; Delay10us(); //S1D13700_WR = 1; S1D13700_CS = 1; S1D13700_E = 1; }
void DelayMs(uint16_t ms) { unsigned char i; while (ms--) { i = 4; while (i--) { Delay10us(25); } } }
/************************************************************************ * Function: void GfxTconWriteCommand(BYTE index, WORD value) * * Overview: This writes a word to SPI by calling the write byte * routine. * * Input: index - The index (or address) of the register to be written. * value - The value that will be written to the register. * * Output: none * ************************************************************************/ void GfxTconWriteCommand(WORD index, WORD value) { GfxTconSetIO(BB_CS, 0); // Index GfxTconSetIO(BB_DC, 0); GfxTconWriteByte(((WORD_VAL) index).v[1]); GfxTconWriteByte(((WORD_VAL) index).v[0]); GfxTconSetIO(BB_CS, 1); Delay10us(1); GfxTconSetIO(BB_CS, 0); // Data GfxTconSetIO(BB_DC, 1); GfxTconWriteByte(((WORD_VAL) value).v[1]); GfxTconWriteByte(((WORD_VAL) value).v[0]); GfxTconSetIO(BB_CS, 1); Delay10us(1); }
/**************************************************************************** Function: void DelayMs( unsigned short int ms ) Description: This routine performs a software delay in intervals of 1 millisecond. Precondition: None Parameters: UINT16 ms - number of one millisecond delays to perform at once. Returns: None Remarks: None ***************************************************************************/ void DelayMs( unsigned short int ms ) { volatile unsigned char i; while (ms--) { i = 4; while (i--) { Delay10us( 25 ); } } }
/* *------------------------------------------------------------------------------ * void WriteDataToDisplay(UINT8 digit, UINT8 data) * * Summary : Write one byte data on the bus * * Input : UINT8 digit - digit number to write the data * UINT8 dataByte - data byte for the digit * * Output : None *------------------------------------------------------------------------------ */ void WriteDataToDisplay(UINT8 digit, UINT8 data) { if( digit >=64 ) { digit+=128; } DISPLAY_CONTROL = DISPLAY_DISABLE; //disable the display DIGIT_PORT = digit; //set the address DATA_PORT = data; // write data DISPLAY_CONTROL = DISPLAY_ENABLE; //enable the display Delay10us(10); //delay for the data to stabilize DISPLAY_CONTROL = DISPLAY_DISABLE; //disable it again }
//----------------------------------------------------------------------------- // Ecriture sur le LCD complet // aChar: Pointeur sur la chaîne de charactère à afficher 32 caractères //----------------------------------------------------------------------------- void mLcd_WriteEntireDisplay(UINT8* aChar) { UINT16 i; // Attente du busy flag=0 while(TRUE==mLcd_ReadLcdBusy()); // Efface la mémoire mLcd_SendLcdCmd(kReturnHome); DelayMs(2); // Envoi des 32 caractères à l'affichage for (i=0;i<kMaxLcdCarac;i++) { // Attente du busy=0 while(TRUE==mLcd_ReadLcdBusy()); // Envoi du caractère au LCD mLcd_SendLcdData(*aChar); Delay10us(5); // Si fin de 1ère ligne on passe à la 2e if((kNbOfChar-1)==i) { // Attente du busy flag=0 while(TRUE==mLcd_ReadLcdBusy()); // 2e ligne mLcd_SendLcdCmd(kLineJump); Delay10us(5); } // Caractère suivant aChar++; } }
double distance() { double distemp=0; TRIG = 1; Delay10us(); Delay10us(); TRIG = 0; while(ECHO==0); TR1 = 1; //开定时器 while(ECHO==1); TR1=0; distemp= ((TH1*256+TL1)*1.08) * 340.0 /2 /10000; // printf("TL0 IS %bd",TL1); // printf("TH0 IS %bd",TH1); TH1 = 0; TL1 = 0; return distemp; }
/* *------------------------------------------------------------------------------ * void DDR_loadDigit(UINT8 digit, UINT8 data) * * Summary : Write one byte data on the bus * * Input : UINT8 digit - digit number to write the data * UINT8 dataByte - data byte for the digit * * Output : None *------------------------------------------------------------------------------ */ void DDR_loadDigit(UINT8 digit, UINT8 data) { /* if( digit >=64 ) { digit+=128; } */ DISABLE_TMR1_INTERRUPT(); DISPLAY_CONTROL = DISPLAY_DISABLE; //disable the display DIGIT_PORT = digit; //set the address DATA_PORT = (~LED_MAP[data]) | 0X80; // write data DISPLAY_CONTROL = DISPLAY_ENABLE; //enable the display Delay10us(50); //delay for the data to stabilize DISPLAY_CONTROL = DISPLAY_DISABLE; //disable it again ENABLE_TMR1_INTERRUPT(); }
/** * Reset the NIC */ void NICReset(void) { #if (DEBUG_MAC >= LOG_INFO) debugPutMsg(5); //@mxd:5:Reset MAC #endif TRISD = 0xff; //Input WRITE_NIC_ADDR(0); NIC_IOW_IO = 1; NIC_IOR_IO = 1; NIC_RESET_IO = 1; NIC_CTRL_TRIS = 0x00; // Reset pulse must be at least 800 ns. Delay10us(1); DelayMs(5); NIC_RESET_IO = 0; }