Red de conocimiento informático - Conocimiento sistemático - Buscamos un experto para escribir el programa de automóvil inteligente Freescale (puede sumar mil puntos)

Buscamos un experto para escribir el programa de automóvil inteligente Freescale (puede sumar mil puntos)

De hecho, sólo el programa es inútil. El programa y el hardware deben combinarse. Por ejemplo, utilizar PT0 en el hardware y PT1 en el programa ciertamente no logrará el propósito esperado. El siguiente es un programa de la Universidad Jiao Tong de Shanghai.

Main.c

#include lt; hidef.hgt /* definiciones y macros comunes */

#include mc9s12db128.hgt; información derivada */

#pragma LINK_INFO DERIVATIVE "mc9s12db128b"

#include "define.h"

#include "init.h"

// variable utilizada en el proceso de vídeo

volatile unsigned char image_data[ROW_MAX][LINE_MAX]; // matriz de datos de la imagen

unsigned char black_x[ROW_MAX]; Matriz unidimensional

fila de caracteres unsigned; // posición x de la matriz

línea de caracteres unsigned // posición y de la matriz

unsigned; int row_count; // contador de filas

unsigned char line_sample; // usado para contrarrestar en AD

unsigned char row_image

unsigned char line_temp; variable utilizada en la transferencia de datos

unsigned char sample_data[LINE_MAX] ; // utilizada para guardar la matriz unidimensional obtenida en

interrupción

// las variables a continuación son usado en medida de velocidad

Pulso de caracteres sin firmar[5] // usado para guardar datos en el proceso PA

Contador de caracteres sin firmar // contador temporal en detección de velocidad

Unsigned char cur_speed; // velocidad actual

stand corto;

datos cortos;

curva de char unsigned // válvula usada para decidir directamente; o gire

Short Bounds(datos cortos);

Short FuzzyLogic(stand corto);

/*----------- -------------------------------------------------- --------------*\

receive_sci

\*---------------- -- --------

-------------------------------------------------- */

unsigned char recibir_sci(void) // recibir datos a través de sci

{ unsigned char sci_data;

while(SCI0SR1_RDRF!=1);

p>

sci_data=SCI0DRL;

devolver sci_data;

}

/*--------- ----- --------------------------------------------- ----- -*\

transmit_sci

\*---------------- -------------------------------------------------- -- -------*/

void transmit_sci(unsigned char transmit_data) // envía datos a través de sci

{

while(SCI0SR1_TC! =1 );

mientras(SCI0SR1_TDRE!=1);

SCI0DRL=transmitir_datos;

}

/**** ** ************************************************* *** **********************

***/

/*------ --- ----------------------------------------------- --- ------------------*\

abs_sub

\*---------- ---- ---------------------------------------------- ---- ------------*/

carácter sin firmar abs_sub(carácter sin firmar num1, carbón sin firmar num2)

{ diferencia de caracteres sin firmar;

if(num1gt;=num2){

difference=num1-num2;

}else{

difference=num2-num1;

}

diferencia de devolución;

}

void pwm_set(unsigned int dutycycle)

{

PWMDTY1=dutycycleamp;0x00FF;

PWMDTY0=dutycyclegt;gt;8;

}

void get_black_wire(void) // solía extraiga el cable negro

{ unsigned char i;

for(row=0; rowlt; ROW_MAX; row){

for(line=LINE

_MIN; linelt; LINE_MAX-3; línea ){

if(image_data[fila][línea]gt; image_data[fila][línea 3] VÁLVULA){

para(i =3;ilt;10;i){

if(image_data[fila][línea i] VALVElt;image_data[fila][línea i 3]){

black_x[fila ]=línea i/2 2;

i=10;

}

}

línea=LINE_MAX;

} más{

//black_x[row]=(black_x[row]/45)*78;

}

}

}

}

/*---------------------- -------------------------------*\

control_velocidad

\*--------------------------------- -------- ---------------------------------*/

void speed_control(void)

{

suma int sin signo, promedio

suma=0

for(fila= 0; ; rowlt; FIRST_FIVE; fila ){

suma=suma black_x[fila];

}

average=sum/FIRST_FIVE;

curva=0;

for(row=0;rowlt;FIRST_FIVE;fila)

{

curva=curva abs_sub(black_x[fila], promedio );

if(curvegt;CURVE_MAX){

curve_flag=0;

velocidad=low_speed;}

else{< / p>

bandera_curva=1;

velocidad=alta_velocidad;

}

}

}

/*----------------------------------------------- ----------------------------------*\

control_de_dirección

\*- -------------------------------------------- ------ -----------------------*/

void steer_control(void)

