cm_main1.c

uClinux 下MicroWindows开发的电机控制平台软件和模拟示波器的双路数据采集系统源码

			            arry_y[7]='\0';

			            GrClearWindow(WIN_Massage,GR_FALSE);

                        GrFillRect(WIN_Massage,Gid_Button,0,0,60,20);//画填充矩形为按钮
                        GrText(WIN_Massage,Gid_Message,4,18,arry_x,-1,GR_TFASCII);
                        GrText(WIN_Massage,Gid_Message,4,38,arry_y,-1,GR_TFASCII);

                        GrEllipse(WIN_Screen,Gid_Red_Red,Real_x(Current_x),Real_y(Current_y),1,1);
	                }


		            Mark_OBStatus = START;
	            }
	        }
	        if(Mark_OBStatus == ARRIVED)
	        {
	            GrClearWindow(WIN_Status,GR_FALSE);
                GrFillRect(WIN_Status,Gid_Red_Red,0,0,50,25);//画填充矩形为按钮
                GrText(WIN_Status,Gid_Black_Red,5,18,"已完成",-1,GR_TFASCII);

                GrClearWindow(WIN_But_Start,GR_FALSE);
                GrFillRect(WIN_But_Start,Gid_Button,0,0,Button_Width,Button_High);//画填充矩形为按钮
                GrText(WIN_But_Start,Gid_ButtonName,9,18,"开始",-1,GR_TFASCII);

		        GrClearWindow(WIN_But_Stop,GR_FALSE);
                GrFillRect(WIN_But_Stop,Gid_ButtonDown,0,0,Button_Width,Button_High);//画填充矩形为按钮
                GrText(WIN_But_Stop,Gid_ButtonDownName,9,18,"停止",-1,GR_TFASCII);
		        Mark_OBStatus = STOP;
	        }
	}

}

void  CM_gvGoTo(int X_Y_pos)
{
     int New_x;
     int New_y;
     int Left_steps;
     int Right_steps;
     int Left_direction;
     int Right_direction;
     float Left_length;
     float Right_length;


     New_x = X_Y_pos%1000;
     New_y = X_Y_pos/1000;
     
     Left_length = sqrt((New_x/2+15)*(New_x/2+15)+(115-New_y/2)*(115-New_y/2))-
     sqrt((Current_x/2+15)*(Current_x/2+15)+(115-Current_y/2)*(115-Current_y/2));
     
     Right_length = sqrt((95-New_x/2)*(95-New_x/2)+(115-New_y)*(115-New_y))-
     sqrt((95-Current_x/2)*(95-Current_x/2)+(115-Current_y/2)*(115-Current_y/2));
     
     Left_steps = abs(Left_length/STEP_LENTGTH);
     Right_steps = abs(Right_length/STEP_LENTGTH);
     
     if(Left_length >= 0)
     {
         Left_direction =FORWARD;
     }
     else
     {
         Left_direction =BACKWARD;
     }
     if(Right_length >= 0)
     {
         Right_direction =FORWARD;
     }
     else
     {
         Right_direction =BACKWARD;
     }
     if(Left_steps>=Right_steps)
     {
         if((Left_direction == BACKWARD)&&(Right_direction == BACKWARD))
         {
             while(Right_steps)
             {
                 EXIO = ALL_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Left_steps)
             {
                 EXIO = LEFT_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
             }
             
         }
         else if((Left_direction == FORWARD)&&(Right_direction == FORWARD))
         {
             while(Right_steps)
             {
                 EXIO = ALL_FORWARD;
                 EXIO = ALL_DOWN;
                 Left_steps--;
                 Right_steps--;
             }
             while(Left_steps)
             {
                 EXIO = LEFT_FORWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
             }
             
         }
         else if((Left_direction == BACKWARD)&&(Right_direction == FORWARD))
         {
             while(Right_steps)
             {
                 EXIO = LB_RF;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Left_steps)
             {
                 EXIO = LEFT_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
             }
             
         }
         else if((Left_direction == FORWARD)&&(Right_direction == BACKWARD))
         {
             while(Right_steps)
             {
                 EXIO = LF_RB;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Left_steps)
             {
                 EXIO = LEFT_FORWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
             }
             
         }
     }
     else
     {
         if((Left_direction == BACKWARD)&&(Right_direction == BACKWARD))
         {
             while(Left_steps)
             {
                 EXIO = ALL_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Right_steps)
             {
                 EXIO = RIGHT_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Right_steps--;
             }
             
         }
         else if((Left_direction == FORWARD)&&(Right_direction == FORWARD))
         {
             while(Left_steps)
             {
                 EXIO = ALL_FORWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Right_steps)
             {
                 EXIO = RIGHT_FORWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Right_steps--;
             }
             
         }
         else if((Left_direction == BACKWARD)&&(Right_direction == FORWARD))
         {
             while(Left_steps)
             {
                 EXIO = LB_RF;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Right_steps)
             {
                 EXIO = RIGHT_FORWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Right_steps--;
             }
             
         }
         else if((Left_direction == FORWARD)&&(Right_direction == BACKWARD))
         {
             while(Left_steps)
             {
                 EXIO = LF_RB;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Left_steps--;
                 Right_steps--;
             }
             while(Right_steps)
             {
                 EXIO = RIGHT_BACKWARD;
                 delay();
                 EXIO = ALL_DOWN;
                 delay();
                 Right_steps--;
             }
             
         }
     }

}

