hello.c

port of ARM to NOkia 3310 display

/***************************************************************************************************************
*
*                           NOKIA Lcd, ARM7, SD/MMC PROJECT
*
*
***************************************************************************************************************/
#include "globals.h"
#include "includes.c"


/* INTERRUPTS */
static cyg_interrupt      			int1;
static cyg_handle_t     			int1_handle;

/* SEMAPHORES */
static cyg_sem_t        			gps_data_validity;

/* DEFINES */
#define NTHREADS  				5
#define STACKSIZE  				(CYGNUM_HAL_STACK_SIZE_TYPICAL)

/* STATIC */
static cyg_handle_t     			thread[NTHREADS];
static cyg_thread        			thread_obj[NTHREADS];
static char stack[NTHREADS][STACKSIZE];

// Interrupt service routine for int1
cyg_uint32   interrupt_1_ISR(cyg_vector_t vector, cyg_addrword_t data)
{
    cyg_interrupt_mask(vector);
    cyg_interrupt_acknowledge(vector);
    return(CYG_ISR_HANDLED | CYG_ISR_CALL_DSR);
    
}

// deferred service routine for int1
void interrupt_1_dsr(cyg_vector_t vector,  cyg_ucount32 count,  cyg_addrword_t data )
{
    //cyg_semaphore_post(& );
    cyg_interrupt_unmask(vector);
}


// exception handler
void system_call_exception_handler( cyg_addrword_t data,
                                                      cyg_code_t number,
                                                      cyg_addrword_t info)
{
    cls();
    nokia_printmessage("System Halted",1);
    diag_printf("\n ERROR: System Call Exception \n");
}


// CYG_STAFF
cyg_mutex_t                			cliblock;        /* and now a mutex to protect calls to the C library */
cyg_alarm_t                			test_alarm_func;
cyg_handle_t               			mbox_handle;




/* CYG USER START */
void cyg_user_start(void)
{
    //exception
    cyg_exception_handler_t *old_handler;
    cyg_addrword_t old_data;
  
    //Init LCD, eCos logo
    EcosLogo();
    
    //Init Led, Buttton
    LedButInit();
   
    //Clear lcd
    cls(); 
 
    cyg_vector_t  				int1_vector = CYGNUM_HAL_INTERRUPT_UART0;
    cyg_priority_t 				int1_priority = 0 ;
    
    //SEMAPHORES     
    //cyg_semaphore_init(&gps_data_validity,0);
    
    //MUTEX  
    cyg_mutex_init(&cliblock);
    
    // CREATE THREADS
    // ATENTION! BITMAP SHEDULER!!!
    cyg_thread_create(5,   GPS_program,    (cyg_addrword_t) 0,  "gps",      (void *) stack[0], STACKSIZE, &thread[0], &thread_obj[0]);
    cyg_thread_create(13,  LCD_program,    (cyg_addrword_t) 1,  "lcd",      (void *) stack[1], STACKSIZE, &thread[1], &thread_obj[1]);
    cyg_thread_create(11,  BTN_program,    (cyg_addrword_t) 2,  "btn",      (void *) stack[2], STACKSIZE, &thread[2], &thread_obj[2]);
    cyg_thread_create(12,  ALARM_program,  (cyg_addrword_t) 3,  "alarm",    (void *) stack[3], STACKSIZE, &thread[3], &thread_obj[3]);
    cyg_thread_create(6,   SER0_program,   (cyg_addrword_t) 4,  "ser0",     (void *) stack[4], STACKSIZE, &thread[4], &thread_obj[4]);
      
    //INIT INTERRUPT
    cyg_interrupt_create(int1_vector,  int1_priority,  0, &interrupt_1_ISR, &interrupt_1_dsr, &int1_handle,  &int1);
    
    //THREADS RESUME  
    //GPS
    cyg_thread_resume(thread[0]);
    //LCD
    cyg_thread_resume(thread[1]);
    //BUTTON
    cyg_thread_resume(thread[2]);
    //ALARM
    cyg_thread_resume(thread[3]);
    //SER0
    cyg_thread_resume(thread[4]);
    //Atach
    cyg_interrupt_attach(int1_handle);
    //Unmask
    cyg_interrupt_unmask(int1_vector);
      
    /*
     //install the exception handler for error output:
     cyg_exception_set_handler( CYGNUM_HAL_EXCEPTION_ILLEGAL_INSTRUCTION ,
                                            &system_call_exception_handler,
                                            0,
                                            &old_handler,
                                            &old_data);
    */
            
    return;
}




void BTN_program(cyg_addrword_t index)
{
      //button control  
      for(;;)
      {   
           //Icone select by Button press
           if(IOPIN>>SWPIN==0)
           {
                 beep(5,2);
                 // 4 icons counter
                 if(menu_counter < ICON_COUNTER)   menu_counter +=1;
                 else menu_counter =0x00;
				 
		 // Close/Suspend windows with button press
                 gps_latitude_flag = 0x00;
                 gps_status_flag = 0x00;
                 draw_window=0x00;
                 console_msg_flag=0x00;
                 LED_OFF;
                      
                 cyg_thread_delay(50);
           }
	   cyg_thread_delay(10);//don't pip!
      }
}




