dsPIC Curso Basico con C30

[Renatox_]

 Hola Chekebo, si no me dabas la idea inicial no hubiera podido hacer esto. No utilizé el formato 5.23 debido a que esa multiplicación toma varios ciclos, utilizé las operaciones AND y corrimiento ">>" a la derecha pero tampoco me funcionó, asi que utilizé macros, las pongo aquí:

Código: [Seleccionar]

//mis macros
//consigue direcciones del float
#define Lmbyteptr(var32) ((unsigned char*)(&var32)) //returns address of Lm byte
#define LMbyteptr(var32) ((unsigned char*)(&var32)+1) //returns address of LM byte
#define Hmbyteptr(var32) ((unsigned char*)(&var32)+2) //returns address of Hm byte
#define HMbyteptr(var32) ((unsigned char*)(&var32)+3) //returns address of HM byte
//descompone el float
#define getLmbyte(var32) ((unsigned char)(*Lmbyteptr(var32))) //
#define getLMbyte(var32) ((unsigned char)(*LMbyteptr(var32))) //
#define getHmbyte(var32) ((unsigned char)(*Hmbyteptr(var32))) //
#define getHMbyte(var32) ((unsigned char)(*HMbyteptr(var32))) //
//arma float
#define setLmbyte(var32,var8) {(unsigned char)(*Lmbyteptr(var32)=var8);} //
#define setLMbyte(var32,var8) {(unsigned char)(*LMbyteptr(var32)=var8);} //
#define setHmbyte(var32,var8) {(unsigned char)(*Hmbyteptr(var32)=var8);} //
#define setHMbyte(var32,var8) {(unsigned char)(*HMbyteptr(var32)=var8);} //

Los pasos que seguí son:

* Comprendí que la idea era primero encontrar la dirección de memoria en donde empieza el float, guardando estas 4 direcciones.

* Luego sacar la información de estas 4 direcciones utilizando punteros y almacenarlos en 4 bytes.

* LLevar los valores de esos 4 bytes al nuevo float guardando cada byte en su puntero correspondiente, es decir en las direcciones apuntadas Lm, LM, Hm, HM que son las 4 direcciones del nuevo float.

Este es el procedimiento;

Código: [Seleccionar]

   float x=-12.85, y;
   char dummy1, dummy2, dummy3, dummy4;

   //desarmar float
   dummy1=getLmbyte(x);
   dummy2=getLMbyte(x);
   dummy3=getHmbyte(x);
   dummy4=getHMbyte(x);

   //armar float
   setLmbyte(y,dummy1);
   setLMbyte(y,dummy2);
   setHmbyte(y,dummy3);
   setHMbyte(y,dummy4);

Comprobé mediante la herramienta "Watch" que el float se descompone en 4 bytes y se vuelven armar almacenandolos en el nuevo float.

Lo mejor de todo es que desarmar un float demora tan solo 8 ciclos, que bueno, comparados a los 10 000 ciclos de la instrucción sprintf es un gran avance.

Armar el float también demora tan solo 8 ciclos.

 Pego la foto de los registros.

[Renatox_]

así se ve mejor, es mi primera vez que pego una foto en el medio



Algo más sobre las macros que puse arriba. Para armar el float utilizé este formato:

Código: [Seleccionar]

#define setLmbyte(var32,var8) {(unsigned char)(*Lmbyteptr(var32)=var8);} //

Lmbyte(var32) = direc.baja del nuevo float

pero;

*Lmbyte(var32) = var8 = dummy1 = valor localizado o apuntado en la direc.baja del nuevo float

 

[Renatox_]

 Hola otra ves. Con el procedimiento anterior se puede mandar los 4bytes de un Float o los 2bytes de un Entero por los módulos de comunicación de forma rápida, la función printf y sprintf demoran muchos ciclos, por ejm el sprintf demora 10 000 ciclos en obtener los valores ASCII de un número Flotante, en cambio con ayuda de las macros puestas arriba toma tan solo 8 ciclos.

 Ahora he ordenado la parte de recepción, es decir como el otro dspic recibe estos 4 bytes o 2, y los vuelve a transformar a Float o Entero.

 Pego el procedimiento, para la recepción SPI, para la UART es similar:

Código: [Seleccionar]

