Exemple #1
0
/*******************************************************************************
* Function Name: main
********************************************************************************
*
* Summary:
*  Main function performs following functions:
*   1. Initialises the DMA to move data from ADC_SAR_1 work registers to the
*      PrISM pulse density registers.
*   2. Initialises the ISR connected to the DMA nrq terminal(DMA done).
*   3. Initialises the LCD.
*   4. Initialises the PrISM with 1Mhz clock.
*   5. Initialises the two SAR ADCs.
*   6. Displays the results of ADC_SAR_1 when DmaDone ISR rises.
*      The results are read from PrISM pulse density register.
*   7. Displays the results of ADC_SAR_2 when internal EOC ISR rises.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
*******************************************************************************/
int main()
{
    char8 resultStr[16u];
    float res;


    /* Initializes the LCD. */
    LCD_Start();
    LCD_Position(1u,0u);
    LCD_PrintString("ADC2=      V");

    ADC_SAR_2_Start();
    ADC_SAR_2_IRQ_StartEx(ADC_SAR_2_ISR_LOC);
    ADC_SAR_2_StartConvert();

    CyGlobalIntEnable;

    for(;;)
    {

        /* Show ADC2 result on LCD*/
        if(dataReady != 0u)
        {
            res = ADC_SAR_2_CountsTo_Volts(result);
            sprintf((char *)resultStr,"%+1.2f",res);
            LCD_Position(1u,5u);
            LCD_PrintString(resultStr);
            dataReady = 0u;
        }
    }
}
signed char DisplayChoices(const char *Menu[], char ItemCount, const char *Prompt, char Initial) {
    char SelectedItem = 0;
    signed char ret = 0;
    SelectedItem = Initial;
    while (1) {
        LCD_ClearDisplay();
        LCD_PrintString(Prompt);
        LCD_SetPosition(1, 0);
        LCD_PrintChar('*');
        LCD_PrintString(Menu[SelectedItem]);

        ret = GetInput();
        if (ret < 0) return ret;

        switch (ret) {
            case USER_INPUT_CLICK:
                return (SelectedItem);
            case USER_INPUT_BACK:
                return (-1);
            case USER_INPUT_CANCEL:
                return (-2);
            case USER_INPUT_INC:
                if (SelectedItem == ItemCount) SelectedItem = ItemCount;
                else SelectedItem++;
                break;
            case USER_INPUT_DEC:
                if (SelectedItem == 0) SelectedItem = 0;
                else SelectedItem--;
                break;
        }
    }
    return (0);
}
Exemple #3
0
int main(void)
{

  /* USER CODE BEGIN 1 */
	uint8_t damogranlabs_logo[]={
		0x0F,
		0x13,
		0x11,
		0x11,
		0x0e,
		0x00,
		0x00		
	};
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();

  /* USER CODE BEGIN 2 */
	LCD_Init(2, 20);
	LCD_CreateChar(0, damogranlabs_logo); 
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	LCD_PrintString(2, 1, "n: ");
	LCD_PrintNumber(2, 4, -10);
	
	LCD_PrintString(2, 10, "f: ");
	LCD_PrintFloat(2, 13, -326.5635, 5);
	
	while (1)
  {
		LCD_PrintStringWindow(1, 3, 14, 350, "Find us on github and www.damogranlabs.com");
		LCD_Clear();
		LCD_PrintString(1, 1, "www.damogranlabs.com");
		LCD_PutCustom(2, 10, 0);
		LCD_ClearArea(1, 5, 12); 
		HAL_GPIO_TogglePin(LD3_GPIO_Port, LD3_Pin);
		HAL_Delay(2000);
		
		
		
				/* USER CODE END WHILE */

		/* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

}
signed char GetYesNo(const char *prompt, signed char Initial) {
    signed char answer;
    signed char inp;
    LCD_ClearDisplay();
    LCD_PrintString(prompt);

    answer = Initial;
    while (1) {
        LCD_SetPosition(1, 0);
        if (answer) LCD_PrintString("<YES>\0");
        else LCD_PrintString("<NO> \0");
        inp = GetInput();
        if (inp < 0) return inp;

        switch (inp) {
            case USER_INPUT_CLICK: //The User Pressed the button to select something...
                return (answer);
                
            case USER_INPUT_CANCEL:
                return -2;
                
            case USER_INPUT_BACK:
                return -1;
                
            case USER_INPUT_INC: //Rot +
            case USER_INPUT_DEC: //Rot -
                answer = !answer;
                break;
            default:
                break;
        }
    }
    return (0);
}
Exemple #5
0
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();

  /* USER CODE BEGIN 2 */
	LCD_Init(2, 20);
	LCD_PrintString(0, 0, "Damogran Labs");
	
	Encoder_Init(&encoder1, ENC1_A_GPIO_Port, ENC1_A_Pin, ENC1_B_GPIO_Port, ENC1_B_Pin);
	Encoder_Init(&encoder2, ENC2_A_GPIO_Port, ENC2_A_Pin, ENC2_B_GPIO_Port, ENC2_B_Pin);
		
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	LCD_PrintNumber(1, 0, encoder1.abs_rot);
	LCD_PrintNumber(1, 6, encoder2.abs_rot);
	
  while (1)
  {
		if(Encoder_GetState(&encoder1)){
			LCD_PrintString(1, 0, "     ");
			LCD_PrintNumber(1, 0, encoder1.abs_rot);
		}	
		if(Encoder_GetState(&encoder2)){
			LCD_PrintString(1, 6, "     ");
			LCD_PrintNumber(1, 6, encoder2.abs_rot);
		}	
		
		if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_SET){
			Encoder_SetAbsToZero(&encoder1);
			Encoder_SetAbsToZero(&encoder2);
		}
		
		HAL_Delay(100);
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}
Exemple #6
0
//main routine for ADC (linear) calibration testing
void TestADCCalibration(void)
{
  unsigned int * ADCBuffer;
  double * ADCRealValues;
  double P, Q;
  unsigned int i;
  unsigned int NumOfData;
  volatile double diffOrig;
  volatile double diffCalib;
  unsigned char DEBUG_STRING[30];

  //set external clock (16MHz XTALL required)
  SetCPUClock(0);

  //allocate buffer space
  if ((ADCBuffer = malloc(ADC_BUFFER_SIZE * sizeof(ADCBuffer[0]))) == NULL)
    _asm("trap\n");
  if ((ADCRealValues = malloc(ADC_BUFFER_SIZE * sizeof(ADCRealValues[0]))) == NULL)
    _asm("trap\n");

  //main test
  {
    //collect data
    NumOfData = ADCCollectDataCalib(ADCBuffer, ADCRealValues);
    P= GetMultiplierCalib(ADCBuffer, ADCRealValues, NumOfData);
    diffOrig = GetErrorCalib(ADCBuffer, ADCRealValues, NumOfData, P, 0);

    //calib data
    ADCCalibratePQ(ADCBuffer, ADCRealValues, NumOfData, &P, &Q);
    diffCalib = GetErrorCalib(ADCBuffer, ADCRealValues, NumOfData, P, Q);

    //print errors
    sprintf(DEBUG_STRING, "Orig = %f", diffOrig);
    LCD_PrintString(LCD_LINE1, ENABLE, DISABLE, DEBUG_STRING);
    sprintf(DEBUG_STRING, "Calib= %f", diffCalib);
    LCD_PrintString(LCD_LINE2, ENABLE, DISABLE, DEBUG_STRING);
    delay(500000l);//to show results
  }
  
  //see real values after ADC calibration - for checking calibration
  LCD_Clear();
  LCD_PrintString(LCD_LINE1, DISABLE, ENABLE, "Real calibrated U");  
  while(!JOY_SEL)
  {
    //start single conversion
    ADC2_StartConversion();
    while (!ADC2_GetFlagStatus());
    //clear end of conversion bit
    ADC2_ClearFlag();
    //collect ADC value and display
    LCD_SetCursorPos(LCD_LINE2, 4);//set cursor position
    LCD_PrintDec4((P*ADC2_GetConversionValue() + Q)*1000);
  }
  
  //unallocate buffer
  free(ADCBuffer);
}//TestADCCalibration
void printDebug(STATE state){
  LCD_MoveCursor(1,1);
  char stringToPrint[16];
  sprintf(stringToPrint,"%4d%4d%4d%4d",IRSensor_GetLeftFront(), IRSensor_GetCenterLeft(), IRSensor_GetCenterRight(), IRSensor_GetRightFront());
  LCD_PrintString(stringToPrint);
  LCD_MoveCursor(1,2);
  sprintf(stringToPrint,"OC:%5d:%5d %1d",OC2RS,OC4RS,state);
  LCD_PrintString(stringToPrint);
};
signed char GetFloat(const char *prompt, const char *unit, double* Value, double Min, double Max, double Precision) {
    double Output;
    char WholePlaces;
    char FractionalPlaces;
    signed char ret = 0;


    if ((Max >= 10000) || (Min <= -10000)) WholePlaces = 5;
    else if (Max >= 1000 | Min <= -1000) WholePlaces = 4;
    else if (Max >= 100 | Min <= -100) WholePlaces = 3;
    else if (Max >= 10 | Min <= -10) WholePlaces = 2;
    else WholePlaces = 2;

    if (Precision >= 1.0) FractionalPlaces = 0;
    else if (Precision >= 0.1) FractionalPlaces = 1;
    else if (Precision >= 0.01) FractionalPlaces = 2;
    else if (Precision >= 0.001) FractionalPlaces = 3;
    else if (Precision >= 0.0001) FractionalPlaces = 4;


    Output = *Value;
    LCD_ClearDisplay();
    LCD_PrintString(prompt);

    LCD_SetPosition(1, 0);
    LCD_PrintFloat(Output, WholePlaces, FractionalPlaces, 1);
    LCD_PrintString(unit);

    while (1) {
        LCD_SetPosition(1, 0);
        LCD_PrintFloat(Output, WholePlaces, FractionalPlaces, 1);
        ret = GetInput();
        if (ret < 0) return ret;
        switch (ret) {
            case USER_INPUT_CLICK: //user has pressed the switch to accept.                     
                *Value = Output;
                return (0);
            case USER_INPUT_CANCEL:
                return -2;
                
            case USER_INPUT_BACK:
                return -1;
                
            case USER_INPUT_INC: //Rot+
                Output += GetRotaryMultiplier() * Precision;
                if (Output > Max) Output = Max;
                break;
            case USER_INPUT_DEC:
                Output -= GetRotaryMultiplier() * Precision;
                if (Output < Min) Output = Min;
                break;
        }
    }
    return (0);
}
Exemple #9
0
/************************************************
 * Method to calculate the heartrate based on 
 * the start and end values of a counter that
 * is driven by interrupts which are driven by
 * the heartbeat.
 * @return heartrate The last recorded heartrate
 ************************************************/
float Detect_heartrate(void) {
    LCD_Position(0,0);
    LCD_PrintString("Heartrate: ");
    LCD_PrintString("      ");
    LCD_Position(1,0);
    /* 600000 because the clock speed of the 
     heartrate is set to kHz */
    heartrate = (600000/(endCounts-startCounts));
    LCD_PrintU32Number(heartrate);
    LCD_PrintString("      ");
    return heartrate;
}
Exemple #10
0
/**
  * @brief  Reports the name of the source file and the source line number
  *   where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
    LCD_PrintString(LCD_LINE1, DISABLE, DISABLE, "      ERR       ");
    LCD_PrintString(LCD_LINE2, DISABLE, DISABLE, "     ASSERT     ");
  }
}
signed char ShowVoltage() {    
    double Batt;
    LCD_ClearDisplay();
    bLock_BatteryVoltage = 1;
    Batt = BatteryVoltage;
    bLock_BatteryVoltage = 0;
    Batt *= Config.Volts_per_Count;
    LCD_PrintString("BATTERY VOLTAGE:\0");
    LCD_SetPosition(1, 0);
    LCD_PrintFloat(Batt, 2, 2, 0);
    LCD_PrintString(" VOLTS\0");
    return GetClick();
}
signed char GetPresetNumber() {
    signed char inp;
    char pnum;
    signed char ptype;
    LCD_ClearDisplay();
    LCD_PrintString("PRESET SLOT:\0");
    LCD_SetPosition(1, 0);
    LCD_PrintString("PRESET 01\0");
    pnum = 1;

    while (1) {
        LCD_SetPosition(1, 7);
        LCD_PrintLong((int) pnum, 2, 0);

        ptype = GetPresetType(pnum);

        switch (ptype) {
            case 0:
                LCD_PrintString("-EMPTY    \0");
                break;
            case 1:
                LCD_PrintString("-WAYPOINT \0");
                break;
            case 2:
                LCD_PrintString("-ORBIT    \0");
                break;
        }

        inp = GetInput();
        if (inp<0) return inp;
        
        switch (inp) {
            case USER_INPUT_DEC:
                if (pnum > 1) pnum--;
                break;
            case USER_INPUT_INC:
                if (pnum < 5) pnum++;
                break;
            case USER_INPUT_CLICK:
                return (pnum);
            case USER_INPUT_BACK:
                return (-1);
            case USER_INPUT_CANCEL:
                return (-2);
        }
    }
    return (-2);
}
Exemple #13
0
/*******************************************************************************
* Function Name: main
********************************************************************************
*
* Summary:
*  main() performs following functions:
*  1: Initializes the LCD
*  2: Starts ADC
*  3: Starts ADC converstion.
*  4: Gets the converted result and displays it in LCD.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
*******************************************************************************/
int main()
{
    int16 output;

    /* Start the components */

    LCD_Start();
    ADC_DelSig_1_Start();

    /* Start the ADC conversion */
    ADC_DelSig_1_StartConvert();

    /* Display the value of ADC output on LCD */
    LCD_Position(0u, 0u);
    LCD_PrintString("ADC_Output");

    for(;;)
    {
        if(ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_RETURN_STATUS))
        {
            output = ADC_DelSig_1_GetResult16();
            
            /* Saturate ADC result to positive numbers. */
            if(output < 0)
            {
                output = 0;
            }
            LCD_Position(1u, 0u);
            LCD_PrintInt16(output);
        }
    }
}
Exemple #14
0
//////////////////////////////////////////////////////
//	This function display current input from user
//////////////////////////////////////////////////////
void UserInput(void)
{
	//Write_Lcd(0x0D, 0);
	char_menu_pw[current_pw_digit] = digit;
	char_menu_pw[current_pw_digit+1] = 0;
	LCD_PrintString(char_menu_pw, LCD_ROW1, 1);
}
/*******************************************************************************
* Function name: DisplayPrintLastTimeSkier
********************************************************************************
*
* Summary:
*   print time last skier from position row = 1, column = 0
*
*******************************************************************************/
void DisplayLastSkierTime(uint32_t sec, uint16_t milisec)
{
    /*printf time in format mm:ss:msmsms*/
    sprintf(buff, "Result %02u:%02u:%03u",sec/60,sec%60, milisec);
    LCD_Position(0,0);
    LCD_PrintString(buff);
}
Exemple #16
0
static void kb_draw_key(struct guiBox *box, char c, u8 pressed)
{
    u16 w, h;
    u16 bg_color;
    u16 fg_color;
    char ch[2];
    const char *str = "";
    if ( c == '\x06') { //DONE
        str = "DONE";
        if (pressed) {
            bg_color = Display.keyboard.fg_key3;
            fg_color = Display.keyboard.bg_key3;
        } else {
            bg_color = Display.keyboard.bg_key3;
            fg_color = Display.keyboard.fg_key3;
        }
    } else if (c < ' ') { //CAPS, DEL, NUMPAD
        if      (c == '\x09') str = caps_str;
        else if (c == '\x08') str = del_str;
        else if (c == '\x01') str = mix_str;
        else if (c == '\x02') str = char_str;

        if (pressed) {
            bg_color = Display.keyboard.fg_key2;
            fg_color = Display.keyboard.bg_key2;
        } else {
            bg_color = Display.keyboard.bg_key2;
            fg_color = Display.keyboard.fg_key2;
        }
    } else {
        if (c == ' ') {
            str = space_str;
        } else {
            ch[0] = c;
            ch[1] = 0;
            str = ch;
        }
        if (pressed) {
            bg_color = Display.keyboard.fg_key1;
            fg_color = Display.keyboard.bg_key1;
        } else {
            bg_color = Display.keyboard.bg_key1;
            fg_color = Display.keyboard.fg_key1;
        }
    }
    /*
    printf("(%dx%dx%dx%d)", box->x, box->y, box->width, box->height);
    if(coords1)
        printf(" coords1: %dx%d", coords1->x, coords1->y);
    if(coords2)
        printf(" coords2: %dx%d", coords2->x, coords2->y);
    printf(" Draw: %d\n", draw);
    */
    LCD_SetFont(Display.keyboard.font);
    _draw_key_bg(box, pressed, bg_color);
    LCD_GetStringDimensions((const u8 *)str, &w, &h);
    LCD_SetXY(box->x + (box->width - w) / 2, box->y + (box->height - h) / 2);
    LCD_SetFontColor(fg_color);
    LCD_PrintString((const char *)str);
}
Exemple #17
0
int main(void)
{    
    CyGlobalIntEnable; /* Enable global interrupts. */
    
    DisplayStart();
    Display("System init...");
    
    RTC_WDT_Init(); 
    InitNetwork();
    
    
    
    Display("Sync time...");

    uint8_t number = 0;
    while((result = NTPsync()) != TIME_SYNC_OK)
    {
        char buf[10];
        sprintf(buf, "Sync time -%d", number++);
        LCD_Position(0,0);
        LCD_PrintString(buf);
        CyDelay(500);
    }
    
    Display("Sync ok        ");
    CyDelay(4*TIMEOUT_USER_READ_INFO);
    
    for(;;)
    {
        DisplayRealTime();
        CyDelay(500);
    }
}
Exemple #18
0
void main_play_ttc(){
    LCD_Start();					    // initialize lcd
    LCD_ClearDisplay();
    UART_Start();                       // initialize UART
    UART_PutChar(0x81); // init connection; set to 16x12 image 
    
    struct disp_grid_81 disp; 
    disp_grid_init(&disp,0x3F); // init our display grid matrix to white  
    disp_grid_transmit(&disp);
    
    struct tic_tac_toe lolz;
 	ttc_init(&lolz,4,3);    
    disp_grid_init_ttc(&disp,lolz.grid); // init the board
    disp_grid_draw_xia(&disp,26,16,0x30); // draw xia
    disp_grid_transmit(&disp);
    
    int x,y,z; int Values;
    
    while (lolz.game_not_won == 0){
        //Values = read_from_8255(Values);
        Values = Pin3_Read();
        if (Values >= 0 && Values <= 63){ //integer value
            z = Values / 16;
            x = Values % 4; //get row value
            y = Values / 4 - z*4; // 
            LCD_ClearDisplay();
            LCD_PrintNumber(Values);
            LCD_PrintString(" x");
            LCD_PrintNumber(x);
            LCD_PrintString(" y");
            LCD_PrintNumber(y);
            LCD_PrintString(" z");
            LCD_PrintNumber(z);
        }
        if (ttc_get_grid(&lolz,x,y,z) == 0){ // has not been accessed
            ttc_step(&disp,&lolz,x,y,z); // step & print
            disp_grid_transmit(&disp);
        }
        
    }
    LCD_ClearDisplay();
    LCD_Position(0,0); //move to bot row
    LCD_PrintString("GAME OVER!");    
    
}
/*******************************************************************************
* Function name: DisplayPrintfRealTime
********************************************************************************
*
* Summary:
*   print real time from position row = 1, column = 0
*
*******************************************************************************/
void DisplayRealTime(void)
{
    uint32_t time;
    
    time = RTC_GetTime();
    sprintf(buff, "%02lu:%02lu:%02lu      ", RTC_GetHours(time),RTC_GetMinutes(time), RTC_GetSecond(time));
    LCD_Position(1,0);
    LCD_PrintString(buff);
}
Exemple #20
0
void gotoMenuResetState(void)
{
	static unsigned int boardrequest = 12000;
	int i;
	char s[17] = "";
	// Sends a request to bottom board to get readings.
	// Any readings received will be processed in mcu.c.

	if( TickGet()-Timer > (5*TICK_SECOND) )
	{
		//s[0] = ph_4total;		// 2014-07-01 Liz removed
		s[0] = 0;				// 2014-07-01 Liz added
		s[1] = 10;
		s[2] = 'N'; //2012-09-24: Liz added to distinguish from EEPROM request.
		// Show on the LCD the reading that is in the local variable
		// while at the same time request for a new reading from the
		// bottom board.
		
		// 2012-05-10(Eric) - No need to retry here since it is not critical.
		// More impt to release control back to main loop.
		MCURequestToBOTTOMBoard(MMT_READING_REQUEST, s, 3, FALSE, FALSE);
		//MCURequestToBOTTOMBoard(MMT_READING_REQUEST, s, 2, FALSE, TRUE);

		// 2014-07-01 Liz removed
//		ph_4total++;
//		if( ph_4total >= 4)
//		{
//			ph_4total = 1;
//			//Convert3RealEnergyToCharArray(s);
//			Convert3RealEnergyToCharArray(s, 1, 1);
//		
//			LCD_PrintString(s, LCD_ROW1, 0);
//		}
		
		// 20114-07-01 Liz added
		Convert3RealEnergyToCharArray(s, 1, 1);
		LCD_PrintString(s, LCD_ROW1, 0);
		///////////////////////
		
		Timer = TickGet();
	}	
	
	switch (menu_control(reset_table, reset_table_max))
	{
		case -2:
			break;
		case 0:
			setMenuCurrentState(MENU_IDLE_STATE);
			set_current_menu(0);
			gotoMenuIdleState();
			LCD_PrintStringPGM("",LCD_ROW1);
			break;
		default:
			break;
	}
}
Exemple #21
0
// Show shift register contents and flags
void show(void) {
    uint8       i;
    
    LCD_Position(0, 0);
    for (i = 0; i < 8; i++) {
        LCD_PrintInt8(v[i]);
    }
    LCD_Position(1, 0);
    if (SR1_Read() & 1) {
        LCD_PrintString("FULL ");
    } else {
        LCD_PrintString("     ");
    }
    if (SR1_Read() & 2) {
        LCD_PrintString("EMPTY ");
    } else {
        LCD_PrintString("      ");
    }
}
Exemple #22
0
//////////////////////////////////////////////////////
//	This function initialize states of 4 buttons
//////////////////////////////////////////////////////
void set_button_state(void)
{
	button_down_old_state = 0;
	button_up_old_state = 0;
	button_escape_old_state = 0;
	button_enter_old_state = 0;
	is_button_pressed = 0;
	Timer = TickGet() + 5*TICK_SECOND;	// 2014-07-02 Liz. Top board will immediately send request after initialisation.
	LCD_PrintString((char *)reset_table[0], LCD_ROW0, 0);	// 2012-05-04 Liz: add in cursor display mode for LCD_PrintString()
}
Exemple #23
0
/**
  * @brief Example  main entry point.
  * @par Parameters:
  * None
  * @retval 
  * None
  */
