📄 mainb.c
字号:
#include "C240.h"
/* define constant value */
#define FALSE 0
#define TRUE 1
#define VELOCITY_CONST 1562500
/* define variable */
unsigned int IA_max,IB_max,IC_max; /* MAX limit for current */
unsigned int IA_min,IB_min,IC_min; /* MIN limit for current */
unsigned int ADC_channel; /* Channel for A/D convert */
int display_times; /* accumulation for display */
int T3overflow_counter; /* T3 overflow times */
int input_state;
int sign_state=1;
int dot_state;
int CAP1_flag;
int inputdata_num;
int key_state;
unsigned int input_value;
unsigned int input_dotbit;
unsigned int position_value;
unsigned int position_dotbit;
unsigned int position;
unsigned int velocity_value;
unsigned int velocity_dotbit;
unsigned int int_position;
int display_order=1; /* 1 while display velocity ,2 while display current ,3 while display input data */
/* define Input/Output variable value */
ioport unsigned int port0,port1,port2,port3,port4,port5;
/* define structure type and variable value */
struct CAP_INT
{
unsigned int PA_value;
unsigned int CAP_value;
unsigned long delta_count;
struct CAP_INT * next;
};
struct CAP_INT * CAP_p;
/*********************************************/
/* Creat circle linkage table */
struct CAP_INT * creat_link()
{
int i;
struct CAP_INT * h,* p; /* pointer h point to virtual value */
h=(struct CAP_INT *)malloc(sizeof(struct CAP_INT));
h->next=h;
for(i=1;i<=5;i++)
{
p=(struct CAP_INT *)malloc(sizeof(struct CAP_INT));
p->PA_value=0;
p->CAP_value=0;
p->delta_count=0;
p->next=h->next;
h->next=p;
}
return (h); /* return head pointer */
}
/*********************************************/
/*********************************************/
void dsp_setup()
{
unsigned int temp;
/*********************************************/
/* Disable watchdog timer */
/*********************************************/
temp = WDCR;
temp = temp|0x68;
WDCR = temp;
/*********************************************/
/* initialize PLL module (20 MHz XTAL1) */
/*********************************************/
CKCR1 = 0x60; /* crystal=20MHz CPUCLK = 20MHz */
/* and 1x PLL mult ratio */
CKCR0 = 0xc3; /* low–power mode 0, */
/* ACLK enabled, */
/* PLL enabled, */
/* SYSCLK=CPUCLK/2 */
SYSCR = 0x40c0;
XINT1CR=0x0007;
}
/* Initiate the event management register */
void eventmgr_init()
{
GPTCON=0x0442;
/* Initialize PWM */
/* Period is 200us */
ACTR=0x09aa;
CMPR1=0x07d0;
CMPR2=0x07d0;
CMPR3=0x07d0;
DBTCON=0x0000;
COMCON=0x4a57;
COMCON=0xca57;
/* Initialize T1 */
T1PER=0xfa0;
T1CON=0x0000;
T1CON=0x910e;
/* Initialize T2 */
T2PER=0xffff; /* Period is 20us */
T2CON=0x8000;
/* Setup shared pins */
OCRA = 0xf800; /* pins IOPB0–IOPB3 & IOPA0–IOPA2 to I/O pins */
OCRB = 0x00f1; /* pins are: ADSOC, XF, /BIO, CAP1–CAP4 */
PADATDIR = 0x0707
; /* outputs IOPA0–IOPA2, set low */
PBDATDIR = 0x0704; /* outputs IOPB0–IOPB2, set high */
/* Initialize T3 */
T3CNT=0x0;
T3PER=0xffff;
T3CON=0x9440; /* Prescaler=/16 */
/* Setup capture units */
CAPCON = 0x0; /* reset capture control register */
CAPFIFO= 0x0ff; /* Clear FIFO’s */
CAPCON = 0xa6c0; /* enable #1, use Timer3, both edges */
/* enable PWM output */
T1CON=0x914e;
}
/*******************************************************************/
void disable_interrupts()
{
asm(" SETC INTM");
}
/************************************************************************/
void enable_interrupts()
{
IFR = 0xffff; /* Clear pending interrupts */
IFRA = 0xffff;
IFRB = 0xffff;
IFRC = 0xffff;
IMR = 0x000e; /* Enable CPU Interrupts:INT 2,3,4 */
IMRA = 0x0080; /* Enable timer 1 period interrupts */
IMRB = 0x0010; /* Enable temer 3 period interrupts */
IMRC = 0x0001; /* Enable CAP1 interrupts*/
asm(" CLRC INTM"); /* Global interrupt enable */
}
/* initiating parameter and register */
void init_SRM()
{
velocity_value=0;
velocity_dotbit=4;
position_value=position=0;
position_dotbit=4;
input_value=0;
input_dotbit=4;
display_times=0;
key_state=0;
input_state=FALSE;
sign_state=FALSE;
dot_state=FALSE;
display_order=3;
inputdata_num=0;
T3overflow_counter=0;
}
/********************************************************** */
/* READ CAPTURE FIFO REGISTERS
/* This routine is used to read the data from the capture FIFO
/* registers.
/*
/* inputs: capture = which FIFO to read?
/* range = 1–3
/* outputs fifo_data =
/* range = 0–65535
/********************************************************* */
unsigned int read_fifo(int capture)
{
unsigned int fifo_data;
int fifo_status;
if (capture == 1)
{
do {
fifo_data = FIFO1; /* read value */
fifo_status = CAPFIFO & 0x0300; /* read status register, mask bits */
}
while (fifo_status != 0);
}
else
fifo_data = 0xffff; /* error, not a valid capture */
return fifo_data;
}
/* ISR for GPT1 interrupt */
void c_int2()
{
IFR=0x0002; /* clear CPU interrupt flag */
IFRA=0x7ff;
display_times++;
}
/* ISR for GPT3 interrupt */
void c_int3()
{
IFR=0x0004; /* clear CPU interrupt flag */
IFRB=0x0ff; /* clear interrupt flag */
T3overflow_counter++;
}
/* ISR for CAP unit interrupt */
void c_int4()
{
int groupc_flags;
int capture;
struct CAP_INT * p;
IFR=0x0008; /* clear CPU interrupt flag */
groupc_flags = IFRC;
p=CAP_p;
CAP_p=CAP_p->next;
if (groupc_flags & 0x1) /* read event manger interrupt */
{
/* capture #1 */
IFRC = 0xff; /* clear flag register */
capture = 1;
PADATDIR=CAP_p->PA_value;
}
else
{
/* not a valid capture */
IFRC = 0xff;
capture = 0;
}
CAP_p->CAP_value = read_fifo(capture); /* read FIFO */
CAP_p->delta_count = 65535*T3overflow_counter + CAP_p->CAP_value - p->CAP_value;
T3overflow_counter=0;
position=position+75; /* accumulate position */
}
/*************************************/
/* drive SRM */
void drive_SRM()
{
static unsigned int clock_PAvalue[6]={0x0704,0x0706,0x0702,0x0703,0x0701,0x0705};
static unsigned int anticlock_PAvalue[6]={0x0706,0x0704,0x0705,0x0701,0x0703,0x0702};
int i;
struct CAP_INT * p;
CAP_p=creat_link();
p=CAP_p->next;
if (sign_state) /* drive SRM */
{
PADATDIR=0x0702;
for(i=0;i<=5;i++)
{
p->PA_value=anticlock_PAvalue[i];
p->delta_count=0;
p=p->next;
}
}
else
{
PADATDIR=0x0704;
for(i=0;i<=5;i++)
{
p->PA_value=clock_PAvalue[i];
p->delta_count=0;
p=p->next;
}
}
}
/*********************************************/
void keyboard_ISR()
{
int i;
unsigned int scan_in,scan_out,x2;
int row,column=0,key_NO; /* row=0,1,2; column=1,2,3,4 */
row=4;
for(i=0;i<7500;i++);
scan_in=port5;
x2=scan_in & 0x0f;
if (x2!=0x0f)
{
switch(x2)
{
case 0x0e: column=4;
break;
case 0x0d: column=3;
break;
case 0x0b: column=2;
break;
case 0x07: column=1;
break;
default : column=17;
}
scan_out=0x0f7;
port0=scan_out; /* scan keyboard */
for(i=0;i<1000;i++);
scan_in=port5;
while ((scan_in & 0x0f)==0x0f)
{
scan_out=scan_out>>1;
port0=scan_out;
for(i=0;i<1000;i++);
scan_in=port5;
row--;
if (row==0)
{
row=17;
break;
}
}
key_NO=4*(row-1)+column;
port0=0x00;
x2=port5;
while ((x2&0x0f)!=0x0f)
{
x2=port5;
port0=0x00;
}
for(i=0;i<7500;i++);
x2=port5;
while ((x2&0x0f)!=0x0f)
{
x2=port5;
port0=0x00;
}
switch(key_NO)
{
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
case 6 :
case 7 :
case 8 :
case 9 :
case 10 : if (input_state==FALSE) /* deal with data keyboard */
break;
if (dot_state)
input_dotbit--;
input_value=input_value*10+key_NO-1;
inputdata_num++;
break;
case 11 : if (input_state==FALSE) /* deal with radix point keyboard */
break;
if (dot_state)
break;
input_dotbit=3;
if ((input_dotbit==0) || (inputdata_num>=4))
input_dotbit=4;
break;
case 12 : if (sign_state) /* deal with sign keyboard */
sign_state=FALSE;
else
sign_state=TRUE;
break;
/***********************/
/* code for denote the reverse state */
/***********************/
case 13 : /*PADATDIR = 0x0702; /* fire phase B */
input_state=TRUE;
init_SRM();
/* Enable timer 1 period interrupts */
IFR = 0xffff;
IFRA = 0x7ff;
IMR = 0x0002; /* Enable CPU Interrupts:INT */
IMRA = 0x0080; /* Enable timer 1 period interrupts */
asm(" CLRC INTM"); /* Global interrupt enable */
/* location SRM, fire phase A */
PADATDIR = 0x0701; /* outputs IOPA0–IOPA2, IOPA0 set high */
break;
case 14 : display_order++;
if (display_order==4);
display_order=1;
break;
case 15 : disable_interrupts();
display_order=1;
enable_interrupts();
drive_SRM();
break;
case 16 :
/* stop SRM */
disable_interrupts();
PADATDIR = 0x0703; /* outputs IOPA0–IOPA2, IOPA0 set high */
break;
default : break;
}
}
}
/*************************************/
/* ISR for A/D and keyboard interrupt */
void c_int6()
{
unsigned int sysint_vector;
IFR=0x0020; /* Clear interrupt flags */
sysint_vector=SYSIVR; /* read interrupt vector address offset */
if (sysint_vector=0x0001) /* if keyboard(XINT1) interrupt */
{
keyboard_ISR();
XINT1CR=0x0007;
}
}
/* display data on LCD */
void display(display_value,dot_bit)
unsigned int display_value; /* the value want to be displayed */
int dot_bit; /* dot bit */
{
unsigned int bit_value[4];
int x;
port1=0;
if (display_value>=2000)
port1=port1|0x40;
bit_value[3]=display_value%10; /* the lowest bit data */
bit_value[2]=(display_value/10)%10;
bit_value[1]=(display_value/100)%10;
bit_value[0]=display_value/1000; /* the highest bit data */
if (bit_value[0]==1)
port1=port1|0x02;
if (sign_state)
port1=port1|0x01;
x=dot_bit;
if (x!=4)
port1=port1|(1<<(x+1)); /* show radix point */
port2=bit_value[1];
port3=bit_value[2];
port4=bit_value[3];
if ((dot_bit==3)&&(bit_value[1]==0)&&(bit_value[0]==0))
port3=0x0f;
}
/* ***************************************************************** */
/* The main program
/* ***************************************************************** */
main()
{
long velocity;
unsigned int x1;
int i;
unsigned long delta_count;
struct CAP_INT * p1;
disable_interrupts();
dsp_setup();
eventmgr_init();
init_SRM();
for(;;)
{
port0=0x00;
x1=XINT1CR;
if (x1&0x8000)
{
keyboard_ISR();
XINT1CR=0x0007;
}
if (display_times>=500)
{
display_times=0;
switch(display_order)
{
case 1: /* read velocity */
delta_count=0;
p1=CAP_p;
for(i=1;i<=6;i++)
{
delta_count=delta_count+p1->delta_count;
p1=p1->next;
}
if (delta_count==0)
velocity=0;
else
velocity=VELOCITY_CONST*60/delta_count;
velocity_value=(unsigned int)velocity;
if (velocity_value%10)
{
velocity_value=velocity;
velocity_dotbit=3;
if (velocity_value>2000)
{
velocity_value=velocity/10;
velocity_dotbit=4;
}
}
else
{
velocity_value=velocity/10;
velocity_dotbit=4;
}
display(velocity_value,velocity_dotbit);
break;
case 2: /* read position */
position_value=position;
if (position_value%10)
{
position_value=position;
position_dotbit=3;
if (position_value>2000)
{
position_value=position/10;
position_dotbit=4;
}
}
else
{
position_value=position;
position_dotbit=4;
}
display(position_value,position_dotbit); break;
case 3: display(input_value,input_dotbit); break;
default: break;
}
}
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -