Ultima etapa de PFC

[huntergti]

Buenas una vez más a todos los foreros. Después de unos cuantos meses programando he llegado por fin a mi última etapa de proyecto de fin de carrera, la cual es la más difícil y necesitaré una vez más de vuestra ayuda para acabarla. Empezaré explicando de que va el proyecto y que dudas me surgen. consistia en medir mediante un sensor de altura, sensor de peso a una persona, ver si hay aforo suficiente para el y que no se pase ni en altura minima ni maxima y que su peso sumado al total que hay en el local no supere el maximo permitido. Por supuesto todo almacenado en la eeprom y cada vez que saliera alguien se le restara tanto en aforo como en peso. El pic que he utilizado es el 18f4550. El motivo de usar este pic es x la ultima parte del pfc que es el usb. Todo lo anterior lo he hecho en ensamblador, ya que la primera vez que utilicé un pic use este lenguaje y el lenguaje c con sus funciones ya hechas me lía un poco.
En la ultima parte del pfc debo conectar lo anterior por usb de tal forma que mediante una interfaz gráfica pueda saber el peso del local y el aforo actual o por el contrario modificar los valores totales de aforo y peso. La interfaz gráfica que muestra o modifica los valores está hecha en Visual Basic. A partir de aquí me surge la duda de saber si una vez instalado el driver del usb del pic y programada la interfaz para que capture los eventos del usb será compatible con mi código que está escrito en ensamblador?? Donde puedo encontrar un ejemplo en ensamblador de usb? (la ayuda de palitroquez en "mis primeros pasos con el pic18f4550" fue fundamental para entender mejor este pic, pero todo allí del usb esta escrito en c). Espero que podais ayudarme y que pueda seguri desarrollandolo en ensamblador, pues volver a programarlo en c me haría perder un tiempo que es valiosisimo. Muchas gracias por todo

[huntergti]

Ummm no ha habido muchas respuestas. Puesto que seguro que es debido a lo del tema de ensamblador pues si pueden ayudenme en c y ya me encargaré yo de traducirlo al ensamblador por medio del disassembly listing. Gracias

[elreypic2]

Huntergti,

Creo que va a ser un poquito dificil que encuentres algo relacionado con USB en lenguaje ensamblador. Esto por el grado de complejidad que representa. Es por eso que la mayora de los trabajos para USB estan en lenguaje C, ya que este simplifica bastante lo referente al USB. Yo te sugiero que mas bien por ahi ataques el problema.

Saludos.

Elreypic.

[huntergti]

Ya suponía algo de eso  pero hay alguna forma de que desarrolle esta parte del pic en c, es decir el usb, y que el resto que tengo escrito en ensamblador se mantenga haciendo que el programa funcione??

[maunix]

Ya suponía algo de eso  pero hay alguna forma de que desarrolle esta parte del pic en c, es decir el usb, y que el resto que tengo escrito en ensamblador se mantenga haciendo que el programa funcione??

Fijate este link, creo que está lo que buscas

http://pe.ece.olin.edu/ece/projects.html

Y si quieres leer más

http://pic18fusb.online.fr/wiki/wikka.php?wakka=Links

[huntergti]

Muchas gracias por pasarme todos estos enlaces. Me estais ayudando un moton, menos mal q existe hoy x hoy internet y foros como este. La final tuve q tomar la decision de hacerlo en c, ya vere como consigo encgancharlo todo (tirare de #asm y #endasm). el caso es que siguiendo los pasos de J1M me quedo atrancado en una pequña prueba q estoy haciendo. Necesito enviar como mucho de la interfaz grafica al pic un valor q ronda 0-65535. Como sabreis eso ocupa dos bytes que debo guardar en la EEPROM. mi pregunta es como consigo separar los valores, es decir si, 10500 es en hex 2904, como hago para meter en un registro 29 y en otro contiguo 04. Una vez mchas gracias por todo

[huntergti]

No podeis ayudarme o es que no me explicado bien ? Please help

[vszener]

Creo que Microchip te da en su página referente al usb, código de muestra en ASM.


Suerte!!!

[maunix]

No podeis ayudarme o es que no me explicado bien ? Please help

A ver si te entendí ¿Quieres tomar el valor del byte low o high de una variable de 16 bits en C o en assembly?

[huntergti]

A traves de una interfaz grafica creada con visual c#, quiero tomar el valor del textbox (que sera como mucho 65535, es decir 2 bytes) y enviarlo al pic para que lo guarde en la eeprom. Mi problema es como hago para enviar un valor que sea mayor de 255, como guardo eso en la eeprom.
ejemplo: envio un array de la interfaz al pic donde  el array[0] = modo (en este caso enviar) y el array [1]= dato (0-65535). Mi pregunta es, como guardo el valor que envia si ocupa mas de un byte??

[maunix]

ejemplo: envio un array de la interfaz al pic donde  el array[0] = modo (en este caso enviar) y el array [1]= dato (0-65535). Mi pregunta es, como guardo el valor que envia si ocupa mas de un byte??

No programo en C# pero una forma simple e intuitiva es la siguiente (hay muchas formas de hacer lo mismo)

1) Tomas el dato de 16bits (0 a 65535) y lo divides por 256.
     El resultado lo guardas y lo envías.
2) Tomas el valor del dato y le restas 256xEl valor anterior, el numero que te quede será el resto.  Y eso envías

Yendo a usar formulas

Valor = 0 a 65535

VALOR_H = Valor / 256;  // división entera

VALOR_L = Valor - VALOR_H * 256;


Luego envias VALOR_H y VALOR_L en el orden que te parezca y lo reconstruyes del otro lado en el mismo orden.

[huntergti]

Bravo maunix. Muchas gracias x tu ayuda. Voy a intentar que funcione