void LCD_program(cyg_addrword_t data)
{
     // show on lcd. Graphic mode
     lcd_key=0x00; 
     
     for(;;)
     {  
        // show Datum on if lcd is not busy      
        if(!lcd_key)
        {
        	//DRAW MAIN WINDOW
                draw_picture(mainwin);
                  
                //LATITUDE /NORD/
                if(gps_latitude_flag) gps_latitude();
                                                        
                //GPS STATUS WINDOW /system control/
                if(gps_status_flag) gps_status();
                   
                //ABOUT
                if(draw_window)  Draw_Window(2,10,60,25,"About","GPS VER.1.0");
                    
		//CONSOLE MSG
                if(console_msg_flag)  {Draw_Window(2,10,79,25,"Console",&console_buff[2]);}

                //SHOW THE LCD BUFF !!!!!
	        LcdUpdate();
         }
         else {lcd(&current_latitude[0]);lcd(&current_longitude[0]);}
         cyg_thread_delay(10); //don't pip!   
     }
}

   


void GPS_program(cyg_addrword_t data)
{
      
   FILE * pSER1;
   cyg_uint32 len = 126;        /* data length */
   //cyg_serial_info_t info;	/* serial port config info */
   //Cyg_ErrNo error;		/* error output*/
   //cyg_io_handle_t handle;	/* mouse device handle */
     
 
   /* eCos com0 open */
   //error=cyg_io_lookup("dev/ser0", &handle);
   //len=sizeof(info);
   pSER1=fopen("/dev/ser1","r");    

  for(;;)
  {
    fgets (&Gps_buff[0], len, pSER1);

        
    //$GPRMC
    if(Gps_buff[0]=='$')
    {
       if(Gps_buff[1]=='G')
       {
          if(Gps_buff[2]=='P')
          {
	     if(Gps_buff[3]=='R')
             {
                if(Gps_buff[4]=='M')
                {
		     //Read buff
                     strcpy(&GPRMC[0], &Gps_buff[0]); GPRMC[127]='\0';
                     //CALL GPS SUB
                     GPS();
                }
             }
          }
       }
       
    }
    free(Gps_buff); 
    //fclose(pSER1);
    cyg_thread_delay(10);
 }

}


/* CONSOLE */
void SER0_program(cyg_addrword_t data)
{
  FILE * pSER0;
  cyg_uint32 len = 126;         /* data length */
  //cyg_serial_info_t info;	/* serial port config info */
  //Cyg_ErrNo error;		/* error output*/
  //cyg_io_handle_t handle;	/* mouse device handle */
     
 
  /* eCos com0 open */
  //error=cyg_io_lookup("dev/ser0", &handle);
  //len=sizeof(info);
  pSER0 = fopen("/dev/ser0","r");    

  for(;;)
  {
    fgets (&ser0_buff[0], len, pSER0);

    //@CONSOLE
     if(ser0_buff[0]=='@')
     {	
        if(ser0_buff[1]=='c')
        {	
           if(ser0_buff[2]=='o')
           {
              if(ser0_buff[3]=='n')
              {
                  //turn_0ff gps recaiving
                  mode = 0x02;
                  //IMPORTANT : The console message must be terminated by #013#010(dec)! 
                  strncpy(&console_buff[0], &ser0_buff[4],15); console_buff[127]='\0';
		  console();
              }
           }
        }
     }
    free(ser0_buff); 
    //fclose(pSER1);
    cyg_thread_delay(10);
  }
} 
 
 
 
 
 
 
    
 // alarm_prog() is a thread which sets up an alarm which is then handled by test_alarm_func() 
 void ALARM_program(cyg_addrword_t data)
{
  cyg_handle_t test_counterH, system_clockH, test_alarmH;
  cyg_tick_count_t ticks;
  cyg_alarm test_alarm;
  unsigned how_many_alarms = 0, prev_alarms = 0, tmp_how_many;

  system_clockH = cyg_real_time_clock();
  cyg_clock_to_counter(system_clockH, &test_counterH);
  cyg_alarm_create(test_counterH, test_alarm_func, (cyg_addrword_t) &how_many_alarms, &test_alarmH, &test_alarm);
  
  //init alarm trig.= 500, interval = 4000
  cyg_alarm_initialize(test_alarmH, cyg_current_time() + 500, 4000);

  // get in a loop in which we read the current time and  print it out
  for (;;) 
  {
  
    ticks = cyg_current_time();
   
    cyg_scheduler_lock();
        tmp_how_many = how_many_alarms;
    cyg_scheduler_unlock();
    
    if (prev_alarms != tmp_how_many) 
    {
       LED_OFF;

      // Code for Alarm Event
      // Close/Suspend windows
      //LATITUDE
      if( !gps_latitude_flag )  gps_latitude_flag=0x01;
      else gps_latitude_flag = 0x00;
      cyg_thread_delay(500);
      
      //SYSTEN STATUS
      if( !gps_status_flag )  gps_status_flag=0x01;
      else  gps_status_flag = 0x00;
      cyg_thread_delay(500);
      
      //DRAW WINDOW
      if(!draw_window) draw_window=0x01;
      else draw_window=0x00;
      cyg_thread_delay(500);

      //CONSOLE MESSAGES
      if(console_msg_flag)  console_msg_flag=0x00;
      cyg_thread_delay(500);

      //Prevent Alarm
      prev_alarms = tmp_how_many;
    }
     
    cyg_thread_delay(300);
  }
}







/*
   test_alarm_func() is invoked as an alarm handler, so
   it should be quick and simple.  in this case it increments
   the data that is passed to it. 
*/
void test_alarm_func(cyg_handle_t alarmH, cyg_addrword_t data)
{
    ++*((unsigned *) data);
}

//eof