Esempio n. 1
0
static void processCy7c4xxFifo(void)
{
    unsigned char c;
    static unsigned char *cy7c4xx_buf_ptr = InDataPacket;
    static unsigned char len = 0;

    if (cy7c4xxPull(&c) != 0)
        return;

    if (len) {
        *cy7c4xx_buf_ptr = c;
        ++cy7c4xx_buf_ptr;
        --len;

        if (len == 0) {
#if DEBUG
            if (usbfifo_debug_operation.dump_fifo_out == 1) {
                unsigned char l = cy7c4xx_buf_ptr-InDataPacket, i;
                unsigned char b[12];
                putrsUSART("FIFO IN: '");
                for (i=0;i<l;++i) {
                    if (i != 0) {
                        while (BusyUSART());
                        putcUSART(' ');
                    }
                    sprintf(b, "%02x", InDataPacket[i]);
                    putsUSART(b);
                }
                sprintf(b, "' len=%3d\r\n", l);
                putsUSART(b);
            }

            if (usbfifo_debug_operation.fifo_loopback == 1) {
                unsigned char l = cy7c4xx_buf_ptr-InDataPacket, i; /* length of incoming packet _must_ not exceed the length of outgoing */
                fifo9403aPush(l, 1);
                for (i=0;i<l;++i)
                    fifo9403aPush(InDataPacket[i], 1);
            }
#endif

            /* FIXME: use real ping-pong */
            while (USBHandleBusy(UsbInDataHandle)); // should not loop, anyway ...
            UsbInDataHandle = USBGenWrite(USBGEN_DATA_EP_NUM, (BYTE*)&InDataPacket, cy7c4xx_buf_ptr-InDataPacket);
            while (USBHandleBusy(UsbInDataHandle)); // have to wait here as full ping-pong is not implemented
                                                    // and thus we don't want data from FIFO override the data being sent here

            cy7c4xx_buf_ptr = InDataPacket;
        }
    } else {
        len = c;
    }
}
Esempio n. 2
0
void imprimir() {
    while(BusyUSART());
    WriteUSART(35);
    while(BusyUSART());
    WriteUSART(88);
    while(BusyUSART());
    itoa(buf, acc_x, 10);
    putsUSART(&buf);
    //putintUSART(&acc_x);
    while(BusyUSART());
    WriteUSART(43);
    while(BusyUSART());
    WriteUSART(89);
    while(BusyUSART());
    //putintUSART(&acc_y);
    itoa(buf, acc_y, 10);
    putsUSART(&buf);
    while(BusyUSART());
    WriteUSART(43);
    while(BusyUSART());
    WriteUSART(90);
    while(BusyUSART());
    //putintUSART(&acc_z);
    itoa(buf, acc_z, 10);
    putsUSART(&buf);
    while(BusyUSART());
    WriteUSART(43);
    while(BusyUSART());
    WriteUSART(33);
    //itoa(buf, temperature, 10);
    //  putsUSART(&buf);
    //  putsUSART(&mid);
    //putsUSART(&start);
    //itoa(buf, acc_x, 10);
    //putintUSART(&acc_x);
    //putsUSART(&mid);
    //itoa(buf, acc_y, 10);
    //putsUSART(&buf);
    //putsUSART(&mid);
    //itoa(buf, acc_z, 10);
    //putsUSART(&buf);
    //putsUSART(&mid);
    //putsUSART(&end);
    //putsUSART(&enter);

}
void main()       {
clock_int_4MHz();

habilita_interrupcao(recep_serial);
taxa_serial(9600);

  while (1) {
  if(!entrada_pin_e3){Reset();}//pressionar o botão para gravação

    nivel_alto(pin_b7);
    tempo_ms(1000);
    nivel_baixo(pin_b7);
    tempo_ms(1000);
    
    //tempo_ms(2000);
     ultoa(d,str); // convert to string and print d - importante para sensores
     putsUSART(str);
     tempo_ms(200);// o tempo para envio de mais de um caractere

    // escreve_serial('A'); //while (envia_byte());// escreve só um byte
     
   //------------Transmissão Serial ----------------------------------------------------------------
    putsUSART((char *) Txdata); // transmite the string   

    if (avisa_interrompeu == 1)  //foi inserido um caracter?
    {
        if(inputstr[str_pos - 1] == 'K') //0x0D o último caracter foi o ENTER?
        {avisa_interrompeu = 0;
 //   printf("Comando digitado %s\r", inputstr);
    str_pos = 0; //reset da posição na string de buffer
    
        }
    } 
     
  }
}
void main (void) {

    // Interrupt configs
    RCONbits.IPEN = 0;      // Deshabilitar prioridades
    INTCONbits.PEIE = 1;    // Habilitar interrupciones de perifericos
    INTCONbits.GIE = 1;     // Habilitar interrupciones globales

    // Inicializa el USART y lo configura a 8N1, 9600 badios
    OpenUSART(
            USART_TX_INT_OFF &          // TX sin interrupciones
            USART_RX_INT_ON &           // RX con interrupciones
            USART_ASYNCH_MODE &         // Modo asincronico
            USART_EIGHT_BIT &           // 8 bits de datos
            USART_CONT_RX &             // Recepci?n continua
            USART_BRGH_HIGH, 129        // 9600 baudios a 20 mhz (calcular con PicBaudRate)
    );

    // Init LCD
    lcd_init();
    lcd_gotoxy(0,2);
    lcd_putrs("   Temp:        ");

    // Safety?
    __delay_ms(39);

    while (1) {

        if (dataFlag != 0) {
            dataFlag = 0;

            // Convierte el float a string
            sprintf(strGrados, "%2.1f,", grados);

            if      (data == 0xFD) putcUSART(0xFD);         // Control
            else if (data == 0xFF) putsUSART(strGrados);    // Env�a info

        }

        Medir_Temperatura();
        __delay_ms(39);
        grados = Leer_DS18B20();

        lcd_gotoxy(10,2);
        printf("%2.1f", grados);
    }
}
void main(void) {
    char msg[6];
    int counter=0;
    initSquareWear();

    // open USART, default baud rate 57600 (defined in SquareWear.h)
    openUSART();
    putrsUSART("Begin.\r\n");   // write a constant string
    while(1) {
        itoa(counter, msg);
        putsUSART(msg);         // write a string
        putrsUSART("\r\n");
        latC7 = !latC7;
        delaySeconds(1);
        counter++;
    }
}
Esempio n. 6
0
// main application code
void main()
{
	u8 counter=0;
	char str[20];
//	TRISBbits.TRISB7=0;

	init_picstar();
	init_buzzer();
	init_bPous;


// Configure Hardware USART 
	OpenUSART( USART_TX_INT_OFF &
		USART_RX_INT_OFF &
		USART_ASYNCH_MODE &
		USART_EIGHT_BIT &
		USART_CONT_RX &
		USART_BRGH_LOW,
		BAUD19200);     //check the uard_baud.h file for available baud rates.

	bip();
// let's wait until we powered the PICKIT2
	delay_ms(2000); 

// print from ROM
    putrsUSART( "\r\nHello World!\r\n" ); 

// main loop
	while(1)
	{
		if(bPous==0)
		{
//	bip();

// print from variable string
	sprintf(str,"counter= %u \r\n", counter++);
	putsUSART(str);

	delay_ms(1000);
		}
	} // end of main loop
}
Esempio n. 7
0
void InitializeGPS(void)
{
    // configure USART
    OpenUSART( USART_TX_INT_OFF &
    USART_RX_INT_OFF &
    USART_ASYNCH_MODE &
    USART_EIGHT_BIT &
    USART_CONT_RX &
    USART_BRGH_LOW,
    64 );
    
    while (BusyUSART());
    putsUSART(gga_off);
    while (BusyUSART());
    putsUSART(gsa_off);
    while (BusyUSART());
    putsUSART(gsv_off);
    while (BusyUSART());
    putsUSART(rmc_off);
    while (BusyUSART());
    putsUSART(gll_off);
    while (BusyUSART());
    putsUSART(vtg_on);
}
Esempio n. 8
0
void main(void)
{
    // Configuracao das portas com LEDs
    TRISCbits.TRISC0=0;    // LED Amarelo para simples sinalizacao
    TRISCbits.TRISC1=0;    // LED Verde para simples sinalizacao
    TRISCbits.TRISC2=0;    // LED Vermelho para simples sinalizacao

    // Configuracao do pino TX da porta serial EUSART / para RS232
    TRISCbits.TRISC6=1;    // TX da EUSART
    // O programa ira informar na porta serial o status
    // e logs de funcionamento da coleta de dados I2C

    // agora a CHAMADA para configuracao GLOBAL da PIC
    configuracao_PIC();

    // Preparacao para configuracao do modulo MSSP I2C (com Errata aplicada)
    /* 17. Module: MSSP (ERRATA for PIC18F4550 and PIC18F2525, etc)
     * ================
     *
     *  It has been observed that following a Power-on Reset, I2C mode may not
     *  initialize properly by just configuring the SCL and SDA pins as either
     *  inputs or outputs. This has only been seen in a few unique system
     *  environments. A test of a statistically significant sample of pre-
     *  production systems, across the voltage and current range of the
     *  application's power supply, should indicate if a system is
     *  susceptible to this issue.
     *
     * Work around = Before configuring the module for I2C operation:
     * 1. Configure the SCL and SDA pins as outputs by clearing
     *  their corresponding TRIS bits.
     * 2. Force SCL and SDA low by clearing the corresponding LAT bits.
     * 3. While keeping the LAT bits clear, configure SCL and SDA as
     *  inputs by setting their TRIS bits.
     *
     * Once this is done, use the SSPCON1 and SSPCON2 registers to
     *  configure the proper I2C mode as before.
     */

    TRISCbits.TRISC3=0;    // SCL do I2C colocado como saida por causa de bug*
    TRISCbits.TRISC4=0;    // SDA do I2C colocado como saida por causa de bug*
    LATC3=0;            // bug* pede que zere-se o LAT das portas SCL e SDA
    LATC4=0;            // durante inicializacao do I2C para evitar flutuacoes
    // eletricas que ficariam nas portas antes de liga-las

    Delay10KTCYx(10);   // simples pausa para troca de estado na SDA e SCL

    TRISCbits.TRISC3=1;    // SCL do I2C, agora corretamente como saida
    TRISCbits.TRISC4=1;    // SDA do I2C, agora corretamente como saida
    // here ends "errata workaround"

    // entao a CHAMADA para diversas configuracoes referentes ao I2C (MSSP)
    configuracao_I2C();

    // e a inicializacao da porta serial EUSART
    configuracao_EUSART();

    while(BusyUSART());
    putrsUSART("\n\r_INIT SERIAL.\n\r");


    /*************************
     *
     * INICIO DO PROGRAMA
     *
     *************************/

    LED_AMAR=0;
    LED_VERM=1;
    LED_VERD=0;

    // Inicializacao do MSSP I2C

    CloseI2C(); // simplesmente fechando qualquer possibilidade de I2C anterior
    // comando nao necessario no boot da PIC
    //macro = #define CloseI2C()  SSPCON1 &=0xDF

    while(BusyUSART());
    putrsUSART("SSPAD=");
    putsUSART( itoa(NULL,SSPADD,10) );
    putrsUSART(" (hex=0x");
    putrsUSART( itoa(NULL,SSPADD,16) );
    putrsUSART("); Abrindo MSSP I2C (Master,Slew_off)\n\r");

    OpenI2C(MASTER,SLEW_OFF);   // configuracao implicita da SSPCON1 e SSPSTAT

    while (1)
    {
        testaColisao();
        getDS1307();



        //testaColisao();
        getTemperaturaHumidade();

        pausa(10);
    }
}
Esempio n. 9
0
void getDS1307(void)
{
    int hora=0, minuto=0, segundo=0, diasemana=0, dia=0, mes=0, ano=0, dummy=0;
    char msg[40];

    //#define StartI2C()  SSPCON2bits.SEN=1;while(SSPCON2bits.SEN)

    LED_AMAR=1;

    IdleI2C();
    StartI2C();
    //IdleI2C();
    __delay_us(16);
    WriteI2C( 0xD0 );
    //IdleI2C();
    __delay_us(60);
    WriteI2C( 0x00 );
    IdleI2C();
    __delay_us(16);
    //AckI2C();AckI2C();AckI2C();AckI2C();AckI2C();AckI2C();AckI2C();AckI2C();
    StopI2C();
    //#define StopI2C()  SSPCON2bits.PEN=1;while(SSPCON2bits.PEN)

    //IdleI2C();
    __delay_us(26);

    RestartI2C();
    __delay_us(16);

    WriteI2C( 0xD1 );
    __delay_us(1);
    IdleI2C();

    segundo    =ReadI2C();
    AckI2C();
    IdleI2C();

    minuto  =ReadI2C();
    AckI2C();
    IdleI2C();

    hora =ReadI2C();
    AckI2C();
    IdleI2C();

    diasemana=ReadI2C();
    AckI2C();
    IdleI2C();

    dia     =ReadI2C();
    AckI2C();
    IdleI2C();

    mes     =ReadI2C();
    AckI2C();
    IdleI2C();

    ano     =ReadI2C();
    AckI2C();
    IdleI2C();

    dummy   =ReadI2C();
    //AckI2C();
    //__delay_us(16);
    //IdleI2C();
    //NotAckI2C();
    //IdleI2C();
    StopI2C();
    //#define StopI2C()  SSPCON2bits.PEN=1;while(SSPCON2bits.PEN)


    LED_VERM = 0;
    LED_AMAR=0;
    LED_VERD=1;

    sprintf(msg,"%xh:%xm:%xs _ dia %x/%x/%x _ ",
            hora,minuto,segundo,dia,mes,ano);

    while(BusyUSART());
    putsUSART( msg );

    LED_VERD=0;
}
Esempio n. 10
0
void getTemperaturaHumidade (void)
{
    unsigned char TEMPL=0, TEMPH=0, HUMIDL=0, HUMIDH=0;
    unsigned char DUMMY=0, OP=0, BT=0;
    float humidade, temperatura;

    char msg[55];

    LED_AMAR=1;

    //#define StartI2C()  SSPCON2bits.SEN=1;while(SSPCON2bits.SEN)

    StartI2C();             // ACORDAR DEVICE
    __delay_us(16);
    WriteI2C(0xB8);     // endereco Slave do AM2315
    __delay_us(135);
    StopI2C();
    //#define StopI2C()  SSPCON2bits.PEN=1;while(SSPCON2bits.PEN)

    // com clock de 4 mhz:
    // 10K (100) = 1000 ms
    // 1K  (100) = 100 ms
    // 1K  (10)  = 10 ms
    // 1K  (2)   = 2 ms
    // Delay100TCYx();

    __delay_us(25);

    RestartI2C();           // REQUISITAR PEDIDO DE BYTES
    __delay_us(16);
    WriteI2C(0xB8);     // endereco Slave do AM2315
    __delay_us(60);     // manual do AM2315 recomenda minimo de 30us

    WriteI2C(0x03);     // byte que simboliza a temperatura
    __delay_us(60);

    WriteI2C(0x00);     // start byte para leitura
    __delay_us(60);

    WriteI2C(0x04);     // quantidades de bytes a serem lidos;
    //AckI2C();
    __delay_us(16);
    StopI2C();
    //#define StopI2C()  SSPCON2bits.PEN=1;while(SSPCON2bits.PEN)

    __delay_ms(10); // manual do AM2315 recomenda esperar no minimo 10ms

    RestartI2C();
    WriteI2C(0xB9);     // endereco Slave do AM2315
    //AckI2C();         // retirado por nao necessitar (?)
    __delay_us(60);     // manual do AM2315 recomenda minimo de 30us
    IdleI2C();

    OP          = ReadI2C();        // 1o byte
    AckI2C();
    IdleI2C();

    BT          = ReadI2C();        // 2o byte
    AckI2C();
    IdleI2C();

    HUMIDL       = ReadI2C();       // 3o byte
    AckI2C();
    IdleI2C();

    HUMIDH       = ReadI2C();       // 4o byte
    AckI2C();
    IdleI2C();

    TEMPL    = ReadI2C();           // 5o byte
    AckI2C();
    IdleI2C();

    TEMPH    = ReadI2C();           // 6o byte
    AckI2C();
    IdleI2C();

    DUMMY          = ReadI2C();     // 7o byte
    AckI2C();
    IdleI2C();

    DUMMY          = ReadI2C();     // 8 byte
    //__delay_us(16);
    StopI2C();
    //#define StopI2C()  SSPCON2bits.PEN=1;while(SSPCON2bits.PEN)

    LED_VERM=0;
    LED_AMAR=0;
    LED_VERD=1;


    // Calculos obtidos do exemplo do Arduino
    humidade  = HUMIDL;
    humidade *= 256;
    humidade += HUMIDH;
    humidade /= 10;

    temperatura  = TEMPL;
    temperatura *= 256;
    temperatura += TEMPH;
    temperatura /= 10;

    /* ou ainda
    RH = RHH << 8;
    RH |= RHL;

    TEMP = TEMPH << 8;
    TEMP |= TEMPL;
    */

    sprintf (msg, "Temp= %0.2f, Humid= %0.2f .", temperatura, humidade);

    while(BusyUSART());
    putsUSART(msg);

    while(BusyUSART());
    putrsUSART("\n\r");

    LED_VERD=0;

}
Esempio n. 11
0
File: main.c Progetto: JarrettR/GPWM
void main(void) {
    /* Configure the oscillator for the device */
    ConfigureOscillator();

    /* Initialize I/O and Peripherals for application */
    InitApp();


    char i = 0;
    int loops = 0;
    int direction = 1;
    
    unsigned int servoIn[MAX_SERVOS];
    
    unsigned int servoSorted1[MAX_SERVOS];
    unsigned int servoSorted2[MAX_SERVOS];
    unsigned char servoSortedId1[MAX_SERVOS];
    unsigned char servoSortedId2[MAX_SERVOS];
    
    unsigned int servoBuffer[MAX_SERVOS];
    unsigned int servoBufferId[MAX_SERVOS];
    
    //unsigned int servoBuffer[MAX_SERVOS];
    
    
    unsigned char currentServo = 0;
    unsigned int servoValue;
    unsigned char sBegin[] = "Begin\n";
    unsigned char sCommand[25];

    for(i = 0; i < MAX_SERVOS; i++) {
        servoIn[i] = 0;
    }
    
    //Test values
    servoIn[0] = 0x01AA;
    servoIn[1] = 0x00AF;
    servoIn[2] = 0x0100;
    servoIn[3] = 0x0060;
    servoIn[4] = 0x0020;
 
        
    putsUSART((char *) sBegin); 
        
    while(1) {
        int  num = 32424;
        char hex[5];
        
        
        //Process values
        SortServos(servoIn, servoBuffer, servoBufferId);
        
        PrintStatus(servoIn, servoBuffer, servoBufferId,
                currentServo, servoValue);
        
        ScaleServos(servoBuffer);
        
        OffsetServos(servoBuffer);
 
        
        //Cleanly switch out new values
        //ToDo: Functionize
        if(Servo_Set == 1) {
            for(i = 0; i < MAX_SERVOS; i++) {
                servoSorted2[i] = servoBuffer[i];
                servoSortedId2[i] = servoBufferId[i];
                Servo_Set = 2;
            }
            if(Servo_Switch_Flag == 1) {
                Servo_Times = servoSorted2;
            }
        }
        if(Servo_Set == 1) {
            for(i = 0; i < MAX_SERVOS; i++) {
                servoSorted2[i] = servoBuffer[i];
                servoSortedId2[i] = servoBufferId[i];
                Servo_Set = 2;
            }
            if(Servo_Switch_Flag == 1) {
                Servo_Times = servoSorted2;
            }
        }
//            for(int i = 0; i < MAX_SERVOS; i++) {
//                servoSorted2[i] = servoSortedNext[i];
//                //Servo_Times = servoSorted2;
//                servoSet = 2;
//            }
//            
//        }
        
        
        //Read dashboard controls
        if(CTRLBUTTON1) {
            CTRLLED1 = 1;
            currentServo = (currentServo + 1) % MAX_SERVOS;
            for(int e = 0; e < 10; e++) {
               //__delay_ms(40);
               __delay_ms(10);
            }	
        } else {
            CTRLLED1 = 0;
        }
        
        if(CTRLSWITCH1) {
            CTRLLED2 = 1;
            servoIn[currentServo] = servoValue;	
        } else {
            CTRLLED2 = 0;
        }

        //TODO: I got bridge problems, son
        /*
        //if(DataRdyUSART()) 
        //while (!DataRdyUSART());
        //sHeader[3] = getcUSART();
        while( !DataRdyUSART( ) ); //Wait for serial data
        
        //sHeader[1] = ReadUSART(); // Read buffer
        if (RCSTAbits.OERR) {
            RCSTAbits.CREN=0;
            RCSTAbits.CREN=1;        
            sHeader[1] = getcUSART();
        }
        //getsUSART((char *) sHeader, 4); // Receive data up to 24 bytes.
        //while (BusyUSART());
        */
        
        ConvertADC();

        for(int e = 0; e < 20; e++) {
             //__delay_ms(40);
             __delay_ms(40);
        }	
        while( BusyADC() );
        servoValue = ReadADC();
        
        
    }

}
Esempio n. 12
0
void main(void) {
    char c;
    char str[7]="ECHO:x\0";

    RCONbits.IPEN = 1; // Enable priority interrupt
    INTCON = 0b10100000;

    TRISD = 0b00000000; // Configure PORTD for output
    PORTD = 0b00000000; // turn off all LEDs initially
    TRISB = 0b00000010; // Configure PORTB for output except RB1
    PORTB = 0b00000000; // turn off all LEDs initially

    //TMR0H=0x67;
    //TMR0L=0x69;
    //T0CON=0b10000110;
	

    //    configure USART
    OpenUSART(USART_TX_INT_OFF &
            USART_RX_INT_OFF &
            USART_ASYNCH_MODE &
            USART_EIGHT_BIT &
            USART_CONT_RX,
            129);


    OpenADC(ADC_FOSC_64 & ADC_RIGHT_JUST & ADC_1ANA, ADC_CH0 & ADC_INT_OFF, 0);
    OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_64);
    WriteTimer0(57722);


    //CONFIGURAR AQUI AS INTERRUPÇÕES

    while (1); // stay in an infinite loop
    {
        // ADC handler

        ConvertADC();
        while (BusyADC());
        resultado = ReadADC();
		
		// Usart handler
        c = getc_usart();
        if (c == 'l') {
            PORTB = 0b00000001;
        } else if (c == 'd') {
            PORTB = 0b00000000;
        }
        else if (c == 'q') {
            resultado = resultado + 50;
        }
        else if (c == 'f') {
            resultado = resultado - 50;
        }
        
        // get char from USART by polling method
        str[5] = c;
        putsUSART(str); // send string to USART

    }
}
Esempio n. 13
0
void terminalSendString(char *str) {
    while(BusyUSART());
    putsUSART(str);
}
void TaskTxSerial(void *pdata)
{
#if OS_CRITICAL_METHOD == 3
    OS_CPU_SR  cpu_sr;
#endif
	struct AdcMsg *Sensores;
	INT8U err;
    INT16S Sensor1;
    INT16S Sensor2;
    INT16S Sensor3;
    INT16U  Acumulador1;
    INT16U  Acumulador2;
    INT16U  Acumulador3;
    INT8U contador;
    INT16U ValorTeclado;
    INT8S strTx1[5];
    INT8S strTx2[5];
    INT8S strTx3[5];
	
	for(;;)
	{
		OSSemPend(STaskTxSerial,0,&err);
        Acumulador1=0;
        Acumulador2=0;
        Acumulador3=0;
        for(contador=0 ; contador<10 ; contador++) {
            Sensores = (struct AdcMsg *) OSQPend(QueueADC0, 0, &err);
            Acumulador1+=Sensores->adc0;
            Acumulador2+=Sensores->adc1;
            Acumulador3+=Sensores->adc2;
            OSMemPut(dMemory,Sensores);
        }

		OSSemPend(STeclado,0,&err);
        ValorTeclado=NumeroSensores;
        OSSemPost(STeclado);
        Sensor1=0;
        Sensor2=0;
        Sensor3=0;
		switch(ValorTeclado){
			case 3:
				Sensor3 = (INT16S) Acumulador3/10;
			case 2:
				Sensor2 = (INT16S) Acumulador2/10;
			case 1:
				Sensor1 = (INT16S) Acumulador1/10;
			default:
				break;
		}
/*
        itoa(Sensor1,strTx1);
        putsUSART(strTx1);
        putrsUSART(SPACE);
        itoa(Sensor2,strTx2);
        putsUSART(strTx2);
        putrsUSART(SPACE);
        itoa(Sensor3,strTx3);
        putsUSART(strTx3);
        putrsUSART(CRLF);
 */
		if(NumeroSensores > 0){
            itoa(Sensor1,strTx1);
            putsUSART(strTx1);
            putrsUSART(SPACE);
			if(NumeroSensores > 1){
                itoa(Sensor2,strTx2);
                putsUSART(strTx2);
                putrsUSART(SPACE);
			}
			if(NumeroSensores > 2){
                itoa(Sensor3,strTx3);
                putsUSART(strTx3);
			}
			putrsUSART(CRLF);
		}
		//OSSemPost(STask1);
        
		OSTimeDly(10);
	}
}
Esempio n. 15
0
void main(void) {

    char mensagem[]="Pronto > ";

    ADCON1=0xF;    // torna todas portas AN0 a AN12 como digitais
                    // na PIC18F2525 somente AN0 a AN4 e AN8 a AN12
                    // nas PICs com 40 pinos, todos ANs de 0 a 12
                    //
                    // PCFG3:PCFG0: A/D Port Configuration Control bits
                    // Note 1:
                    // The POR value of the PCFG bits depends on the value of
                    // the PBADEN Configuration bit. When PBADEN = 1,
                    // PCFG<2:0> = 000; when PBADEN = 0, PCFG<2:0> = 111.


    TRISB=0;    // output do LCD na PORTB / LCD output in PORTB
    initLCD();  // inicia comandos de configuracao do LCD
                // LCD init commands
    /*
     * obs: a biblioteca XLCD.H da PLIB para PIC18, considera como default o LCD
     * conectado na PORTB com as seguintes pinagens:
     *
     Lower Nibble = LCD DATA in PORT B0, B1, B2, B3 (DATA_PORT)
     RW_PIN   in B6   		( PORT for LCD RW , can also be grounded)
     RS_PIN   in B5   		( PORT for LCD RS )
     E_PIN    in B4  		( PORT for LCD Enable Pin )
     */

    TRISA2=1;   // entrada do BOTAO / push-BOTTON input

    TRISC0=0;   // led verde 1
    TRISC1=0;   // led verde 2
    TRISC2=0;   // led verde 3
    TRISC3=0;   // led verde 4
    TRISC4=0;   //buzzer
    TRISC5=0;   //led vermelho

    LED_VERMELHO=1;
    LED1=1;

    Delay10KTCYx(1000);


    while(BusyXLCD());
    WriteCmdXLCD(0x01); // comando para limpar LCD / command to clear LCD

    while(BusyXLCD());
    putrsXLCD ("Serial IO EUSART"); // somente logotipo / just a start logo
    SetDDRamAddr(0x40);     // Linha 2 do Display LCD / second line of LCD

    while(BusyXLCD());
    putrsXLCD ("RS232 PIC18F2525"); // somente logotipo / just a start logo

    SetDDRamAddr(0x00); // volta cursor para linha 0 e posicao 0 do LCD
                        // put cursor in position 0,0 of LCD

    contadorDisplay=0;      // zerando a posicao de caracteres do LCD
                            // reseting the LCD character count

    // Habilitacao dos pinos C6 e C7 para uso da EUSART (explicacao abaixo):
    // Enabling pins C6 and C7 for EUSART (explanation bellow):
    TRISC6=1;
    TRISC7=1;
    RCSTAbits.SPEN=1;
    /*
    The pins of the Enhanced USART are multiplexed
    with PORTC. In order to configure RC6/TX/CK and
    RC7/RX/DT as a USART:
    ? SPEN bit (RCSTA<7>) must be set (= 1)
    ? TRISC<7> bit must be set (= 1)
    ? TRISC<6> bit must be set (= 1)
    Note:
    The EUSART control will automatically
    reconfigure the pin from input to output as
    needed.

     */


    LED1=1;
    LED2=0;
    LED_VERMELHO=0;

    CloseUSART();   // fecha qualquer USART que estaria supostamente aberta antes
                    // just closes any previous USART open port

    
    Delay10KTCYx(1); //Passing 0 (zero) results in a delay of 2,560,000 cycles
    Delay10KTCYx(1000);

    //PORTC=1; Delay10TCYx(50); PORTC=0;

    OpenUSART(  USART_TX_INT_OFF &
                USART_RX_INT_ON &
                USART_ASYNCH_MODE &
                USART_EIGHT_BIT &
                USART_CONT_RX &
                USART_BRGH_LOW,
                51
                );
    // Baud Rate "51" para 2400bps @ 8mhz em modo assincrono
    // de acordo com DS39626E-page 207 do Datasheet em PDF da PIC18F2525

    // These are common comands for 2400 bps running at 8 mhz, assyncronous mode
    // just as being showed in PIC18F2525 Datasheet (DS39626E-page 207)

    //baudUSART (BAUD_8_BIT_RATE | BAUD_AUTO_OFF);

    // page 1158 do pic18_plib.pdf (capitulo 8.17.1.3.3 baud_USART)
    // Set the baud rate configuration bits for enhanced usart operation
    // These functions are only available for processors with
    // enhanced usart capability (EUSART)
    /*
          The Enhanced Universal Synchronous Asynchronous
    Receiver Transmitter (EUSART) module is one of the
    two serial I/O modules. (Generically, the USART is also
    known as a Serial Communications Interface or SCI.)
    The EUSART can be configured as a full-duplex
    asynchronous system that can communicate with
    peripheral devices, such as CRT terminals and
    personal computers. It can also be configured as a half-
    duplex synchronous system that can communicate
    with peripheral devices, such as A/D or D/A integrated
    circuits, serial EEPROMs, etc.
    The Enhanced USART module implements additional
    features, including automatic baud rate detection and
    calibration, automatic wake-up on Sync Break recep-
    tion and 12-bit Break character transmit. These make it
    ideally suited for use in Local Interconnect Network bus
    (LIN bus) systems. (DS39626E-page 201)
     */


    INTCONbits.PEIE = 1;  // interrupcoes para perifericos
    INTCONbits.GIE  = 1;  // interrupcoes globais

    while(BusyUSART());
    putrsUSART("\n\rLed1 e LedVermelho = Interrupcao; Led2 = while wait; Led3/4 = Err");

    while(BusyUSART());
    putrsUSART("\n\rComandos ^E (echo), ^P (lcd), ^L (cls), ^S (status)");

    while(BusyUSART());
    putrsUSART("\n\rTerminal Serial: ");

    while(BusyUSART());
    putsUSART(mensagem);

    LED_VERMELHO=0;
    LED1=1;
    LED2=1;
    
    //LED4=1;

    while (1){

        //LED4=RCIF;
        // o LED4 mostra o status da Interrupcao da RX Serial
        // Led4 shows the status of RX interrupt
      
        //LED3=TXIF;
        // o LED3 mostra o status da suposta interrupcao de TX
        // Led3 shows the suposed TX interrupt state

        LED3=OERR;

        LED4=FERR;
        /*
        bit 2 FERR: Framing Error bit
        1 = Framing error (can be cleared by reading RCREG register and receiving next valid byte)
        0 = No framing error
         *
        bit 1 OERR: Overrun Error bit
        1 = Overrun error (can be cleared by clearing bit, CREN)
        0 = No overrun error
         */


        LED2=~LED2;
        Delay10KTCYx(10);
        // quando esta no modo de espera de tecla* (interrupcao), fica piscando
        // os tres leds para demonstrar a despreocupacao do loop while
        // *na verdade essa espera de tecla eh o RX da serial

        // when being in wait mode (for interrupt *keypress )just flashes the tree
        // leds to demonstrate the un-commitment of while loop to keypress
        // * this keypress event is the serial RX



        // Check for overrun error condition
		if (OERR == 1)
		{
			// Clear the overrun error condition
                        BUZZ=1;
			CREN = 0;
			CREN = 1;
                        Delay100TCYx(10); BUZZ=0;
                }
        LED_VERMELHO = RCIF;    // buffer de recepcao cheio

    }

    return;
}
Esempio n. 16
0
/**
 * シリアルバッファへ書き込み
 * @param str 出力バッファ
 */