[huntergti]

Despues de unos cuantos retoques en el codigo q expuso j1m conseguí enviar datos hasta los 65535 (una vez muchas gracias maunix). Ahora me surgen un par de dudas más. La primera es un hecho raro y es el siguiente: Escribo el dato y lo envio al pic para guardarlo en memoria, posteriormente le doy a recibir para que el pic me proporciono los datos guardados en la eeprom, pues en el texbox me pone un cero, vuelvo a pulsarlo y aparece el resultado correcto, por probar lo vuelvo a pulsar y aparece 0 otra vez, y ya x extrañeza lo pulso otra vez y aparece de nuevo el número, a que puede deberse eso?? La unica diferencia respècto al codigo de j1m es que yo utilizo la funcion usb_puts() debido a que la otra no me funcionaba correctamente.
La otra duda quizas sea más simple y es como hacer para que en visual c# si escriben texto en los textlabel salte una excepcion diciendo que solo acepta números, es decir, si escriben hola salte un msgbox indicando que solo se aceptan numeros.
saludos

[huntergti]

Buenas otra vez. Finalmente lo estoy pasando todo a c (q

[huntergti]

Buenas otra vez. Finalmente lo estoy pasando todo a c (q esta resultando mas facil de lo q pensaba). El problema me surge con las interrupciones que no sé en que fallo. Utilizo la interrupcion de cambio de estado por el portb y luego para el sensor de altura necesito el timer0 con 16 bits, ya que el pulso que me devuelve el sensor es la distancia del sensor al objeto Bueno hechas todas las cuentas limpio los flags y activo otra vez las interrupciones pero el código se queda petado y no hace nada. No sé en que fallo y sé que tiene algo q ver con el timer porque si quito esa línea todo funciona correcamente. Aqui os dejo el código a ver si me podeis echar una mano
#include <18F4550.h>
#use delay (clock=4000)

int   sensor_altura();
void main(){
   port_b_pullups(true);
   set_tris_a(0x3f);
   set_tris_b(0x30);
   set_tris_c(0x00);
   setup_timer_0(RTCC_INTERNAL | RTCC_DIV_2);
   #asm
   bsf   0xfd5,4
   bsf   0xfd5,3
   #endasm
   enable_interrupts(INT_RB);
   enable_interrupts(GLOBAL);
   #asm
   movlw   0x00;
   movwf   0xff1;
   movlw   0x00;
   movwf   0xff0;
   #endasm
   write_eeprom(0x03,0);
   write_eeprom(0x04,0);
   write_eeprom(0x06,250);
   write_eeprom(0x07,0);
   write_eeprom(0x13,0);   
   write_eeprom(0x14,0);
   write_eeprom(0x16,100);
   write_eeprom(0x17,0);   
   write_eeprom(0x25,220);
   write_eeprom(0x30,0);   
   write_eeprom(0x31,0);
   write_eeprom(0x32,0);
   write_eeprom(0x33,0);
   write_eeprom(0x26,150);   
   write_eeprom(0x27,200);

sleep();
}
#INT_RB
void interrupcion() {

   int8 estado=0;
   int1 altura=0;
   int1 peso=0;
   int1 aforo=0;
   disable_interrupts(GLOBAL);
      disable_interrupts(INT_RB);
   if(input_state(PIN_B4)==1){
      delay_ms(5000);
      altura=sensor_altura();
            output_c(0x04);
            delay_ms(2000);
            output_c(0x00);
            clear_interrupt(INT_RB);
            clear_interrupt(INT_TIMER0);
            goto fin;
         }
fin:
   enable_interrupts(GLOBAL);
   enable_interrupts(INT_RB);
}

int sensor_altura(){

   int8 valor=0;
   int8 altura_minima;
   int8 altura_maxima;
   int8 altura_l=0;
   int8 altura_h=0;
   double altura=0;
   int8 altura_sensor=0;
   int8 altura_ac_l=0;
   int8 altura_ac_h=0;
   int8 contador=1;
   double altura_acumulada;

while(contador>0){
   output_b(0x01);
   delay_us(15);
   output_b(0x00);
   valor=input_state(PIN_A1);
   while(valor==0){valor=input_state(PIN_A1);}
   set_rtcc(0);
   valor=input_state(PIN_A1);
   while(valor==1){valor=input_state(PIN_A1);}
   #asm
   movff 0xfd6,0x1D;
   movff 0xfd7,0x1E;
   #endasm
   altura=(altura_h*256)+altura_l;
   altura_sensor=altura/58;
   altura=read_eeprom(0x25);
   altura_l=altura-altura_sensor;
   write_eeprom(0x20,altura_l);
   altura_ac_l=read_eeprom(0x30);
   altura_ac_h=read_eeprom(0x31);
   altura_acumulada=altura_ac_h*256+altura_ac_l;
   altura=read_eeprom(0x20);
   altura_acumulada+=altura;
   if(altura_acumulada<255){
      altura_ac_l=altura_acumulada;
      write_eeprom(0x30,altura_ac_l);
      contador--;
   }else{
      altura_ac_h=altura_acumulada/256;
      altura_ac_l=altura_acumulada - (256*altura_ac_h);
      write_eeprom(0x30,altura_ac_l);
      write_eeprom(0x31,altura_ac_h);
      contador--;
         }
}
   altura_ac_l=read_eeprom(0x30);
   altura_ac_h=read_eeprom(0x31);
   altura_acumulada=(altura_ac_h*256)+altura_ac_l;
   altura_acumulada/=1;
   altura_minima=read_eeprom(0x26);
   altura_maxima=read_eeprom(0x27);
   if(altura_acumulada>altura_maxima){return 0;}
   else if(altura_acumulada<altura_minima){return 0;}
   else
   return 1;
}