//-------Exynos Linux에 사용된 함수 및 소스코드---------// //------------UART 디바이스 드라이브 제어용 코드-----------// #include #include #include #include #include #include #include #include #include #include #include int open_serial( char *dev_name, int baud, int vtime, int vmin ) { int fd; struct termios newtio; // \uc2dc\ub9ac\uc5bc\ud3ec\ud2b8\ub97c \uc5f0\ub2e4. fd = open( dev_name, O_RDWR | O_NOCTTY ); if ( fd < 0 ) { // \ud654\uc77c \uc5f4\uae30 \uc2e4\ud328 printf( "Device OPEN FAIL %s\n", dev_name ); return -1; }// \uc2dc\ub9ac\uc5bc \ud3ec\ud2b8 \ud658\uacbd\uc744 \uc124\uc815\ud55c\ub2e4. memset(&newtio, 0, sizeof(newtio)); newtio.c_iflag = IGNPAR; // non-parity newtio.c_oflag = 0; newtio.c_cflag = CS8 | CLOCAL | CREAD; // NO-rts/cts switch( baud ) { case 1000000 : newtio.c_cflag |= B1000000; break; case 115200 : newtio.c_cflag |= B115200; break; case 57600 : newtio.c_cflag |= B57600; break; case 38400 : newtio.c_cflag |= B38400; break; case 19200 : newtio.c_cflag |= B19200; break; case 9600 : newtio.c_cflag |= B9600; break; case 4800 : newtio.c_cflag |= B4800; break; case 2400 : newtio.c_cflag |= B2400; break; default : newtio.c_cflag |= B115200; break; } newtio.c_lflag = 0; newtio.c_cc[VTIME] = vtime; // timeout 0.1\ucd08 \ub2e8\uc704 newtio.c_cc[VMIN] = vmin; // \ucd5c\uc18c n \ubb38\uc790 \ubc1b\uc744 \ub54c\uae4c\uc9c4 \ub300\uae30 tcflush ( fd, TCIFLUSH ); tcsetattr( fd, TCSANOW, &newtio ); return fd; } void close_serial( int fd ) { close( fd ); } //------------통신용 프로토콜 명령어 세트------------// typedef enum {//instruction moter_r_go=1, moter_r_back, moter_l_go, moter_l_back, arm_r_x_up, arm_r_x_down, arm_r_y_up, arm_r_y_down, arm_r_z_up, arm_r_z_down, arm_r_end_up, arm_r_end_down, arm_r_hand_on, arm_r_hand_off, arm_l_x_up, arm_l_x_down, arm_l_y_up, arm_l_y_down, arm_l_z_up, arm_l_z_down, arm_l_end_up, arm_l_end_down, arm_l_hand_on, arm_l_hand_off, }inst_set; //------------key패드 제어를 위한 코드------------// #include #include #include #include #include #include #include #include "inst_lib.h" char getche_linux(void) { struct termios oldt, newt; int ch; tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); tcsetattr(STDIN_FILENO, TCSANOW, &newt); ch = getchar(); // printf("in %c", ch); tcsetattr(STDIN_FILENO, TCSANOW, &oldt); return ch; } int main(){ char val; char m3_name[128]="/dev/ttySAC0"; int fd_m3; int rdcnt; unsigned char buf[2]; fd_m3=open_serial(m3_name,115200,1,1); if ( fd_m3 <0) return -2; while(1){ //read(fd_m3,buf,1); //printf("%c",buf[0]); buf[1]=0; val = getche_linux(); //printf("%d \n",val); //if(val==0)continue; //val = getche(); switch(val){ //right command case 's': buf[1]=arm_l_y_down; break; case 'd': buf[1]=arm_l_z_down; break; case 'f': buf[1]=arm_l_y_up; break; case 'e': buf[1]=arm_l_z_up; break; case 'w': buf[1]=arm_l_x_up; break; case 'r': buf[1]=arm_l_x_down; break; case 'q': buf[1]=arm_l_end_up; break; case 'a': buf[1]=arm_l_end_down; break; case 't': buf[1]=arm_l_hand_on; break; case 'g': buf[1]=arm_l_hand_off; break; //left command case 'l': buf[1]=arm_r_y_down; break; case 'k': buf[1]=arm_r_z_down; break; case 'j': buf[1]=arm_r_y_up; break; case 'i': buf[1]=arm_r_z_up; break; case 'o': buf[1]=arm_r_x_up; break; case 'u': buf[1]=arm_r_x_down; break; case 'p': buf[1]=arm_r_end_up; break; case ';': buf[1]=arm_r_end_down; break; case 'y': buf[1]=arm_r_hand_on; break; case 'h': buf[1]=arm_r_hand_off; break; //moter command case 'b': buf[1]=moter_l_go; break; case 'n': buf[1]=moter_r_go; break; case 'v': buf[1]=moter_l_back; break; case 'm': buf[1]=moter_r_back; break; } //buf[0]='0'; if(buf[1]!=0){ buf[0]=0xff; write(fd_m3,buf,2); printf("%d\n",buf[1]); } } } //-----------블루투스 통신을 위한 소스코드------------// #include #include "inst_lib.h" #include #include #include #include #include #include #include #define Setbit(x,y) ( x |= (1<=1024)return ; if(Pos<0)return ; unsigned char check = 0; AX_put(0xff); AX_put(0xff); AX_put(Id);//id AX_put(5);//length AX_put(0x03);//instruction AX_put(0X1E);//address AX_put(Pos&0xFF); AX_put((Pos>>8)&0xFF); check = ~(Id+5+3+0X1E+((Pos>>8)&0xFF)+(Pos&0xFF)); AX_put(check); } void AX_CMAR(unsigned char Id, unsigned char Pos) { unsigned char check = 0; AX_put(0xff); AX_put(0xff); AX_put(Id);//id AX_put(0X05);//length AX_put(0x03);//instruction AX_put(0X1A);//address AX_put(Pos); AX_put(Pos); check = ~(Id+5+3+0X1A+Pos+Pos); AX_put(check); } void AX_CSLO(unsigned char Id, unsigned char Pos) { unsigned char check = 0; AX_put(0xff); AX_put(0xff); AX_put(Id);//id AX_put(5);//length AX_put(0x03);//instruction AX_put(0X1C);//address AX_put(Pos); AX_put(Pos); check = ~(Id+5+3+0X1C+Pos+Pos); AX_put(check); } void AX_ID(unsigned char id,unsigned char id2){ unsigned char check = 0; AX_put(0xff); AX_put(0xff); AX_put(id);//id AX_put(0X04);//length AX_put(0x03);//instruction AX_put(0X03);//address AX_put(id2); check = ~(id2+0X04+0x03+0x03+id); AX_put(check); } void AX_RESET(unsigned char id){ unsigned char check = 0; int i; // 0XFF 0XFF 0X00 0X02 0X06 0XF7 if(id != 0){ AX_put(0xff); AX_put(0xff); AX_put(id);//id AX_put(0X02);//length AX_put(0X06);//instruction check = ~(0XFE+0X04+0x03+0x03+id); AX_put(check); }else{ uint32_t freq; printf("iput tar freq = \n"); scanf("%d",&freq); if(freq!=0){ usart.init(USE_USART,freq); // printf("%d \n",i); AX_put(0xff); AX_put(0xff); AX_put(0XFE);//id AX_put(0X02);//length AX_put(0X06);//instruction check = ~(0XFE+0X04+0x03+0x03+0XFE); AX_put(check); // printf("all Hz reset\n"); }else{ for(i=7344;i<1000001;i+=2){ usart.init(USE_USART,i); printf("%d \n",i); AX_put(0xff); AX_put(0xff); AX_put(0XFE);//id AX_put(0X02);//length AX_put(0X06);//instruction check = ~(0XFE+0X04+0x03+0x03+0XFE); AX_put(check); } } // printf("all reset complete\n"); } } #ifndef __AX_12__ #define __AX_12__ #include "stm32f10x.h" #include "usart.h" #include void AX_put(u16 data); void AX_CSLO(unsigned char Id, unsigned char Pos); void AX_CMAR(unsigned char Id, unsigned char Pos); void AX_(u8 Id, u32 Pos); void AX_ID(unsigned char id,unsigned char id2); void AX_RESET(unsigned char id); typedef struct AX_class{ void (*put)(uint16_t); void (*slope)(unsigned char Id, unsigned char Pos); void (*margine)(unsigned char Id, unsigned char Pos); void (*pos)(u8 Id, u32 Pos); void (*id)(unsigned char id,unsigned char id2); void (*reset)(unsigned char id);// 0 is all reset }AX_class; static struct AX_class ax = { .slope = AX_CSLO, .margine = AX_CMAR, .pos = AX_, .id = AX_ID, .reset = AX_RESET, }; #endif //------------AX-12_XYZ 변환을 위한 수식 코드------------// #ifndef __AX_12_CON__ #define __AX_12_CON__ #include #include "ax_12.h" #include #include #include #define PI 3.14 //파이 디파인 #define RADIAN(X) ((X)*0.01744) //라디안 변환 #define DEGREE(X) ((X)*57.32) // 디그리 변환 #define L_0 200 //arm 길이 #define ax_vpd(x) (int32_t)(3.41*x) //value per degree #define ax1_0_offset 245 #define ax1_1_offset 512 #define ax1_2_offset 512 #define ax2_0_offset 800 #define ax2_1_offset 512 #define ax2_2_offset 512 #define ax1_0_id 13 #define ax1_1_id 12 #define ax1_2_id 11 #define ax2_0_id 23 #define ax2_1_id 22 #define ax2_2_id 21 #define ax1_end_id 10 #define ax2_end_id 20 #define Right 1 #define Left 2 typedef struct { float x, y, z; }pos; typedef struct { float t0, t1, t2; }result; void xy_vect( pos *tar, result *res); //t1 하단부 , t2 중단부 t0 가 최하단부 void AX_vect(result *r, int a); void submain_axcon(void); #endif #include "ax_control.h" void xy_vect( pos *tar, result *res){ float val_0, val_1; float the_0, the_1, the_2; val_0 = tar->x*tar->x + tar->y*tar->y;//로우 벡터 val_1 = sqrtf(tar->z*tar->z + val_0);//R 벡터 val_0 = sqrtf(val_0); printf("rowu vector = %f \n", val_0); printf("Round vector = %f \n", val_1); val_1 /= 2; if (val_1t1 = DEGREE(the_0);//하단부 관절 res->t2 = DEGREE(the_1);//중단부 관절 res->t0 = DEGREE(atanf(tar->y / tar->x)); if((tar->x<0&&tar->y>0)||(tar->x>0&&tar->y<0)){ res->t0 = 180 + res->t0; } printf("t0= %f , t1= %f t2= %f \n",res->t0,res->t1,res->t2); } } //t1 하단부 , t2 중단부 t0 가 최하단부 void AX_vect(result *r, int a){ uint32_t val; float temp; if(a==Right){ temp = r->t0 ; // if(r->t0<0){ //val = ax1_0_offset - ax_vpd(temp); // // }else{ val = ax1_0_offset + ax_vpd(temp); printf("tmep = %f ax_vpd =%d \n",temp,ax_vpd(temp)); // } AX_(ax1_0_id,val); printf("t0 = %d \n ", val); temp = 90 -r->t1; val = ax1_1_offset + ax_vpd(temp); AX_(ax1_1_id,val); printf("t1 = %d \n ", val); temp = r->t2-90; val = ax1_2_offset + ax_vpd(temp); AX_(ax1_2_id,val); printf("t2 = %d \n ", val); }else if(a==Left){ temp = r->t0 ; val = ax2_0_offset - ax_vpd(temp); AX_(ax2_0_id,val); printf("2t0 = %d \n ", val); temp = 90 -r->t1 ; val = ax2_1_offset - ax_vpd(temp); AX_(ax2_1_id,val); printf("2t1 = %d \n ", val); temp = r->t2-90; val = ax2_2_offset - ax_vpd(temp); AX_(ax2_2_id,val); printf("2t2 = %d \n ", val); } } void submain_axcon(void){ int selval; printf("select mode 1.idset 2. test 3.margin 4.reset\n"); scanf("%d",&selval); if(selval==3){ int32_t id,i; printf("id, margin \n"); scanf("%d %d",&id,&i); printf("id = %d , margin = %d \n",id,i); AX_CMAR(id,i); }else if(selval==2){ int32_t id,i; while(1){ printf("id ,angle \n"); scanf("%d %d",&id,&i); printf("\n"); printf("%d %d\n",id,i); if(i=='q')break; AX_(id,i); } }else if(selval==1){ int32_t id,id2; printf("input tar id, chan id id\n"); scanf("%d %d",&id,&id2); printf("id1=%d id2=%d \n",id,id2); AX_ID(id,id2); printf("complete"); }else if(selval==4){ int32_t id; printf("input reset id\n"); scanf("%d",&id); printf("reset %d \n",id); AX_RESET(id); } } //------------하드웨어 기초 설정을 위한 코드------------// #ifndef __CONFIG__ #define __CONFIG__ #include "stm32f10x_it.h" #include #define SET(x,y) GPIO_SetBits(x,y) #define CLR(x,y) GPIO_ResetBits(x,y) #define READ_out(x,y) GPIO_ReadOutputDataBit(x,y) #define READ_in(x,y) GPIO_ReadInputDataBit(x,y) #define Setbit(x,y) ( x |= (1< 0 ; i--) { for (j = i*8-1; j >= (i-1)*8; j--) { printf("%d", (uNumber & (1 << j)) ? 1 : 0); } printf(" "); } printf("\n"); } void Systick_config(){ if(SysTick_Config(72000)){ while(1); } } void Delay_us(u32 arg){//딜레이 100us u32 Dly = arg; while(Dly--) { for(volatile int i = 71; i; i--); } } static volatile u32 TimingDelay; void TimingDelay_Decrement(void){ if(TimingDelay != 0x00){ TimingDelay--; } } void Delay_ms(__IO u32 nTime){ TimingDelay = nTime; while(TimingDelay != 0); } void Delay_s (u32 time){ while(time--) Delay_ms(1000); } void rcc_init(void){//rcc초기화 RCC_HSEConfig(RCC_HSE_ON);//hse 구동 RCC_WaitForHSEStartUp();//hse 대기 RCC_HSICmd(DISABLE);//hsi 정지 RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);//PLL설정 RCC_PLLCmd(ENABLE);//PLL사용 커맨드 RCC_HCLKConfig(RCC_SYSCLK_Div1);//HCLK clock RCC_PCLK1Config(RCC_HCLK_Div2);//PCLK1클럭 RCC_PCLK2Config(RCC_HCLK_Div1);//PCLK2클럭 //RCC_ITConfig(RCC_IT_PLLRDY,ENABLE);//RCC래디 인터럽트; PLLRDY 되면 인터럽트발생. RCC_ADCCLKConfig(RCC_PCLK2_Div6); RCC_LSEConfig(RCC_LSE_ON); RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); RCC_RTCCLKCmd(ENABLE); // Flash wait state FLASH_SetLatency(FLASH_Latency_2); // Half cycle access FLASH_HalfCycleAccessCmd(FLASH_HalfCycleAccess_Disable); // Prefetch buffer FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); NVIC_SetVectorTable(NVIC_VectTab_FLASH,0x4000); RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//SYStem clock config } //------------Exynos와 상호 통신을 위한 소스코드------------// #ifndef __EXYNOS_LINK__ #define __EXYNOS_LINK__ #include #include "usart.h" #include "stm32f10x_usart.h" #include "queue.h" #include "ax_12.h" #include "ax_control.h" #define Setbit(x,y) ( x |= (1<>8); check += (uTemp>>8); txx(uTemp>>16); check += (uTemp>>16); txx(uTemp>>24); check += (uTemp>>24); txx(check); return 0; } }*/ #endif //------------Queue 버퍼를 사용하기 위한 코드------------// #ifndef __QUEUE__ #define __QUEUE__ #include "stm32f10x.h" #include #define BUFFER_SIZE 60 #define FALSE 0 #define TRUE 1 #define __USE_USART1__ //#define __USE_USART2__ #define __USE_QUEUE_RECIEVE__ //#define __USE_PULL_RECIEVE__ typedef struct Queue_buffer{ uint32_t rx_buffer[BUFFER_SIZE]; uint32_t rx_point_head; uint32_t rx_point_tail; }Queue_buffer; extern Queue_buffer Abuffer; void System_Information(); size_t __write(int handle, const unsigned char *buf, size_t bufSize); size_t __read(int handle, unsigned char * buffer, size_t size); void increase_point_value(uint32_t * data_p); uint32_t Is_Empty(Queue_buffer *buf); void EnQueue(Queue_buffer *buf,uint32_t data); uint32_t DeQueue(Queue_buffer *buf); typedef struct Queue_class{ void (*en)(Queue_buffer *buf,uint32_t data); uint32_t (*de)(Queue_buffer *buf); uint32_t (*isempty)(Queue_buffer *buf); }Queue_class; static struct Queue_class queue ={ .en=EnQueue, .de=DeQueue, .isempty=Is_Empty }; #endif #include "queue.h" Queue_buffer Abuffer; void System_Information() { RCC_ClocksTypeDef rcc_clocks; RCC_GetClocksFreq(&rcc_clocks); printf("SYSCLK_Frequency = %d\n",rcc_clocks.SYSCLK_Frequency ); printf("HCLK_Frequency = %d\n",rcc_clocks.HCLK_Frequency ); printf("PCLK1_Frequency = %d\n",rcc_clocks.PCLK1_Frequency ); printf("PCLK2_Frequency = %d\n",rcc_clocks.PCLK2_Frequency ); printf("ADCCLK_Frequency = %d\n",rcc_clocks.ADCCLK_Frequency ); } void increase_point_value(uint32_t * data_p) { (* data_p) ++; if(BUFFER_SIZE == (* data_p)) { (* data_p) = 0; } } u32 Is_Empty(Queue_buffer *buf) { if(buf->rx_point_head == buf->rx_point_tail) { return TRUE; } return FALSE; } void EnQueue(Queue_buffer *buf,uint32_t data) { buf->rx_buffer[buf->rx_point_head] = data; increase_point_value(&buf->rx_point_head); } uint32_t DeQueue(Queue_buffer *buf) { uint32_t retVal = buf->rx_buffer[buf->rx_point_tail]; increase_point_value(&buf->rx_point_tail); return retVal; } /* size_t __read(int handle, unsigned char * buffer, size_t size) { size_t nChars = 0; unsigned char c; if (handle != 0) return -1; for (; size > 0; --size) { while(USART_GetFlagStatus(USART2, USART_FLAG_RXNE)== RESET); c = USART_ReceiveData(USART2); USART_SendData(USART2, (uint8_t)c); while(USART_GetFlagStatus(USART2, USART_FLAG_TC)== RESET); if (c == 0) break; *buffer++ = c; ++nChars; } return nChars; }*/ size_t __read(int handle, unsigned char * buffer, size_t size) {//queue 적용 코드 size_t nChars = 0; unsigned char c; if (handle != 0) return -1; for (; size > 0; --size) { #ifdef __USE_QUEUE_RECIEVE__ while(queue.isempty(&Abuffer) == TRUE); c = (u8)queue.de(&Abuffer); #elif defined __USE_PULL_RECIEVE__ #ifdef __USE_USART2__ while(USART_GetFlagStatus(USART2, USART_FLAG_RXNE)== RESET); c = USART_ReceiveData(USART2); #elif defined __USE_USART1__ while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE)== RESET); c = USART_ReceiveData(USART1); #endif #endif #ifdef __USE_USART2__ USART_SendData(USART2, (uint8_t)c); while(USART_GetFlagStatus(USART2, USART_FLAG_TC)== RESET); #elif defined __USE_USART1__ USART_SendData(USART1, (uint8_t)c); while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET); #endif if (c == 0) break; *buffer++ = c; ++nChars; } return nChars; } size_t __write(int handle, const unsigned char *buf, size_t bufSize) { size_t nChars = 0; if(handle == -1) return 0; else if(handle != 1 && handle != 2) return -1; for(;bufSize> 0; --bufSize) { #ifdef __USE_USART2__ if( *buf == '\n') { USART_SendData(USART2, '\r'); while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET); USART_SendData(USART2, '\n'); }else { USART_SendData(USART2, (uint8_t)*buf); } while(USART_GetFlagStatus(USART2, USART_FLAG_TC)== RESET); #elif defined __USE_USART1__ if( *buf == '\n') { USART_SendData(USART1, '\r'); while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET); USART_SendData(USART1, '\n'); }else { USART_SendData(USART1, (uint8_t)*buf); } while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET); #endif ++buf; ++nChars; } return nChars; } //------------UART 초기화 코드------------// #ifndef __USART__ #define __USART__ #include "stm32f10x.h" #include "misc.h" #define u1 USART1 #define u2 USART2 #define u3 USART3 void usart_rx_interrupt(USART_TypeDef* USARTx,FunctionalState); void usart_tx_interrupt(USART_TypeDef* USARTx,FunctionalState); void usart_init(USART_TypeDef* USARTx,uint32_t baudrate); void J_USART_SendData(USART_TypeDef* USARTx,uint16_t data); uint16_t J_USART_ReceiveData(USART_TypeDef* USARTx); typedef struct USART_class { void (*init)(USART_TypeDef* USARTx,uint32_t); void (*IT_rx)(USART_TypeDef* USARTx,FunctionalState); void (*IT_tx)(USART_TypeDef* USARTx,FunctionalState); void (*send)(USART_TypeDef* USARTx,uint16_t ); uint16_t (*recv)(USART_TypeDef* USARTx); FlagStatus (*getflag)(USART_TypeDef* USARTx,u16 USART_FLAG); }USART_class; static struct USART_class usart ={ .init = usart_init, .IT_rx = usart_rx_interrupt, .IT_tx = usart_tx_interrupt, .send=J_USART_SendData, .recv=J_USART_ReceiveData, .getflag = USART_GetFlagStatus, }; #endif #include "usart.h" void usart1_init(uint32_t baud){ USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; //GPIO_PinRemapConfig(GPIO_Remap_USART1 ,DISABLE); USART_DeInit(USART1); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = baud; // baudrate USART_InitStructure.USART_WordLength = USART_WordLength_8b; // data length 8bit USART_InitStructure.USART_StopBits = USART_StopBits_1; // stopbit 1 USART_InitStructure.USART_Parity = USART_Parity_No; // no parity USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // Flow control no USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // tx,rx enable USART_Init(USART1, &USART_InitStructure); USART_Cmd(USART1, ENABLE); } void usart1_rx_interrupt(FunctionalState state){ NVIC_InitTypeDef NVIC_InitStructure; USART_ITConfig(USART1, USART_IT_RXNE, state); if(state == ENABLE){ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } } void usart1_tx_interrupt(FunctionalState state){ NVIC_InitTypeDef NVIC_InitStructure; USART_ITConfig(USART1, USART_IT_TXE, state); if(state == ENABLE){ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } } void usart1_send(uint16_t data){ USART_SendData(USART1,data); while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET); } uint16_t usart1_receive(void){ return USART_ReceiveData(USART1); } void usart2_init(uint32_t baud){ USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; USART_DeInit(USART2); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = baud; // baudrate USART_InitStructure.USART_WordLength = USART_WordLength_8b; // data length 8bit USART_InitStructure.USART_StopBits = USART_StopBits_1; // stopbit 1 USART_InitStructure.USART_Parity = USART_Parity_No; // no parity USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // Flow control no USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // tx,rx enable USART_Init(USART2, &USART_InitStructure); USART_Cmd(USART2, ENABLE); } void usart3_init(uint32_t baud){ USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; USART_DeInit(USART3); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = baud; // baudrate USART_InitStructure.USART_WordLength = USART_WordLength_8b; // data length 8bit USART_InitStructure.USART_StopBits = USART_StopBits_1; // stopbit 1 USART_InitStructure.USART_Parity = USART_Parity_No; // no parity USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // Flow control no USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // tx,rx enable USART_Init(USART2, &USART_InitStructure); USART_Cmd(USART2, ENABLE); } void usart2_rx_interrupt(FunctionalState state){ NVIC_InitTypeDef NVIC_InitStructure; USART_ITConfig(USART2, USART_IT_RXNE, state); if(state==ENABLE){ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } } void usart2_tx_interrupt(FunctionalState state){ NVIC_InitTypeDef NVIC_InitStructure; USART_ITConfig(USART2, USART_IT_TXE, state); if(state==ENABLE){ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //TIM3_IRQn NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } } void usart_rx_interrupt(USART_TypeDef* USARTx,FunctionalState state){ if(USARTx == USART1)usart1_rx_interrupt(state); if(USARTx == USART2)usart2_rx_interrupt(state); } void usart_tx_interrupt(USART_TypeDef* USARTx,FunctionalState state){ if(USARTx == USART1)usart1_tx_interrupt(state); if(USARTx == USART2)usart2_tx_interrupt(state); } void usart_init(USART_TypeDef* USARTx,uint32_t baudrate){ if(USARTx == USART1)usart1_init(baudrate); if(USARTx == USART2)usart2_init(baudrate); if(USARTx == USART3)usart3_init(baudrate); } void J_USART_SendData(USART_TypeDef* USARTx,uint16_t data){ while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET); USART_SendData(USARTx,data); } uint16_t J_USART_ReceiveData(USART_TypeDef* USARTx){ while(USART_GetFlagStatus(USARTx, USART_FLAG_RXNE) == RESET); return USART_ReceiveData(USARTx); } //------------하드웨어 장비등을 선언한 구문------------// #include "stm32f10x.h" #include #include "queue.h" #include #include "stm32f10x_it.h" #include "usart.h" #include "config.h" #include "step.h" #include "ax_12.h" #include "exynos_link.h" #include "led.h" #include "ax_control.h" #define ADC1_DR_Address ((u32)0x4001244c) //****************************************** #define M1_1 SET(GPIOx,GPIO_Pin_x) #define M1_0 CLR(GPIOx,GPIO_Pin_x) #define M2_1 SET(GPIOx,GPIO_Pin_x) #define M2_0 CLR(GPIOx,GPIO_Pin_x) #define FALSE 0 #define TRUE 1 extern u32 adc_val[2]; extern u32 adc_temp[4]; extern u32 adc_max[4]; extern volatile u16 CCR1_val; extern volatile u16 CCR2_val; //******************************************* //base 함수; //usart 1 초기화 함수 void TIM3_SET(u32 peri_a); //0~10000 void TIM4_SET(u32 peri_b);//0~10000 //ADC ONE TWO 파트 셋팅 함수. void ADC_ONE_init(void); void TIM_init(void); void TIM2_SET(u16 arg); //KEY제어 함수 void SETTING(void); void TIM_conti(void); #include"hwconfig.h" u32 adc_val[2]; u32 adc_temp[4]; u32 adc_max[4]; u32 adc_cnt; void ADC_ONE_init(void){//sensor 9input RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE); GPIO_InitTypeDef gpios; gpios.GPIO_Mode=GPIO_Mode_AIN; gpios.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3; GPIO_Init(GPIOC,&gpios); NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); //printf("gpio complete\n"); //DMA config DMA_InitTypeDef dma; DMA_DeInit(DMA1_Channel1); dma.DMA_PeripheralBaseAddr = (u32)ADC1_DR_Address; dma.DMA_MemoryBaseAddr = (u32)adc_val; dma.DMA_DIR = DMA_DIR_PeripheralSRC; dma.DMA_BufferSize = 2; dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable; dma.DMA_MemoryInc = DMA_MemoryInc_Enable; dma.DMA_PeripheralDataSize =DMA_PeripheralDataSize_Word; dma.DMA_MemoryDataSize = DMA_MemoryDataSize_Word; dma.DMA_Mode = DMA_Mode_Circular; dma.DMA_Priority = DMA_Priority_High; dma.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel1,&dma); DMA_ITConfig(DMA1_Channel1,DMA1_IT_TC1,ENABLE); DMA_Cmd(DMA1_Channel1,ENABLE); ADC_InitTypeDef adc; adc.ADC_Mode = ADC_Mode_RegSimult; adc.ADC_ScanConvMode = ENABLE; adc.ADC_ContinuousConvMode = ENABLE; adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; adc.ADC_DataAlign = ADC_DataAlign_Right; adc.ADC_NbrOfChannel = 2; ADC_Init(ADC1, &adc); ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_239Cycles5); ADC_RegularChannelConfig(ADC1, ADC_Channel_11, 2, ADC_SampleTime_239Cycles5); ADC_DMACmd(ADC1, ENABLE); //printf("adc1 complete\n"); /* ADC2 configuration */ adc.ADC_Mode = ADC_Mode_RegSimult; adc.ADC_ScanConvMode = ENABLE; adc.ADC_ContinuousConvMode = ENABLE; adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; adc.ADC_DataAlign = ADC_DataAlign_Right; adc.ADC_NbrOfChannel = 2; ADC_Init(ADC2, &adc); /* ADC2 regular channels configuration */ ADC_RegularChannelConfig(ADC2, ADC_Channel_12, 1, ADC_SampleTime_239Cycles5); ADC_RegularChannelConfig(ADC2, ADC_Channel_13, 2, ADC_SampleTime_239Cycles5); ADC_ExternalTrigConvCmd(ADC2, ENABLE); ADC_Cmd(ADC1, ENABLE); // ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE); ADC_ResetCalibration(ADC1); while(ADC_GetResetCalibrationStatus(ADC1)); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1)); ADC_Cmd(ADC2, ENABLE); ADC_ResetCalibration(ADC2); while(ADC_GetResetCalibrationStatus(ADC2)); ADC_StartCalibration(ADC2); while(ADC_GetCalibrationStatus(ADC2)); ADC_SoftwareStartConvCmd(ADC1, ENABLE); while(!DMA_GetFlagStatus(DMA1_FLAG_TC1)); DMA_ClearFlag(DMA1_FLAG_TC1); } void TIM_init(void){ RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 , ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO , ENABLE); GPIO_InitTypeDef gpio; gpio.GPIO_Mode = GPIO_Mode_AF_PP; gpio.GPIO_Pin = GPIO_Pin_0; gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA,&gpio); TIM_TimeBaseInitTypeDef t_base; TIM_OCInitTypeDef t_oc; t_base.TIM_Period = 99; t_base.TIM_Prescaler = 71; t_base.TIM_ClockDivision = 0; t_base.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &t_base); t_oc.TIM_OCMode = TIM_OCMode_PWM1; t_oc.TIM_OutputState = TIM_OutputState_Enable; t_oc.TIM_Pulse = 30; t_oc.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM2, &t_oc); TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable); TIM_ARRPreloadConfig(TIM2, ENABLE); TIM_Cmd(TIM2, ENABLE); } void TIM2_SET(u16 arg){ TIM_OCInitTypeDef t_oc; t_oc.TIM_OCMode = TIM_OCMode_PWM1; t_oc.TIM_OutputState = TIM_OutputState_Enable; t_oc.TIM_Pulse = arg; t_oc.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM2, &t_oc); TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable); TIM_ARRPreloadConfig(TIM2, ENABLE); TIM_Cmd(TIM2, ENABLE); } void TIM3_SET(u32 peri_a){ TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_TimeBaseStructure.TIM_Period = peri_a; TIM_TimeBaseStructure.TIM_Prescaler = 7200; TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0x0000; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); // TIM_Cmd(TIM3, ENABLE); // TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE); } void TIM4_SET( u32 peri_b){ TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_TimeBaseStructure.TIM_Period = peri_b; TIM_TimeBaseStructure.TIM_Prescaler = 7200; TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0x0000; TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); // TIM_Cmd(TIM4, ENABLE); //TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE); } volatile u16 CCR1_val = 60000; volatile u16 CCR2_val = 60000; void TIM_conti(void){ RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3 , ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE); GPIO_InitTypeDef g; g.GPIO_Mode = GPIO_Mode_Out_PP; g.GPIO_Speed = GPIO_Speed_50MHz; g.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8; GPIO_Init(GPIOC,&g); NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_TimeBaseStructure.TIM_Period = 65535; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // TIM_TimeBaseStructure.TIM_RepetitionCounter = 0x0000; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); TIM_PrescalerConfig(TIM3,4,TIM_PSCReloadMode_Immediate); TIM_OCInitTypeDef t_oc; t_oc.TIM_OCMode = TIM_OCMode_Timing; t_oc.TIM_OutputState = TIM_OutputState_Enable; t_oc.TIM_Pulse = CCR1_val; t_oc.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM3, &t_oc); TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable); t_oc.TIM_Pulse = CCR2_val; TIM_OC2Init(TIM3, &t_oc); TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Disable); TIM_ITConfig(TIM3, TIM_IT_CC1|TIM_IT_CC2, ENABLE); TIM_Cmd(TIM3, ENABLE); /* NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4 , ENABLE); TIM_TimeBaseStructure.TIM_Period = 59; TIM_TimeBaseStructure.TIM_Prescaler = 60000; TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0x0000; TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); TIM_Cmd(TIM4, ENABLE); TIM_ClearFlag(TIM4, TIM_FLAG_Update); TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);[ */ } //------------인터럽트 선언 제어 코드------------// /** ****************************************************************************** * @file SysTick/stm32f10x_it.c * @author MCD Application Team * @version V3.1.0 * @date 06/19/2009 * @brief Main Interrupt Service Routines. * This file provides template for all exceptions handler and peripherals * interrupt service routine. ****************************************************************************** * @copy * * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. * *