void main(void)
{

    /* Initialize SPI for LCD */
    SPI_DeInit();
    SPI_Init(SPI_FIRSTBIT_MSB, SPI_BAUDRATEPRESCALER_128, SPI_MODE_MASTER, SPI_CLOCKPOLARITY_HIGH, SPI_CLOCKPHASE_2EDGE, SPI_DATADIRECTION_1LINE_TX, SPI_NSS_SOFT, 0x07);
    SPI_Cmd(ENABLE);

    
    /* Configure GPIO used to drive the joystick
	      JOYSTICK_UP    --> PB6
	      JOYSTICK_DOWN  --> PB7
	      JOYSTICK_LEFT --> PB4
	*/
  GPIO_Init(GPIOB, GPIO_PIN_4 | GPIO_PIN_6 | GPIO_PIN_7, GPIO_MODE_IN_FL_IT);
  EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOB, EXTI_SENSITIVITY_FALL_LOW);
	
	enableInterrupts();
    
    
    /* Initialize LCD */
    LCD_Init();

    /* Clear LCD lines */
    LCD_Clear();

    LCD_Backlight(ENABLE);

    LCD_PrintString(LCD_LINE1, ENABLE, DISABLE, "Clock Selection");
    LCD_PrintString(LCD_LINE2, ENABLE, DISABLE, " Use joystick");

    CLK_DeInit();
		CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
    /* Output Fcpu on CLK_CCO pin */
    CLK_CCOConfig(CLK_OUTPUT_MASTER);

    while (1)
    {
  
    }

}
Exemple #24
0
//when a user dies, we are going to print "USER DEATH" and pause EVERYthing for a second//
void DEATH(void){
		LCD_SetCursor(140,80);	
		LCD_SetTextColor(255,0,0);
		LCD_PrintString("USER DEATH");
	for(deathPause = 0; deathPause < 30; deathPause++){
			while(Semaphore == 0){};																	//do nothing until SysTick interrupt
				Semaphore = 0;																				//"acknowledge" SysTick
				if(newMissile >3){newMissile = 0;}												//missile count probably very high from all the SysTick calls
			}
		
		}	