void GetCom(unsigned int k, float *z)
{ 
   float f;
   char *p=(char *)&f;   // puntero "p" apunta a la dirección de "f", "p" tiene 4 bytes
   unsigned int m;
 
   for(m=0;m<k;m++)
    {
        while (DataRdySPI1()==0); // el registro SPIRB (SPIBUF) está vacio
        *p=getcSPI1(); // Valor que será guardado en la dirección localizada o apuntada por "p" 
        p++;            // Incrementa la dirección localizada en "p" en uno.
    }
   *z=f;    // "f" será guardado en la dirección localizada o apuntada por "z", o sea en "y"
}

int main (void)
{
   configSPI();
   float y;
    ...
   GetCom(sizeof(y),&y);    //sizeof(y)=4 "bytes" porque es flotante
    ...                                //&y dirección del dato y
}

 Funciona correctamente, apunten esto les puede servir cuando tengan que transmitir los datos flotantes rapidamente.

Saludos
Renatox.

[micro_cadaver]

muy interesantes los aportes de tu investigación compatriota, te he agregado a mi msn si no fuera mucha molestia claro esta  , me han pasado un 30f1020 y en estos dias pienso darme un tiempo para revisar su datasheet, ya me lei todo el post y esta muy intersante jijij 

[Renatox_]

Hola, ya tengo listas y probadas mi nuevas rutinas para transmitir y recibir datos a gran velocidad por los puertos SPI y UART, enviando los tipos de datos en bytes, primero el de menos peso.

Estas rutinas son SendCom y GetCom, pongo el código por si desean usarlas.

Código: [Seleccionar]

SendCom(sizeof(data),(char *)&data);

void SendCom(unsigned int k, char *p)
{ 
 for(;k;--k)
  {
     while(BusyUART1()==1);
     //while(SPI1STATbits.SPITBF==1); 
     putcUART1(*p);
     //putcSPI1(*p);
     p++;
  }
}


GetCom(sizeof(data),(char *)&data);

void GetCom(unsigned int k, char *p)
{
 for(;k;--k)
 {
    while(DataRdyUART1()==0);
    //while(DataRdySPI1==0);
   *p=getcUART1();
   //*p=getcSPI1();
   p++;
 }
}


si data es entero, sizeof(data)=2
si data es flotante, sizeof(data)=4
El puntero p apunta a la dirección más baja de data

Hize la prueba enviando datos enteros a la pc, el programa que las recibe es Labview y lo arma correctamente.

saludos

[Renatox_]

Hola, he encontrado este enlace donde reciben quejas en errores de compilación o bug, si alguién ha encontrado uno en C30 lo puedo mandar aquí,

reporte de errores

saludos

[Renatox_]

Hola como están, tengo un problema estoy enviando esta cadena al hiperterminal mediante el printf, lo mando así:

float f1=-13.25;

printf("%05.2f",f1);

En el hiperterminal lo recibo y muestra -13.25. Pero yo quiero que me salga 00-13.25, como debería configurarlo para que me salga bien el envio.

gracias.

[Milo]

Buennass:

Se me ocurre esta chorrada, no se si te valdrá prueba a ver,

printf("00%05.2f",f1);

saludos,

[Renatox_]

Hola Milo, claro con eso obtengo 00-13.25 en hiperterminal, pero si mi f1=-134.25 entonces obtendré 00-134.25 con 6 decimales a la izquierda, solo necesito 5 y que aparescan siempre aun cuando cambie el f1.

Con el formato entero si funciona, si envio -13 aparece 00-13 en hiperterminal. Necesito enviar una cantidad constante de caracteres por cada numero flotante y el Labview los recibe por la USART. Por ejm en cada bucle while del Labview envio 24 caracteres que representan 3 numeros flotantes, entonces cada flotante debe tener 8 caracteres siempre, sino se me desfasa la secuencia y aparecen otros números en el graficador.

un saludo;

[juandymu]

hola

[juandymu]

hola soy nuevo en el tema de c30
he programado en codigo asm pero en c30 no y aun no logro empesar alguno me puede colaborar ya habri el proyecto pero no se donde ouedo ubicar codigos o comandos ??

[superprp]