© COPYRIGHT 2009 STMicroelectronics

*/ /* Includes ------------------------------------------------------------------*/ #include "stm32f10x_it.h" #include "hwconfig.h" #include "led.h" #include "exynos_link.h" /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ /* Private functions ---------------------------------------------------------*/ /******************************************************************************/ /* Cortex-M3 Processor Exceptions Handlers */ /******************************************************************************/ /** * @brief This function handles NMI exception. * @param None * @retval None */ void NMI_Handler(void) { } /** * @brief This function handles Hard Fault exception. * @param None * @retval None */ void HardFault_Handler(void) { /* Go to infinite loop when Hard Fault exception occurs */ while (1) { } } /** * @brief This function handles Memory Manage exception. * @param None * @retval None */ void MemManage_Handler(void) { /* Go to infinite loop when Memory Manage exception occurs */ while (1) { } } /** * @brief This function handles Bus Fault exception. * @param None * @retval None */ void BusFault_Handler(void) { /* Go to infinite loop when Bus Fault exception occurs */ while (1) { } } /** * @brief This function handles Usage Fault exception. * @param None * @retval None */ void UsageFault_Handler(void) { /* Go to infinite loop when Usage Fault exception occurs */ while (1) { } } /** * @brief This function handles SVCall exception. * @param None * @retval None */ void SVC_Handler(void) { } /** * @brief This function handles Debug Monitor exception. * @param None * @retval None */ void DebugMon_Handler(void) { } /** * @brief This function handles PendSV_Handler exception. * @param None * @retval None */ void PendSV_Handler(void) { } /** * @brief This function handles SysTick Handler. * @param None * @retval None */ void SysTick_Handler(void) { TimingDelay_Decrement(); } /******************************************************************************/ /* STM32F10x Peripherals Interrupt Handlers */ /* Add here the Interrupt Handler for the used peripheral(s) (PPP), for the */ /* available peripheral interrupt handler's name please refer to the startup */ /* file (startup_stm32f10x_xx.s). */ /******************************************************************************/ /******************************************************************************* * Function Name : WWDG_IRQHandler * Description : This function handles WWDG interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void WWDG_IRQHandler(void) { } /******************************************************************************* * Function Name : PVD_IRQHandler * Description : This function handles PVD interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void PVD_IRQHandler(void) { } /******************************************************************************* * Function Name : TAMPER_IRQHandler * Description : This function handles Tamper interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TAMPER_IRQHandler(void) { } /******************************************************************************* * Function Name : RTC_IRQHandler * Description : This function handles RTC global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void RTC_IRQHandler(void) { } /******************************************************************************* * Function Name : FLASH_IRQHandler * Description : This function handles Flash interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void FLASH_IRQHandler(void) { } /******************************************************************************* * Function Name : RCC_IRQHandler * Description : This function handles RCC interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void RCC_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI0_IRQHandler * Description : This function handles External interrupt Line 0 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI0_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI1_IRQHandler * Description : This function handles External interrupt Line 1 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI1_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI2_IRQHandler * Description : This function handles External interrupt Line 2 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI2_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI3_IRQHandler * Description : This function handles External interrupt Line 3 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI3_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI4_IRQHandler * Description : This function handles External interrupt Line 4 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI4_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel1_IRQHandler * Description : This function handles DMA1 Channel 1 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ extern u32 adc_val[2]; extern u32 adc_temp[4]; extern u32 adc_max[4]; extern u32 adc_cnt; void DMA1_Channel1_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_TC1)==1){ DMA_ClearITPendingBit(DMA1_IT_TC1); adc_cnt++; if(adc_temp[0]<(u16)adc_val[0]) adc_temp[0]=(u16)adc_val[0]; if(adc_temp[1]<(adc_val[0]>>16)) adc_temp[1]=(adc_val[0]>>16); if(adc_temp[2]<(u16)adc_val[1]) adc_temp[2]=(u16)adc_val[1]; if(adc_temp[3]<(adc_val[1]>>16)) adc_temp[3]=(adc_val[1]>>16); if(adc_cnt>32){ u32 *adc=adc_max; u32 *adt=adc_temp; adc_cnt=0; *(adc++)=*(adt++); *(adc++)=*(adt++); *(adc++)=*(adt++); *(adc)=*(adt); adt=adc_temp; *(adt++)=0; *(adt++)=0; *(adt++)=0; *(adt++)=0; } /* adc_cnt++; if(adc_temp[0]<(u16)adc_val[0]) adc_temp[0]=(u16)adc_val[0]; if(adc_temp[1]<(adc_val[0]>>16)) adc_temp[1]=(adc_val[0]>>16); if(adc_temp[2]<(u16)adc_val[1]) adc_temp[2]=(u16)adc_val[1]; if(adc_temp[3]<(adc_val[1]>>16)) adc_temp[3]=(adc_val[1]>>16); if(adc_cnt>32){ adc_cnt=0; adc_max[0]=adc_temp[0]; adc_max[1]=adc_temp[1]; adc_max[2]=adc_temp[2]; adc_max[3]=adc_temp[3]; adc_temp[0]=0; adc_temp[1]=0; adc_temp[2]=0; adc_temp[3]=0; } */ } } /******************************************************************************* * Function Name : DMA1_Channel2_IRQHandler * Description : This function handles DMA1 Channel 2 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel2_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel3_IRQHandler * Description : This function handles DMA1 Channel 3 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel3_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel4_IRQHandler * Description : This function handles DMA1 Channel 4 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel4_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel5_IRQHandler * Description : This function handles DMA1 Channel 5 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel5_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel6_IRQHandler * Description : This function handles DMA1 Channel 6 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel6_IRQHandler(void) { } /******************************************************************************* * Function Name : DMA1_Channel7_IRQHandler * Description : This function handles DMA1 Channel 7 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel7_IRQHandler(void) { } /******************************************************************************* * Function Name : ADC1_2_IRQHandler * Description : This function handles ADC1 and ADC2 global interrupts requests. * Input : None * Output : None * Return : None *******************************************************************************/ void ADC1_2_IRQHandler(void) { } /******************************************************************************* * Function Name : USB_HP_CAN_TX_IRQHandler * Description : This function handles USB High Priority or CAN TX interrupts * requests. * Input : None * Output : None * Return : None *******************************************************************************/ void USB_HP_CAN1_TX_IRQHandler(void) { } /******************************************************************************* * Function Name : USB_LP_CAN_RX0_IRQHandler * Description : This function handles USB Low Priority or CAN RX0 interrupts * requests. * Input : None * Output : None * Return : None *******************************************************************************/ void USB_LP_CAN1_RX0_IRQHandler(void) { } /******************************************************************************* * Function Name : CAN_RX1_IRQHandler * Description : This function handles CAN RX1 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void CAN1_RX1_IRQHandler(void) { } /******************************************************************************* * Function Name : CAN_SCE_IRQHandler * Description : This function handles CAN SCE interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void CAN1_SCE_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI9_5_IRQHandler * Description : This function handles External lines 9 to 5 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI9_5_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM1_BRK_IRQHandler * Description : This function handles TIM1 Break interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM1_BRK_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM1_UP_IRQHandler * Description : This function handles TIM1 overflow and update interrupt * request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM1_UP_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM1_TRG_COM_IRQHandler * Description : This function handles TIM1 Trigger and commutation interrupts * requests. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM1_TRG_COM_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM1_CC_IRQHandler * Description : This function handles TIM1 capture compare interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM1_CC_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM2_IRQHandler * Description : This function handles TIM2 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM2_IRQHandler(void) { } /******************************************************************************* * Function Name : TIM3_IRQHandler * Description : This function handles TIM3 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ u32 capture = 0; extern volatile u16 CCR1_val ; extern volatile u16 CCR2_val ; void TIM3_IRQHandler(void) { if(TIM_GetITStatus(TIM3,TIM_IT_CC1)!=RESET){ TIM_ClearITPendingBit(TIM3, TIM_IT_CC1); GPIO_WriteBit(GPIOC, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_7))); capture = TIM_GetCapture1(TIM3); TIM_SetCompare1(TIM3,capture + CCR1_val); // printf("b"); }else if(TIM_GetITStatus(TIM3,TIM_IT_CC2)!=RESET){ TIM_ClearITPendingBit(TIM3, TIM_IT_CC2); GPIO_WriteBit(GPIOC, GPIO_Pin_8, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_8))); capture = TIM_GetCapture2(TIM3); TIM_SetCompare2(TIM3,capture + CCR2_val); //printf("c"); } /* TIM_ClearITPendingBit(TIM3, TIM_IT_Update); // printf("<"); // printf("step_a val = %d \n",step_a_val); RESET(step_a[step_a_val]); step_a_val++; if(step_a_val>=4)step_a_val =0; SET(step_a[step_a_val]); LED0_TOG();*/ } /******************************************************************************* * Function Name : TIM4_IRQHandler * Description : This function handles TIM4 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM4_IRQHandler(void) { } /******************************************************************************* * Function Name : I2C1_EV_IRQHandler * Description : This function handles I2C1 Event interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void I2C1_EV_IRQHandler(void) { } /******************************************************************************* * Function Name : I2C1_ER_IRQHandler * Description : This function handles I2C1 Error interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void I2C1_ER_IRQHandler(void) { } /******************************************************************************* * Function Name : I2C2_EV_IRQHandler * Description : This function handles I2C2 Event interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void I2C2_EV_IRQHandler(void) { } /******************************************************************************* * Function Name : I2C2_ER_IRQHandler * Description : This function handles I2C2 Error interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void I2C2_ER_IRQHandler(void) { } /******************************************************************************* * Function Name : SPI1_IRQHandler * Description : This function handles SPI1 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void SPI1_IRQHandler(void) { } /******************************************************************************* * Function Name : SPI2_IRQHandler * Description : This function handles SPI2 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void SPI2_IRQHandler(void) { } /******************************************************************************* * Function Name : USART1_IRQHandler * Description : This function handles USART1 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART1_IRQHandler(void) { overwrite_IT(); /* u8 c; if(USART_GetITStatus(USART1,USART_IT_RXNE)==1){ USART_ClearITPendingBit(USART1,USART_IT_RXNE); c=USART_ReceiveData(USART1); if(c=='`'){ NVIC_SystemReset(); } queue.en(&Abuffer,c); } */ } /******************************************************************************* * Function Name : USART2_IRQHandler * Description : This function handles USART2 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART2_IRQHandler(void) { //overwrite_IT(); /* u8 c; if(USART_GetITStatus(USART2,USART_IT_RXNE)==1){ USART_ClearITPendingBit(USART2,USART_IT_RXNE); c=USART_ReceiveData(USART2); if(c=='`'){ NVIC_SystemReset(); } queue.en(&Abuffer,c); } */ } /******************************************************************************* * Function Name : USART3_IRQHandler * Description : This function handles USART3 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART3_IRQHandler(void) { } /******************************************************************************* * Function Name : EXTI15_10_IRQHandler * Description : This function handles External lines 15 to 10 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI15_10_IRQHandler(void) { } /******************************************************************************* * Function Name : RTCAlarm_IRQHandler * Description : This function handles RTC Alarm interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void RTCAlarm_IRQHandler(void) { } /******************************************************************************* * Function Name : USBWakeUp_IRQHandler * Description : This function handles USB WakeUp interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USBWakeUp_IRQHandler(void) { } /******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/ //------------메인 함수------------// #include "hwconfig.h" extern u32 adc_max[4]; void SETTING(void){ rcc_init(); delay.systick_init(); delay.ms(1); //usart.init(USART1,115200); //usart.IT_rx(USART1,ENABLE); usart.init(USART2,1000000); //LED.init(); exy_Init(); GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOC, &GPIO_InitStructure); GPIO_InitTypeDef gpios; GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE); gpios.GPIO_Mode=GPIO_Mode_Out_PP; gpios.GPIO_Pin=GPIO_Pin_3|GPIO_Pin_4; gpios.GPIO_Speed=GPIO_Speed_50MHz; GPIO_Init(GPIOB,&gpios); System_Information(); // ADC_ONE_init(); // TIM_init(); // TIM2_SET(); // TIM_conti(); } extern pos ptr,ptl; extern uint32_t r_end_pos,l_end_pos; pos ptr,ptl; int main(void) { SETTING(); ptr.x=100,ptr.y=100,ptr.z=100; ptl.x=100,ptl.y=100,ptl.z=100; LED.led0(OFF); LED.led1(ON); printf("start exy check\n"); while(1){ exy_check(); LED.led0(TOG); LED.led1(TOG); //delay.s(1); } /* char aa; result tar_th; result tar_th2; while (1){ printf("input x y z : "); scanf("%f %f %f", &ptr.x, &ptr.y, &ptr.z); printf("output %f %f %f \n ", ptr.x, ptr.y, ptr.z); xy_vect(&ptr, &tar_th2); AX_vect(&tar_th2, Left); AX_vect(&tar_th2, Right); printf("angle %f %f %f \n ", tar_th2.t0, tar_th2.t1, tar_th2.t2); } */ /* while(1){ // printf("a"); delay.ms(100); scanf("%c",&c); switch(c){ case 'a': // x_dir(1); // x_ena(1); break; case 's': // x_dir(0); // x_ena(0); break; case 'd': CCR1_val+=100; printf("ccr1 = %d \n",CCR1_val); break; case 'f': CCR1_val-=100; printf("ccr1 = %d \n",CCR1_val); break; case 'q': break; case 'w': break; case 'e': break; case 'r': break; } // printf("input = %d \n",d); // scanf("%d",&d2); // printf("\n"); // CCR2_val=d2; // printf("max = %d %d %d %d \r",adc_max[0],adc_max[1],adc_max[2],adc_max[3]); //printf("a"); // Delay_ms(100); }*/ }