Exemple #25
0
void main_test_disp(){
    LCD_Start();					    // initialize lcd
    uint8 current;
    for (;;){
        LCD_ClearDisplay();
        
        LCD_Position(0,0); //move back to top row
        current = Pin0_Read(); //next, read a new value
        LCD_PrintString("P0: ");
        LCD_PrintNumber(current); //print value I am getting
        
        LCD_Position(1,0); //move to bot row
        current = Pin3_Read(); //next, read a new value
        LCD_PrintString("P3: ");
        LCD_PutChar(current); //print ascii value
        LCD_PrintString(" HEX: ");
        LCD_PrintNumber(current); //print value I am getting
        
        waiter(4);
    }
}
Exemple #26
0
void main(){
	CYGlobalIntDisable;//Disable interrupts to avoid triggering during setup.
    LCD_Start();// Start LCD.
	UART_Start();// Start UART.
	Rx_Int_Start();//Start the Interrupt.
	Rx_Int_SetVector(Rx_ISR);//Set the Vector to the ISR.
	LCD_PrintString("UART:RX ISR Demo");//Print to the LCD.
	UART_PutString("UART:RX ISR Demo");//Print to Serial Terminal.
	CyDelay(1000);
	LCD_ClearDisplay();//Clear the screen for RX Data.
	CYGlobalIntEnable;//Enable Interrupts,and let the Games begin!
	
    for(;;);
}
/*******************************************************************************
* Function name: DisplayPrintfLoading
********************************************************************************
*
* print loading from position row = 1, column = 0
*
*******************************************************************************/
void DisplayLoading(uint32_t numLoad)
{
    if(numLoad == 0)
    {
        /*clear row 1*/
        LCD_Position(1,0);
        LCD_PrintString("             ");
    }
    if((numLoad > 0) && numLoad < 16)
    {
        LCD_Position(1,numLoad-1);
        LCD_PutChar(LCD_CUSTOM_4);
    }
}
Exemple #28
0
int main( void )
{
char cIPAddress[ 16 ]; /* Enough space for "xxx.xxx.xxx.xxx\0". */

	/* Configure the hardware for use by this demo. */
	prvSetupHardware();

	/* Start the standard demo tasks.  These are just here to exercise the
	kernel port and provide examples of how the FreeRTOS API can be used. */
	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
    vCreateBlockTimeTasks();
    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
    vStartQueuePeekTasks();
    vStartRecursiveMutexTasks();
	vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );

    /* Create the USB task. */
    xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );
	
	/* Display the IP address, then create the uIP task.  The WEB server runs 
	in this task. */
	LCDdriver_initialisation();
	LCD_PrintString( 5, 10, "FreeRTOS.org", 14, COLOR_GREEN);
	sprintf( cIPAddress, "%d.%d.%d.%d", configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );
	LCD_PrintString( 5, 30, cIPAddress, 14, COLOR_RED);
    xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL );

    /* Start the scheduler. */
	vTaskStartScheduler();

    /* Will only get here if there was insufficient memory to create the idle
    task.  The idle task is created within vTaskStartScheduler(). */
	for( ;; );
}
Exemple #29
0
/*******************************************************************************
* Function Name: main
********************************************************************************
* Summary:
*  Main function performs following functions:
*   1. Starts Character LCD and print project info
*   2. Starts SPI Master component
*   3. Configures the DMA transfer for RX and TX directions
*   4. Displays the results on Character LCD
*   
* Parameters:
*  None.
*
* Return:
*  None.
*
*******************************************************************************/
int main()
{
    uint8 i;
    
    LCD_Start();
    LCD_Position(0u,0u);
    LCD_PrintString("SPI Master");
    LCD_Position(1u,0u);
    LCD_PrintString("example");
    CyDelay(2000u);
    
    DmaTxConfiguration();
    DmaRxConfiguration();
    
    SPIM_Start();
    
    CyDmaChEnable(rxChannel, STORE_TD_CFG_ONCMPLT);
    CyDmaChEnable(txChannel, STORE_TD_CFG_ONCMPLT);

    while (0u == (SPIM_ReadTxStatus() & SPIM_STS_SPI_DONE))
    {
    }
    
    LCD_ClearDisplay();
    LCD_PrintString("Master Rx data:");
    LCD_Position(1u,0u);
    
    for(i=0u; i<BUFFER_SIZE; i++)
    {
        LCD_PrintHexUint8(rxBuffer[i]);
    }

    for(;;)
    {
    }
}
signed char DisplayMenu(const char *Menu[], char ItemCount, char Initial) {
    char SecondLine = 0;
    signed char SelectedItem = 0;
    signed char ret = 0;

    SelectedItem = Initial;

    while (1) {
        LCD_ClearDisplay();
        if (SecondLine) {
            LCD_SetPosition(0, 1);
            if (SelectedItem == 0) LCD_PrintString(Menu[ItemCount]);
            else LCD_PrintString(Menu[SelectedItem - 1]);
            LCD_SetPosition(1, 0);
            LCD_PrintChar('*');
            LCD_PrintString(Menu[SelectedItem]);
            LCD_SetPosition(1, 0);
        } else {
            LCD_PrintChar('*');
            LCD_PrintString(Menu[SelectedItem]);
            LCD_SetPosition(1, 1);
            if (SelectedItem == ItemCount) LCD_PrintString(Menu[0]);
            else LCD_PrintString(Menu[SelectedItem + 1]);
            LCD_SetPosition(0, 0);
        }

        ret = GetInput();
        if (ret < 0) {
            SelectedItem = ret;
            goto exit;
        }

        switch (ret) {
            case USER_INPUT_CLICK:
                goto exit;
            case USER_INPUT_BACK:
                SelectedItem = -1;
                goto exit;
            case USER_INPUT_CANCEL:
                SelectedItem = -2;
                goto exit;
            case USER_INPUT_INC:
                SecondLine = 1;
                if (SelectedItem == ItemCount) SelectedItem = ItemCount;
                else SelectedItem++;
                break;
            case USER_INPUT_DEC:
                SecondLine = 0;
                if (SelectedItem == 0) SelectedItem = 0;
                else SelectedItem--;
                break;
        }
    }
exit:
    return (SelectedItem);
}