{ unsigned int dutycycle ;

unsigned char video_center;

coeficiente unsigned int;

int E, U //actual

estático int e=0 ;

video_center

=(LINE_MIN LINE_MAX)/2;

stand=abs_sub(negro_x[1] negro_x[9], 2*negro_x[5]);

E=video_center-black_x[8 ];

coeficiente=30 1*FuzzyLogic(stand);

U=coeficiente*E;

dutycycle=Bounds(centro U);

pwm_set(dutycycle);

}

// asegúrate de que esté dentro de los límites

short Bounds(short data){

if(datagt;right_limit){

datos = right_limit;

}

if(datalt;left_limit){

datos = límite_izquierdo;

}

devolver datos;

}

Vid speed_get(void)

{

Temperatura de caracteres sin firmar;

Contador;

Temp=PACN1;

cur_speed=temp-pulse[counter-1];

pulso[counter-1]=temp;

if(counter==5)

{

counter=0;

if(contador==5)

{

contador=0;

p>

}

}

Vid set_speed(caracter sin firmar velocidad_deseado)

{

If(desired_speedlt;cur_speed)

{

PWMDTY2=baja_velocidad;

}

De lo contrario

{

PWMDTY2 =alta_velocidad;

}

}

/****************************** ******* ******************************************** ****

*\

Principal

\************************ *** ********************************************** ** ****

*/

void main(void) {

// función principal

init_PORT()

// inicialización del puerto

init_PLL();

// configuración del PLL

init_ECT();

init_PWM();

// INICIALIZACIÓN PWM

init_SPEED();

init_SCI();

for(; ;) {

if(field_signal==0){ // par-gt<

/p>

mientras(field_signal==0);

row_count=0;

row_image=0;

Habilitar interrupciones;

while(row_countlt;ROW_END){

get_black_wire();

speed_control();

steer_control();

}

DisableInterrupts;

}

else{ // impar-gt; par

mientras(field_signal==1);

p>

row_count=0;

row_image=0;

Habilitar interrupciones;

while(row_countlt;ROW_END){

get_black_wire();

speed_control();

steer_control();

}

Desactivar interrupciones;

}

/* transmit_sci('x');

for(row=0; rowlt; ROW_MAX; fila){

transmit_sci (black_x[fila] );

}

transmitir_sci(curva);

*/

}

}

interrumpir 6 void IRQ_ISR()

{

row_count;

if((row_countgt;ROW_START)amp;amp; (row_countINTERVAL==0 )amp;amp;(row_imagelt;ROW_MAX))

{

init_AD();

for(line_sample=0;line_samplelt; LINE_MAX;line_sample ){

while(!ATD0STAT1_CCF0); // ESPERA A QUE FINALICE LA TRANSFORMACIÓN

sample_data[line_sample]=signal_in; // transferencia A/D

}

ATD0CTL2=0x00;

row_image;

}

if((row_countgt;ROW_START)amp;amp;( row_countINTERVAL==2) amp;amp;(row_imagelt;ROW_MAX

1)){

for(line_temp=0;line_templt;LINE_MAX;line_temp){

image_data[row_image- 1][line_temp]=sample_data[line_temp];

}

}

}

/// ///// ////////////////////////////////////////////// ///////// /////////////

////////////////////////////////////////////////// //// ///////////////////

// EL FINAL

//

//// //////////////////////////////////////////////// //////// /////////////////////////////////////////// //////////// //////////////////////////////////////

Define.h // todas las macros están definidas en este archivo de encabezado

/*---------------------- ----------------------- --------------------------- -------------*\

La macro debe usarse en la muestra de video

\*----------- ----------------------- --------------------------- ---------------*/

/////////////////////////// /////

#define signal_in ATD0DR0L // señal de video: modo alineado a la derecha,

// solo usa 8 bits bajos en el resultado de conversión ATD

Registros

#define field_signal PTT_PTT2 // la señal de campo se envía a PortT_bit2

#define LINE_MIN 12 // primera pinta efectiva en cada fila

#define LINE_MAX 78 // número de puntos muestreados en cada fila

#define ROW_MAX 10 // número de filas necesarias para muestrear en cada

imagen

#define ROW_START 50 // comenzar a muestrear desde el inicio de la línea

#define ROW_END 300 // finalizar el indicador de muestreo

#define INTERVAL 20 // intervalo entre filas efectivas

#define VALVE 24 // válvula para decidir pista negra o pista blanca

#define FIRST_FIVE 5

/*--------------- -------------------------- ------------------------ -*\

Variables de servocontrol

\*------------------- ---------------

---------------------------------*/

#define límite_izquierdo 7400 //

#define centro 6400 //

#define límite_derecho 5400 //

//#define coeficiente 30 // (IZQUIERDA -DERECHA)/(LINE_MAX-LINE_MIN)

/*-------------------------------- -------------------------------------------------- *\

Variable de control de velocidad

\*--------------------------- ------- ------------------------------------------- -------*/

#define curve_flag PORTE_BIT2 // indica línea recta o no

#define speed PWMDTY2 // velocidad del auto

#define CURVE_MAX 24 // válvula para decidir vía recta o no

p>

#define high_speed 120 // velocidad utilizada en vía recta

#define low_speed 100 // velocidad utilizada en el turno

/*------- -------------------------------- ------------------ ------------------*\

definir código de salto; interruptor; Led

\*----- --------------------------------- ----------------- ---------------------*/

#definir JP4_1 PTT_PTT7 // JP4

#definir JP4_2 PTT_PTT6

#definir JP4_3 PTT_PTT5

#definir JP4_4 PTT_PTT4

#definir JP4_5 PTP_PTP4

#define JP4_6 PTP_PTP5

# define JP4_7 PTP_PTP6

// define el interruptor de código

#define RP1_1 PTM_PTM0

#definir RP1_2 PTM_PTM1

#definir RP1_3 PTM_PTM2

#definir RP1_4 PTM_PTM3

#definir RP1_5 PTM_PTM4

#definir RP1_6 PTM_PTM5

#definir RP1_7 PORTAD0_PTAD4

#definir RP1_8 PORTAD0_PTAD3

// d

definir Led

#definir Led1 PORTA_BIT4

#definir Led2 PORTA_BIT5

#definir Led3 PORTA_BIT6

#definir Led4 PORTA_BIT7

Init.c // incluye función inicial en este archivo

#include lt; hidef.hgt /* definiciones y macros comunes */

#include lt; hgt; /* información derivada */

#include "define.h" /* todas las macros incluidas */

#include "init.h" /* todas las funciones de inicio incluidas * /

#pragma LINK_INFO DERIVADA "mc9s12db128b"

/*-------------------- -------------------------------------------------- *\

init_PLL

\*------------------------------- --- ----------------------------------------------- -*/

void init_PLL(void)

// configuración del PLL

{

REFDV=3;

SYNR= 7; // periodo de bus=16Mhz*(SYNR 1)/(REFDV 1)

while(0==CRGFLG_LOCK // espera a que VCO se estabilice

CLKSEL=0x80 ;

// abrir PLL

}

Void init_ECT(void);

{

TIOS_IOS3= 0; // establece PT3 como captura de entrada

TCTL4=0b11000000; // establece pt3 como cualquier borde activado

ICPAR_PA1EN=1; habilitado

}

/*-------------------------------- -------- ----------------------------------*\

init_PORT

\*--------------------------------- --------- ----------------------------------*/

void init_PORT(void) // inicialización del puerto

{

DDRT_DDRT2=0;

// El puerto M1 funciona como señal de campo par-impar

entrada

t

DDRJ_DDRJ6=1;

// Puerto J6 habilitado 33886 0 habilitado

// Puerto LED

DDRA_BIT4 =1;

DDRA_BIT5 =1;

DDRA_BIT6 =1;

DDRA_BIT7 =1;

INTCR_IRQE =1 // Seleccionar IRQ solo sensible al borde;

INTCR_IRQEN=1; // Habilitación de IRQ externa

//Instrucción de salida JP4_1 PTT_PTT0

DDRT_DDRT7=1;

DDRT_DDRT6=1 ;

DDRT_DDRT5=1;

DDRT_DDRT4=1;

DDRP_DDRP4=1; //PTP_PTP0

DDRP_DDRP5=1;

p>

DDRP_DDRP7=1;

}

/*------------------- -------------------------------------------------- -- --*\

init_AD

\*--------------------- -------------------------------------------------- --*/

void init_AD(void)

// inicializar AD

{

ATD0CTL2=0xC0;

// abrir AD, borrado rápido, sin modo de espera, inhibir el despertar externo, inhibir la interrupción

ATD0CTL3=0x08;

// una transformación en una secuencia, sin FIFO, continuar transformando en modo congelado

ATD0CTL4=0x81;

// Precisión de 8 bits, dos relojes, ATDClock=[BusClock*0.5]/[PRS 1]; , divider=4;

BusClock=8MHZ

ATD0CTL5=0xA0; // alineado a la derecha, sin signo, canal único,

canal 0

ATD0DIEN=0x00 ; // inhibir entrada digital

}

/*---------------------- ---- ---------------------------------------------- ----* \

init_PWM

\*--------------------- ----- --------------------------------------------- -----*/

void init_PWM(void)

// inicio de PWM

alize

{

PTJ_PTJ6 = 0; // "0" habilita el motor 33886, "1" lo deshabilita

PWME = 0x00 // PWW está deshabilitado;

PWMCTL_CON01 = 1; // combinar PWM0, 1

PWMPRCLK = 0x33; // A=B=32M/8=4M

PWMSCLA = 100; // SA=A/2/100=20k

PWMSCLB = 1; // SB=B/2/1 =2000k

PWMCLK = 0b00011100 // PWM0, 1- A; PWM2, 3-SB; PWM4-SA

PWMPOL = 0xff; // Servicio=Tiempo alto

PWMCAE = 0x00; >PWMPER0 = 0x4e;

PWMPER1 = 0x20;

// 20000 = 0x4e20; Frecuencia=A/20000=200Hz

PWMDTY0 = 0x18;

PWMDTY1 = 0x6a; // inicializa PWM

PWME_PWME1 = 1; // habilita la dirección

PWMDTY2 = 20 // Ciclo de trabajo

PWMPER2; = 200; // Frecuencia=SB/200=10K

PWME_PWME2 = 1; // habilita el motor

}

/*------ -------------------------------------------------- -----------*\

init_SPEED

\*---------- - -------------------------------------------------- --------------*/

void init_SPEED(void) {

DDRM_DDRM0 =0; //cambio de código 1 en RP1

DDRM_DDRM1 =0; //codificar el interruptor 1 en RP1

DDRM_DDRM2 =0; //codificar el interruptor 1 en RP1

DDRM_DDRM3 =0; RP1

DDRM_DDRM4 =0; //código del interruptor 1 en RP1

DDRM_DDRM5 =0; //código del interruptor 1 en RP1

ATD0DIEN_IEN4 = 1; interruptor de código 1 en RP1, habilitar entrada digital PAD4

ATD0DIEN_IEN3 = 1; //interruptor de código 1 en RP1, habilitar entrada digital PAD3

if(RP1_1==

1) {

velocidad= alta_velocidad 2*(RP1_2*10 RP1_3*5 RP1_4*2 RP1_5*2 RP1_6 RP1_7 RP1_8);

}

else{

velocidad= alta_velocidad -2*(RP1_2*10 RP1_3*5 RP1_4*2 RP1_5*2 RP1_6 RP1_7 RP1_8);

}

}

/********************************************* *** **********************************

***/

/*-------------------------------------------- ---- ----------------------------*\

init_SCI

\ *--- ---------------------------------------------- ---- -----------------------*/

void init_SCI(void) // inicializar SCI

{

SCI0BD = 104; // tasa de bode=32M/(16*SCI0BD)=19200

SCI0CR1=0x00; 0b00001100;

SCI0CR2=0b00001100;

SCI0BD = 104; p>

}

Init.h

void init_PLL( void);

void init_AD(void);

void init_PWM(void);

void init_SPEED(void);

void init_SCI(void);

void init_PORT(void);

Void init_ECT(void);

Fuzzy.asm // Código de lógica difusa S12

RAM: sección

; Conjuntos de membresía difusa

; variables de membresía de entrada

fuzvar ausente

fuzvar: ds.b 5; entradas

Z: equ 0; indica de línea recta

VS: equ 1; girar ligeramente

S: equ 2; p>

BB: equ 3; un gran giro

VB: equ 4 ; un gran giro

variables de membresía de salida

fuzout ausente

fuzout: ds.b 4; salidas

permanecen: equ 5; sin cambios en kp

pequeño: pequeño cambio en kp

grande: ecuación 7; gran cambio

e en Kp

muy_grande: equ 8; cambio muy grande en kp

EEPROM: sección

; b 0, 35, 0, 8; indicar de línea recta

dc.b 0, 69, 8, 8; girar ligeramente

dc.b 35, 104, 8, 8; ; girar un poco

dc.b 69,138,8,8; un giro grande

dc.b 104,255,8,0; reglas: ;

construcción de regla

dc.b Z, $FE, permanecer, $FE

dc.b VS, $FE , poco, $ FE

dc.b S, $FE, grande, $FE

dc.b BB, $FE, grande, $FE

dc.b VB , $FE, very_big, $FE

dc.b $FF; fin de la regla

addingleton:

dc.b 0, 1, 2, 3; configuración del peso

ausentry FuzzyLogic

FuzzyLogic:

pshx

ldx #s_tab

ldy #fuzvar

mem; número de mem indica el número de entradas

mem

mem

mem

mem

ldab #4; número de conjuntos de membresía difusa de salida

cloop:

clr 1, y; borrar variables difusas de salida

dbne b, cloop

ldx #rules

ldy #fuzvar

ldaa #$FF

rev

ldy #fuzout

ldx #addsingleton

ldab #4

wav

ediv;

tfr y, d; devolver dpower

pulx

rts