Yo también estoy empezando con el C30, veo que es muy diferente a lo que había hecho hasta ahora (programar pics 16F y 18F en asm), me estoy leyendo los documentos de MPLAB C30 USER GUIDE, 16BITS LANGUAGE TOOL LIBRARY, y LIBRARY C30 GETTING STARTED, hay muchisimo para leer, pero la verdad que no me aclaro mucho con tanta instrucción, si alguien tiene algun tutorial breve en español que con el ingles tantos folios... y muchas cosas no llego a entenderlas, no se ingles 100%, o si podeis explicar lo básico como hacer un TRISB, hacer un PORTB, como configurar los bits de los diferentes registros ADCON, INTCON, ...., como crear variables en una zona de memoria...

[Renatox_]

Hola que tal, para empezar te recomiendo el Getting Started la parte referida al C30 sigue paso a paso el desarrollo para crear el proyecto, luego que sepas como usar la estructura general vete al Family Reference Manual, y empieza con lo básico que es puertos, timer, uart, etc.

Por último cuando ya estes familiarizado con el C30 y sus extensiones de lenguaje básicas puedes profundizar leyendo el C30 Compiler User Guide, donde esta todo detallada, exensiones de lenguaje, atributos, etc.

saludos

[superprp]

El Family Reference Manual del dsPIC30F la verdad que no me soluciona nada, ¿es éste documento o te refieres a otro?

http://ww1.microchip.com/downloads/cn/DeviceDoc/cn021484.pdf

El Getting Started me dice como crear u proyecto, pero eso no te dice nada a la hora de empezar a programar que es donde tengo el dilema, y el C30 Compiler Guide no te explica las cosas básicas, ¿no hay documentos intermedios?

Quizas migrar del ensamblador directamente al C30 no sea lo mas adecuado, pero es necesario, quizas hay algún documento de introducción al C de microchip en general que es válido para el C18, C30, ...

[blackcat]

Hola ... cuando se descarga el C30 del sitio web de microchip dice claramente:

The MPLAB® C C30 compiler is a full-featured ANSI compliant C compiler

Por lo que todo respecto al lenguaje C lo podes encontrar en cualquier libro de C, yo aprendi C con el libro:

Kernighan Brian W; Ritchie Dennis M. El Lenguaje de Programación C. Segunda Edición. Prentice Hall, 1991.

El libro es muy claro para alguien que nunca ha programado y muy buena referencia para alguien que ya tenga experiencia ...

Ahora, Microchip tiene los manuales de C30 que refieren los compañeros... estos no son muy claros de como empezar a programar C, sin embargo, relatan detalles muy importantes y únicos del compilador C30 ... detalles que no te dice un libro de C cualquiera .. de hecho ninguno de los que he leido  ... supongo que Microchip puso esos manuales para personas con un poco experiencia o con algún conocimiento en C.

Respecto a los periféricos del micro el manual mas efectivo es el manual de referencia de la familia que estes usando 24, 30 o 33 ... aunque existe una librería con funciones para utilizar los perifericos esta no se compara ni en 1% al del compilador de CCS ... lo que quiero decir que si no tienes conocimiento del periférico a fuerza tenés que leer (y entender  ) el manual de referencia para ver como funciona ... yo fui asistente de un laboratorio de la universidad en donde se usaban  PICs, mucha gente usaba la serie 16F con el compilador CCS, algunos ASM con MPLAB, unos pocos usaban 18F con C18 ... no quiero criticar a nadie pues hay muchas excepciones ...  todos eran principiantes, mi tarea era ayudarlos con la selección del PIC, cuales interfaces usar según el proyecto, etc, etc ... de los que usaban CCS muy pocos sabian como funcionaba el PWM, pues muchas veces les tuve que explicar!  ... los que usaban ASM y C18 conocían a la perfección como funcionaba el PWM, quiza alguna duda con el timer pero nada complicado ... Con esto NO quiero decir que ASM y C18 es mejor que CCS, me refiero a que ASM y C18 te obligan a leer la hoja de datos y el manual de referencia para ver como demonios se pone a funcionar el PWM.

Mi recomendación siempre es empezar con ASM para tener una noción de como funciona el micro, luego pasar a C. El libro:

Programming 16-Bit PIC Microcontrollers in C: Learning to Fly the PIC 24

Es muy bueno para tener ideas de proyectos.... pero también en la seccion de code examples o app notes en el sitio de microchip hay buenos ejemplos en C y ASM