Esempio n. 1
0
/**
 * @brief  Clears text window
 * @param  none
 * @retval none
 */
void Clear_Line(void) {

    int ft = 2; //font
    int t_x = 4;
    int t_y = 2;
    int column = 20;
    int lines = 2;

    TFT_set_window(ft, t_x, t_y, column, lines);
    TFT_cls();


}
int main(int argc, char *argv[])
{  
	/* Initialisiere TI board und touchscreen */
    Init_TI_Board();
    TFT_cls();

    Make_Touch_Pad();

	/* evaluations-loop bis stdin leer ist */
	/* lookup(stdin) liesst einen character von
	   stdin. lookup(NULL) gibt den zuvor ein-
	   gelesenen character wieder */
	while(evaluate(lookup(stdin))) ;

	end:
		goto end;
}
Esempio n. 3
0
/**
 * @brief  Outputs a number to text window
 * @param  value .. number to output
 * @retval none
 */
void Display_value(int value) {

    char text[50];
    int index = 0;
    int ft = 2; //font
    int t_x = 4;
    int t_y = 2;
    int column = 20;
    int lines = 2;

    TFT_set_window(ft, t_x, t_y, column, lines);
    snprintf(text, 50, "%d", value);
    TFT_cls();
    //TFT_puts("                         ");

    do {
        TFT_putc(text[index]);
        index++;
    } while (text[index] != 0);
}
Esempio n. 4
0
int main(void) {
	RCC_ClocksTypeDef RCC_Clocks;
	
	/* default value with 440 Hz delta fi and Amplitude 1.0V*/
	d_phi = D_PHI_440HZ;
	b = AMPLITUDE_B_HIGH;
	
    initCEP_Board();
	initTimer_Dac();	
		
	msecs = 0;
	
	
	RCC_GetClocksFreq(&RCC_Clocks);
    SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);
	
	TFT_cursor_off();
	
	//Mark buffer as empty
	buf1.isEmpty = 1;
	buf2.isEmpty = 1;
	
	bgbuf  = &buf1;
	isrbuf = &buf1;
   
	TFT_cls();
	TFT_puts("CEP4");
	TFT_gotoxy(1, 2);
	TFT_puts("Besnik & Burim Mulici");
	TFT_gotoxy(1,5);
	TFT_puts("msecs: ");
	TFT_gotoxy(1,6);
	TFT_puts("Interrupts: ");	
	TFT_gotoxy(1,7);
	TFT_puts("delta_P: ");
	TFT_gotoxy(1,8);
	TFT_puts("Frequenz:  440");
	TFT_gotoxy(1,9);
	TFT_puts("Form:    Sinus");	

	
    while (1) {
		
		read_buttons();
	
		//slow down display output
		if(msecCountVar <= msecCounter) {						 
			msecCountVar++;
		} else {
			msecCountVar = 0;
		}
		
		//Display output
		if((output ==1) && (msecCountVar == msecCounter)){		
			ITM->PORT[11].u32 = 0;
			
			TFT_gotoxy(1,5);
			TFT_puts("msecs: ");
			sprintf(msecbuf, "%d" , msecs);
			TFT_puts(msecbuf);	
			
			TFT_gotoxy(1,6);
			TFT_puts("Interrupts: ");
			sprintf(interruptbuf, "%d", interruptCounter);
			TFT_puts(interruptbuf);
			
			TFT_gotoxy(1,7);
			TFT_puts("delta_P: ");
			sprintf(d_phi_buf, "%d", d_phi);
			TFT_puts(d_phi_buf);
			
			ITM->PORT[11].u32 = 1;
		}
		
		//Buffer empty? If yes fill it and Wait-LED off, else Wait-LED on
		if(bgbuf->isEmpty){										
			
			resetLED(WAITING);
			ITM->PORT[12].u32 = 0;
			fill_Buf(bgbuf);
			ITM->PORT[12].u32 = 1;
						
			if(bgbuf == &buf1) { bgbuf = &buf2;} 
			else{ bgbuf = &buf1;}
			
		} else {
			setLED(WAITING);
		}			       
    }
}
Esempio n. 5
0
void labor6(void) {
    run = 1;
    syncword_address =0;
    spi_address = 0;
    pwmVal = 0;
    HMP3Decoder mp3dec;
    bytesLeft = 0;
    bytesTilSyncWord = 0;
    decodeRetVal = 0;
    errorCounter = 0;
    idx_ISR = 0;
    mainBuf_empty = 1;
    interrupt_Counter = 0;
    mseczaehlvar = 0;

    RCC_ClocksTypeDef RCC_Clocks;
    msec = 0;
    int i = 0;

    //Amplitude 1.0V (b_big)
    amplitude = b_big;

    spi_setup();
    setup_TIM8_DAC_PWM();
    mp3dec = MP3InitDecoder();

    //SysTick end of count event each 10ms
    RCC_GetClocksFreq(&RCC_Clocks);
    SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

    TFT_cursor_off();

    buf1.isEmpty = 1;
    buf2.isEmpty = 1;

    mp3OutBuffer = &buf1;		//start with buf1
    irsInBuffer = &buf1;

    TFT_cls();
    TFT_gotoxy(1,1);
    TFT_puts("Frequenz:   5000");

    while(B1 != 0 && B2 != 0) {}

    do {
        //Check Buttons
        read_buttons();
        //ausgabe
        print_display();

        //wenn der mainBuf leer ist, muss der durch readSPI mit mp3-daten gefuellt werden
        if (mainBuf_empty) {

            do {

                //Shift bytes to the beginning
                /**
                * Bsp:  mainBufSize = 10
                * 			readBytes = 7 --> bytesLeft = 3
                * 			for(){
                * 				mainBuffer[0] = mainBuffer[(10-3)+0]	idx[0] = idx[7]
                * 				mainBuffer[1] = mainBuffer[(10-3)+1]	idx[1] = ide[8] ...
                */
                for(i = 0; i < bytesLeft; i++) {															//die ungelesene bytes am anfang stellen
                    mainBuf[i] = mainBuf[(MAINBUF_SIZE - bytesLeft) + i];
                }

                //Reads size-bytes from current_SPI_Address and writes them into the given array ((mainBuffer + nBytesLeft))
                //also nach diesem aufruf, ist der mainBuf voll und spiadresse muss verschoben werden
                spiFlashMemRead(SPI_MEM_WORK, spi_address, (mainBuf + bytesLeft),  MAINBUF_SIZE - bytesLeft);

                //nach sync word in dem mainBuf suchen
                bytesTilSyncWord = MP3FindSyncWord(mainBuf, MAINBUF_SIZE);


                if (bytesTilSyncWord == 0) {	//falls guelltige date gleich am anfang liegen
                    spi_address =  spi_address + (MAINBUF_SIZE - bytesLeft);
                } else if (bytesTilSyncWord < 0) {//fehler, kein sync word gefunden
                    run = 0;
                } else if (bytesTilSyncWord > 0) {//falls skip word an der n-te adresse gefunden wurde, verschiebe ich die spiadresse um n, damit ich beim naechsten durchlauf vom flash nur die guelltige daten lese (also muell ueberspringen)
                    spi_address = (spi_address - bytesLeft )+ bytesTilSyncWord;
                }

                bytesLeft = 0;		//MUSS DAS HIER NICHT AUSSERHALB DER WHILE ?? DAMIT DIE NBYTES NICHT VERLOREN GEHEN
            } while(bytesTilSyncWord != 0 && run);

            mainBuf_empty = 0; //mainBuf ist voll
        }


        if (run) {	//wenn kein fehler

            //wenn der mp3OutBuf voll ist ODER der MainBuf leer ist, dann warten (WAITING-LED) anschalten
            if (!mp3OutBuffer->isEmpty || mainBuf_empty) {
                setLED(WAITING_LED);
            } else {
                resetLED(WAITING_LED);

                bytesLeft = MAINBUF_SIZE;																					//in nBytesLeft steht wieviele daten aus dem MainBuf noch in dem mp3OutBuf uebertragen werden muessen
                ptrMainBuf = mainBuf;																			//mainBufPointer soll auf MainBuff zeigen, obwohl es bei der initialisierung schon gemacht wurde !!

                /**
                	* para1: decoder instance
                	*	para2: buffer aus dem die daten decodet werden sollen
                	* para3: (input) --> anzahl gueltige bytes, die gelesen werden sollen,
                	* 			 (output)--> input - gelesene bytes, also die bytes die noch gelesen werden muessen
                	* para4: der buffer in dem geschrieben werden soll, der pointer wird geupdatet (bis wo der voll geschrieben wurde)
                	*/

                //nach diesem aufruf ist der mp3OutBuf auf jeden fall voll
                decodeRetVal = MP3Decode(mp3dec, &ptrMainBuf, &bytesLeft, mp3OutBuffer->data, 0);		//decodeResult -->(0 means no error, < 0 means error)


                mainBuf_empty = 1;																									//der mainBuf ist nicht komplett voll

                if (decodeRetVal < 0) {
                    errorCounter++;
                } else {
                    errorCounter = 0;
                }

                if (errorCounter > 2) {																							//fehler beim decode aufgetreten
                    run = 0;
                } else {
                    mp3OutBuffer->isEmpty = 0;																			//der mp3OutBuffer wurde voll geschrieben, bereit fuer die ISR
                    if(mp3OutBuffer == &buf1) {																			//buffer ist voll, also wechseln
                        mp3OutBuffer = &buf2;
                    } else if (mp3OutBuffer == &buf2) {
                        mp3OutBuffer = &buf1;
                    }
                }
            }
        }

    } while (run);

    MP3FreeDecoder(mp3dec);

}