void delay()
{
    int i;
    for(i=0;i<DELAY_TIME;i++);
}

int main(void)
{
       EXIO = 0xf0;
	QU_giInitQueue();
    CM_giDrawWindows();
	return(1);
}
int QU_giSetDataIntoQueue(int aiElement) 
{ 
    return (QU_niAddQueue(aiElement));    
} 

int QU_giGetDataFromQueue(void) 
{ 
    return(QU_niDelQueue());
} 

 
int QU_giInitQueue(void)
{ 
    astQueue.front = astQueue.rear = (QU_queuePtr_st)malloc(sizeof(QU_Node_st));
	astQueue.length = 0;	
	astQueue.frontSign = 1;
	astQueue.rearSign = 1;
	return (1);  
} 

int QU_giReInitQueue(void) 
{ 
	int i;
	
	for(i = 1;i <= astQueue.length;i++)
	{
		free(astQueue.rear);
		astQueue.rear = (*astQueue.rear).next;
	}
	if(astQueue.front == astQueue.rear)
	{
		astQueue.length = 0;	
		astQueue.frontSign = 1;
		astQueue.rearSign = 1;
		return (1);
	}	
	else
	return (0);  
} 

int QU_niIsEmptyQueue(void) 
{
	if(astQueue.front == astQueue.rear)
    return (1);
    else
    return(0);
}

int QU_niAddQueue(int aiElement)
{
    QU_queuePtr_st p;
    
    if(!QU_niIsFullQueue())
    {
    	if(1 == astQueue.frontSign)
    	{
    		astQueue.frontSign = 0;
    		p = (QU_queuePtr_st)malloc(sizeof(QU_Node_st));
    		(*p).next = NULL;
    		(*p).data = -1;
    		(*astQueue.front).data = aiElement;
    		(*astQueue.front).next = p;    		
    		astQueue.front = p;
    		astQueue.length++;
			astQueue.frontSign = 1;
			return(1);
		}
		else
		{
			return(0);
		}
	}
	else
	{
		printf("Error !>>>>>>>The queue is full!\n");
		return(-1);
	}	 	
}

int QU_niDelQueue(void)
{
    int i;
    
    if(!QU_niIsEmptyQueue())
    {
    	if(1 == astQueue.rearSign)
    	{
    		astQueue.rearSign = 0;
    		i = (*astQueue.rear).data;
    		free(astQueue.rear);
			astQueue.rear = (*astQueue.rear).next;
			astQueue.length--;
			astQueue.rearSign = 1;
			return (i);
		}
		else
		{
			return(-1);
		} 	
	}
	else
	{
		printf("Error !>>>>>>>It is an Empty queue!\n");
		return(-1);
	}	
}

int QU_niIsFullQueue(void)
{
    if(MAX_QUEUE_LENGTH == astQueue.length)
    return (1);
    else
    return (0);
}