void WriteSerial(char *str)
{
    putsUSART(str);
}
Esempio n. 17
0
File: user.c Progetto: JarrettR/GPWM
void PrintStatus(unsigned int *iServos, unsigned int *iOutput,
        unsigned char *cIds, unsigned char cId, unsigned int iInput) {
    
    static int c = 4;
    
    unsigned char sMod[] =      "Mod: ";
    unsigned char sId[] =       "  Id: ";
    unsigned char sInput[] =    ", Input: ";
    unsigned char sCurrent[] =  "   Current: ";
    unsigned char sNew[] =      "   New:     ";
    unsigned char sSorted[] =   "   Sorted:  ";
    
    unsigned char sSeparator[] = ", ";
    unsigned char sNewline[] = "\r\n";
    
    //Overall Values
    putsUSART((char *) sMod);
    WriteUSART((c % 10) + '0'); //This just shows activity
    putsUSART((char *) sId);
    PrintInt(cId);
    putsUSART((char *) sInput);
    PrintInt(iInput);
    putsUSART((char *) sNewline);
    
    //Current values
    putsUSART((char *) sCurrent);
    
    for(int i = 0; i < MAX_SERVOS; i++) {
        if(i) {
            putsUSART((char *) sSeparator);   
        }
        PrintInt(iServos[i]);
    }
    putsUSART((char *) sNewline);
    
    //New values
    putsUSART((char *) sNew);
    
    for(int i = 0; i < MAX_SERVOS; i++) {
        if(i) {
            putsUSART((char *) sSeparator);   
        }
        PrintInt(iOutput[i]);
    }
    putsUSART((char *) sNewline);
    
    //Sort order
    putsUSART((char *) sSorted);
    
    for(int i = 0; i < MAX_SERVOS; i++) {
        if(i) {
            putsUSART((char *) sSeparator);   
        }
        PrintInt(cIds[i]);
    }
    putsUSART((char *) sNewline);


    putsUSART((char *) sNewline);
    
    c++;
}
Esempio n. 18
0
void main (void)
{
    TRISC0=0;   // Led Amar
    TRISC1=0;   // Led Verd
    TRISC2=0;   // LED Verm
    TRISC6=0;   // saida TX EUSART
    ADCON1=0x0F;    // coloca pinos I/O em modo digital (nao analogico)

    acordar();

    unsigned int D0, D1, D2, D3, minAnterior, contador, segInicial;
    char msg[30];

    LED_VERM=1;
     // inicia porta serial com 9600 bps @ 8mhz

    initExt7SegLCD();   // inicia barramento I2C e escreve ".12:34."
    pausa(1); piscaSeg(0);

    // Inicio do Relogio e Display

    contador=0;    // o contador esta acima do limite (59)
    minAnterior=10; // o minuto nunca chegaria a 10 (forca display)

    while (1)
    {

        
        getDS1307();

        sprintf(msg," _[%x:%x:%x]_", hora, minuto, segundo );
            while(BusyUSART());
            putsUSART( msg );

        D0 = (hora & 0b00110000) >> 4;  // utiliza somente 2 bits da nibble esq
        D1 = hora & 0b00001111;         // utiliza somente 4 bits da nibble dir
        D2 = (minuto & 0b11110000) >> 4;// utiliza somente 4 bits da nibble esq
        D3 = minuto & 0b00001111;       // utiliza somente 4 bits da nibble dir

            /*
            sprintf(msg,"___ %d%d:%d%d ...%xseg_ \r\n",
                D0, D1, D2, D3 ,segundo);
            while(BusyUSART());
            putsUSART( msg );
             */

        if (D3 != minAnterior)  // se mudou o minuto, entao mostre novo horario
        {
            StartI2C();
                __delay_us(16); // delay experimental
                WriteI2C(HT16K33_ADDR << 1);

                WriteI2C(0x00);

                WriteI2C(numbertable[D0] & 0xff ); // preenche todos os bits
                WriteI2C(numbertable[D0] >> 8);    // qualquer byte
                // obs: acima como foram usados somente 2 bits, alguma "sujeira"
                // poderia ter ficado escrita no registrador, por isso a necessidade
                // de "preencher" os outros bits com & 0xff

                WriteI2C(numbertable[ D1 ] & 0xFF ); // preenche todos os bits
                WriteI2C(numbertable[ D1 ] >> 8);    // qualquer byte

                WriteI2C(0xFF); // escreve ":" sempre no segundo 0 de mostrar
                WriteI2C(0xFF >> 8);    // qualquer byte

                WriteI2C(numbertable[ D2 ] & 0xFF );// preenche todos os bits
                WriteI2C(numbertable[ D2 ] >> 8);    // qualquer byte

                WriteI2C(numbertable[ D3 ] & 0xFF );// preenche todos os bits
                WriteI2C(numbertable[ D3 ] >> 8);    // qualquer byte

                NotAckI2C();    // encerra envio
                __delay_us(16); // delay experimental
            StopI2C();
            minAnterior=D3; // variavel para proxima checagem e mudanca
        }

        pausa(1);   // utiliza TIMER0 para realizar contagem precisa de 1 seg
        
        
        if ( (contador % 2) == 0) piscaSeg(1);  // gera a piscada ":" par
        else piscaSeg(0); // ou impar " ", a cada mudanca de contador (seg)

        
        sprintf(msg,"\r\nSeg=%d, Cont=%d", segundo, contador );
            while(BusyUSART());
            putsUSART( msg );


            // rotina abaixo de calculo de desvio de segundos
            // ainda deve ser corrigida para o algoritmo correto

            if (contador >= 2 ) // cont >= 40+10
                { 
                    
                    dormir();

                    sprintf(msg,"\r\nSeg=%d, Cont=%d (volta do sleep)", segundo, contador );
                    while(BusyUSART());
                    putsUSART( msg );
                    contador=0;
            
                }

        contador++; // incrementa controle de contagem de segundos
    }
Esempio n. 19
0
static void processUsbCommands(void)
{
#if defined(USB_POLLING)
    // Check bus status and service USB interrupts.
    USBDeviceTasks(); // Interrupt or polling method.  If using polling, must call
    // this function periodically.  This function will take care
    // of processing and responding to SETUP transactions
    // (such as during the enumeration process when you first
    // plug in).  USB hosts require that USB devices should accept
    // and process SETUP packets in a timely fashion.  Therefore,
    // when using polling, this function should be called
    // regularly (such as once every 1.8ms or faster** [see
    // inline code comments in usb_device.c for explanation when
    // "or faster" applies])  In most cases, the USBDeviceTasks()
    // function does not take very long to execute (ex: <100
    // instruction cycles) before it returns.
#endif

    // Note: The user application should not begin attempting to read/write over the USB
    // until after the device has been fully enumerated.  After the device is fully
    // enumerated, the USBDeviceState will be set to "CONFIGURED_STATE".
    if ((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1))
        return;

    // As the device completes the enumeration process, the UsbCbInitEP() function will
    // get called.  In this function, we initialize the user application endpoints (in this
    // example code, the user application makes use of endpoint 1 IN and endpoint 1 OUT).
    // The USBGenRead() function call in the UsbCbInitEP() function initializes endpoint 1 OUT
    // and "arms" it so that it can receive a packet of data from the host.  Once the endpoint
    // has been armed, the host can then send data to it (assuming some kind of application software
    // is running on the host, and the application software tries to send data to the USB device).

    // If the host sends a packet of data to the endpoint 1 OUT buffer, the hardware of the SIE will
    // automatically receive it and store the data at the memory location pointed to when we called
    // USBGenRead().  Additionally, the endpoint handle (in this case UsbOutCmdHandle) will indicate
    // that the endpoint is no longer busy.  At this point, it is safe for this firmware to begin reading
    // from the endpoint buffer, and processing the data.  In this example, we have implemented a few very
    // simple commands.  For example, if the host sends a packet of data to the endpoint 1 OUT buffer, with the
    // first byte = 0x80, this is being used as a command to indicate that the firmware should "Toggle LED(s)".
    if (!USBHandleBusy(UsbOutCmdHandle)) { // Check if the endpoint has received any data from the host.
#if DEBUG
        unsigned char l = USBHandleGetLength(UsbOutCmdHandle);

        if (usbfifo_debug_operation.dump_usb_out == 1) {
            unsigned char b[16];
            unsigned char i;
            putrsUSART("USB OUT: '");
            for (i=0;i<l;++i) {
                if (i != 0) {
                    while (BusyUSART());
                    putcUSART(' ');
                }
                sprintf(b, "%02x", OutCmdPacket[i]);
                putsUSART(b);
            }
            sprintf(b, "' len=%3d\r\n", l);
            putsUSART(b);
        }

        if (usbfifo_debug_operation.usb_loopback == 1) {
            unsigned char i;
            // Now check to make sure no previous attempts to send data to the host are still pending.  If any attemps are still
            // pending, we do not want to write to the endpoint 1 IN buffer again, until the previous transaction is complete.
            // Otherwise the unsent data waiting in the buffer will get overwritten and will result in unexpected behavior.
            while (USBHandleBusy(UsbInCmdHandle));

            for (i=0;i<l;++i)
                InCmdPacket[i] = OutCmdPacket[i];

            // The endpoint was not "busy", therefore it is safe to write to the buffer and arm the endpoint.
            // The USBGenWrite() function call "arms" the endpoint (and makes the handle indicate the endpoint is busy).
            // Once armed, the data will be automatically sent to the host (in hardware by the SIE) the next time the
            // host polls the endpoint.  Once the data is successfully sent, the handle (in this case UsbInCmdHandle)
            // will indicate the the endpoint is no longer busy.
            UsbInCmdHandle = USBGenWrite(USBGEN_CMD_EP_NUM, (BYTE*)&InCmdPacket, l);
        }
#endif

        switch (OutCmdPacket[0]) {
#if DEBUG
            case USBFIFO_CMD_DUMP_USB_OUT:
                usbfifo_debug_operation.dump_usb_out ^= 1;
                break;
            case USBFIFO_CMD_DUMP_FIFO_OUT:
                usbfifo_debug_operation.dump_fifo_out ^= 1;
                break;
            case USBFIFO_CMD_FIFO_LOOPBACK:
                usbfifo_debug_operation.fifo_loopback ^= 1;
                break;
            case USBFIFO_CMD_USB_LOOPBACK:
                usbfifo_debug_operation.usb_loopback ^= 1;
                break;
#endif
            default:
                {
                    unsigned char b[8];
                    putrsUSART("Unexpected cmd=");
                    sprintf(b, "0x%2X\r\n", OutCmdPacket[0]);
                    putsUSART(b);
                }
                break;
        }

        // Re-arm the OUT endpoint for the next packet:
        // The USBGenRead() function call "arms" the endpoint (and makes it "busy").  If the endpoint is armed, the SIE will
        // automatically accept data from the host, if the host tries to send a packet of data to the endpoint.  Once a data
        // packet addressed to this endpoint is received from the host, the endpoint will no longer be busy, and the application
        // can read the data which will be sitting in the buffer.
        UsbOutCmdHandle = USBGenRead(USBGEN_CMD_EP_NUM, (BYTE*)&OutCmdPacket, USBGEN_EP_SIZE);
    }

    if (!USBHandleBusy(UsbOutDataHandle)) {
#if USBGEN_EP_SIZE > FIFO_9403A_MAX_MSG_LEN
#error "Transfer of more than FIFO_9403A_MAX_MSG_LEN not implemented"
#endif
        unsigned char l = USBHandleGetLength(UsbOutDataHandle);
        unsigned char i;

#if DEBUG
        if (usbfifo_debug_operation.dump_usb_out == 1) {
            unsigned char b[16];
            putrsUSART("USB OUT: '");
            for (i=0;i<l;++i) {
                if (i != 0) {
                    while (BusyUSART());
                    putcUSART(' ');
                }
                sprintf(b, "%02x", OutDataPacket[i]);
            }
            sprintf(b, "' len=%3d\r\n", l);
            putsUSART(b);
        }

        if (usbfifo_debug_operation.usb_loopback == 1) {
            while (USBHandleBusy(UsbInDataHandle)); // ensure that FIFO data left the device

            for (i=0;i<l;++i)
                InDataPacket[i] = OutDataPacket[i];

            /* FIXME: use real ping-pong */
            UsbInDataHandle = USBGenWrite(USBGEN_DATA_EP_NUM, (BYTE*)&InDataPacket, l);
            while (USBHandleBusy(UsbInDataHandle)); // have to wait here as full ping-pong is not implemented
                                                    // and thus we don't want data from FIFO override the data being sent here
        }
#endif

        fifo9403aPush(l, 1);
        for (i=0;i<l;++i)
            fifo9403aPush(OutDataPacket[i], 1);

        UsbOutDataHandle = USBGenRead(USBGEN_DATA_EP_NUM, (BYTE*)&OutDataPacket, USBGEN_EP_SIZE);
    }
}
Esempio n. 20
0
//===============================================================================================
//  Main loop
//===============================================================================================
void main(void)
{
    // Creates the variable to readin the commands from the python script
    char reading;
    
    // Creates the controller structure and initizle the corresponding values
    CONTROLLER PY_GAMES_CONTROLLER;
    CONTROLLER_INIT(&PY_GAMES_CONTROLLER);

    //	Set all of PORTC as outputs
    TRISC=0x00;

    //	Configure UART
    OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE &USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 10);
    Delay1KTCYx(4);

    while(1)
    {
        //  Wait for the next branch of data to come in and store it to the reading variable
        while(!DataRdyUSART());
        reading=ReadUSART();

        // Checks to see if the current reading is equal to c, which means check to see if the controller is connected
        if(reading=='c')
        {
            //  Sends 1 to the python script
            sprintf(message,"1");
            putsUSART(message);
            Delay1KTCYx(4);
        }
        // Checks to see if reading is equal to j for joystick
        else if(reading=='j')
        {
             // Waits for the next data to be sent and stores it to reading
             while(!DataRdyUSART());
             reading=ReadUSART();

             // Checks to see if the next reading is equal to l, or left
             if(reading=='l')
             {
                 // Waits for the next data to come in and stores it to reading
                  while(!DataRdyUSART());
                  reading=ReadUSART();

                  //    Checks to see if x axis data is requested
                  if(reading=='x')
                  {
                      // Reads in the left joystick's x axis and sends it to the python script
                      int result=READJOYSTICKX(&PY_GAMES_CONTROLLER.LEFT_JOYSTICK);
                      sprintf(message,"%d",result);
                      putsUSART(message);
                      Delay1KTCYx(4);
                  }
                  //    Check to see if y axis data is requested
                  else if(reading=='y')
                  {
                      // Reads the left joystick's y axis and sends the results to the python script
                      int result=READJOYSTICKY(&PY_GAMES_CONTROLLER.LEFT_JOYSTICK);
                      sprintf(message,"%d",result);
                      putsUSART(message);
                      Delay1KTCYx(4);
                  }


             }
             // Checks to see if reading is equal to r for right
             else if(reading=='r')
             {
                 // Waits for the next data to come in and stores the results to reading
                  while(!DataRdyUSART());
                  reading=ReadUSART();

                  //    Checks to see if x axis data is requested
                  if(reading=='x')
                  {
                      // Reads in the right joystick's x axis and sends the results to the python script
                      int result=READJOYSTICKX(&PY_GAMES_CONTROLLER.RIGHT_JOYSTICK);
                      sprintf(message,"%d",result);
                      putsUSART(message);
                      Delay1KTCYx(4);
                  }
                  //    Check to see if y axis data is requested
                  else if(reading=='y')
                  {
                      // Checks the right joystick's y axis and sends the results to the python script
                      int result=READJOYSTICKY(&PY_GAMES_CONTROLLER.RIGHT_JOYSTICK);
                      sprintf(message,"%d",result);
                      putsUSART(message);
                      Delay1KTCYx(4);
                  }
             }

        }
        // Checks to see if reading is equal to b for button
        else if(reading=='b')
        {
            // Waits for the next data to come in and stores the results to reading
            while(!DataRdyUSART());
            reading=ReadUSART();
            
            // Checks to see if reading is equal to y for yellow button
            if(reading=='y')
            {
                // Checks the status of the yellow button and sends it to the python script
                int result=ISBUTTONPRESSED(&PY_GAMES_CONTROLLER.YELLOW_BUTTON);
                sprintf(message,"%d",result);
                putsUSART(message);
                Delay1KTCYx(4);
            }
            
            // Checks to see if reading is equal to r for red button
            else if(reading=='r')
            {
                //  Checks the status of the red button and sends the results to the python script
                int result=ISBUTTONPRESSED(&PY_GAMES_CONTROLLER.RED_BUTTON);
                sprintf(message,"%d",result);
                putsUSART(message);
                Delay1KTCYx(4);
            }
        }







    }


}
Esempio n. 21
0
void Write_str(unsigned char* str)
{
putsUSART((char *)str);                                         /*Passing the address of the String to the USART write function */
    while(BusyUSART());                                         /*Wait until USART goes to idle state                           */

}
Esempio n. 22
0
void SEND_TX_DATA(void)
{
    putsUSART(TRANSMITT_DATA);
    while (BusyUSART());
    Clear_TX_Buffer();
}