Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

13/11/2015 #21

Avatar de papirrin

torres.electronico dijo: Ver Mensaje
Loquis, sto es CCS ? PIC? o para tus micros raros esos que soles manejar?
no baje nada aun por que tengo señal EDGE
Son para arduino pero solo para la pantalla que tengo.
13/11/2015 #22

Avatar de TRILO-BYTE

no son micros raros ni patrañas y menos artimañas

son otros micros de otros fabricantes y CCS no es un compilador fiable, almenos para mi no es del todo confiable y no es estandar.

si el AVR studio si es mas fiable y confiable que CCS, cada quien es libre de usar un compilador C , a menos que sea arduino ahi le dire no inventes !!!.
11/12/2015 #23


Migrar Librerias de Arduino a PIC.
Estoy controlando un modulo generador de señales via spi con un pic, especificamente el ad9833.
Funciona perfectamente, pero solo puedo generar ciertas frecuencias debido a que se usan palabras de 28bits; encontre un ejemplo basado en arduino que me puede servir pero no entiendo muy bien las operaciones que realiza.

El codigo en cuestión:

Código:
 //Once we\'ve got that, we split it up into separate bytes.
 MSB = (int)((calculated_freq_word & 0xFFFC000)>>14); //14 bits
 LSB = (int)(calculated_freq_word & 0x3FFF);

No se si esta realizando operaciones "and" o se refiere a otra operación.

En las hojas de datos del ad9833 muestra un ejemplo pero solo utiliza 14 bits, segui los pasos y solo puedo generar frecuencias de 0Hz a 1500Hz, si quisiera frecuencias mas grandes requiero de 28 bits y lamentablemente no se como formar la palabra.

Gracias de antemano. ...
11/12/2015 #24

Avatar de Nuyel

Espero que tengas bien el código y no como aparece ahi XD
Son operaciones lógicas simples, (int) es conversion explicita, & es un operador de AND a nivel de bits, con 0xFFFC000 crea una mascara de bits, prácticamente ignora los bits en ceros, que serian los primeros, el símbolo >> indica un desplazamiento de bits hacia la derecha indicado que son 14.
En el segundo se indica simplemente mascara con los 0x3FFF (los primeros 14) y así es que separa las variables en 2.

Por si acaso, así es como debería verse el código:
Código:
 //Once we\'ve got that, we split it up into separate bytes.
 MSB = (int)((calculated_freq_word & 0xFFFC000)>>14); //14 bits
 LSB = (int)(calculated_freq_word & 0x3FFF);
Las operaciones a nivel de bits y desplazamiento de bits son generales en todos los procesadores, así que puedes usar la función como está, solo recuerda declarar las variables apropiadamente.
12/12/2015 #25


muchas gracias!! funciona perfectamente!!. Voy a pulir un poco mas el codigo para compartirlo.
25/12/2015 #26

Avatar de Meta

Migrar Librerias de Arduino a PIC.
Hola:

Este es el código de Arduino que quiero pasar a C del CCS.
Código:
int pinLed =  13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  pinMode(pinLed, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  /* Voy leyendo carácter a carácter lo que se recibe por el canal
   *  serie (mientras llegue algún dato allí), y los voy concatenando
   *  uno tras otro en una cadena. En la práctica, si usamos el
   *  "Serial monitor" el bucle while acabará cuando pulsemos Enter.
   *  El delay es conveniente para no saturar el canal serie y que la
   *  concatenación se haga de forma ordenada.
   */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /* Unavez ya tengo la cadena "acabada", compruebo su valor y hago
   * que la placa Arduino reaccione según sea este. Aquí podríamos
   * hacer lo que quiesiéramos: si el comando es "tal", enciende
   * un Led, si es cual, mueve un motor... y así.
   */
  if (comando.equals("s1000") == true)  // Led_ON
  {
        digitalWrite(pinLed, HIGH); // Enciende el Led.
        Serial.println("EQUA");
  }
        
  if (comando.equals("s0000") == true) // Led_OFF
  {
        digitalWrite(pinLed, LOW); // Apaga el Led.
        Serial.println("EQUA");
  } 
  
  // Limpiamos la cadena para volver a recibir el siguiente comando. 
  comando="";
}
Hice algo que poco tiene que ver. Por eso los que sepan, intentar hacer lo más parecido a Arduino, con estilo, no lo que hice en C para el PIC.

Código:
#include <16F876A.h> 
#fuses HS,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT
#use delay (clock=4000000)         //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)   //manejo del RS232
#use fast_io (B)
#use fast_io (C)
/*******************************
Declaramos variables a usar
*/////////////////////////

#byte RCSTA=0X018
#define usart_off bit_clear(RCSTA,7)
#define usart_on bit_set(RCSTA,7)
//int xbe_buffer [6];
int dat,dat0,dat1,dat2,dat3;
int1 flag=false;



void main (void)
{
setup_adc_ports(no_analogs);
set_tris_c(0b11111000);
set_tris_a(0b000000);
set_tris_b(0b00000000);
output_a(0b000000);
output_b(0b00000000);
output_c(0b00000000);



while(1)
{

int conta=0;
usart_on;
//delay_ms(100);
while(getc() !=0x73);
{flag=true;
for(conta=0;conta<4;conta++)
{dat=getc();
// ([conta]=getc());
switch(conta)
{
case 0: dat0=dat;
break;
case 1: dat1=dat;
break;
case 2: dat2=dat;
break;
case 3: dat3=dat;
break;
default:
break;
}
//putc(getc());
}
}
if(flag==true)
{
if((dat0=='1') && (dat1=='0') && (dat2=='0') && (dat3=='0'))
{output_high(pin_b5);
output_high(pin_b4);
output_high(pin_c2);
putc ('E');
putc ('Q');
putc ('U');
putc ('A');
flag=false;
}
if(dat0=='0' && dat1=='0' && dat2=='0' && dat3=='0')
{ output_low(pin_a5);
output_low(pin_a1);
output_low(pin_a2);
output_low(pin_b2);
output_low(pin_b1);
output_low(pin_b0);
output_low(pin_b5);
output_low(pin_c1);
output_low(pin_c2);
output_low(pin_b4);
putc ('E');
putc ('Q');
putc ('U');
putc ('A');
flag=false;
}
}
Saludos.
26/12/2015 #27

Avatar de cosmefulanito04

En C tenés librerías ansi que pueden ayudarte:

- comando.equals("s1000") => strcmp(cadena1, cadena2)
- comando.concat(caracter) => strcat(cadena1, cadena2)

Esas funciones se encuentran en la librería "string.h". Fijate si tenés espacio de código suficiente en el uC, de lo contrario vas a tener que hacer algo más a la medida.

Luego la impresión por medio del puerto serie deberás encargarte vos de hacer una rutina para enviar/recibir un string por el puerto serie (supongo que serán las funciones getc y putc). Lo mismo que el manejo de los puertos.

Lo que hiciste para comparar los string no es tan loco, solo que está mal implementado, deberías usar vectores o punteros, que es lo mismo que hacés en assembler cuando apuntás en memoria usando un registro como dirección.
26/12/2015 #28

Avatar de Meta

Hola:

Actualicé el código del PIC arriba.

Aquí abajo, encontré un código ejemplo que no se si estará mejor sin gastar tanta RAM.
Código:
/* El módulo EUSART. Control remoto y monitorización

Este ejemplo recibe una serie de comandos ('0'-'7') que permiten cambiar de estado las salidas
RB7:RB0. Constantemente se transmite, previa conversión a ASCII, el estado actual de esas salidas 
a modo de monitorización */

#include <16f886.h>

/* Ajusta los valores de las palabras de configuración durante el ensamblado.Los bits no empleados
adquieren el valor por defecto.Estos y otros valores se pueden modificar según las necesidades */

#fuses     NOLVP,PUT,NOWDT,EC_IO,NOFCMEN,NOBROWNOUT    //Palabra 1 de configuración
#fuses    NOWRT,BORV40                                //Palabra 2 de configuración

/* Con estas directivas las funciones "input" y "output_bit" no reprograman
el pin de la puerta cada vez que son utilizadas. Si no se indica el
modo fast_io se asume por defecto standard_io el cual reprograma el pin
siempre antes de ser utilizadas estas funciones. */

#use fast_io (B)
#use fast_io (C)
#use delay(clock=4000000)            //Frecuencia de trabajo

//Habilita las funciones RS232, velocidad a 9600 baudios

#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

#byte PORTB =0x06                    //Dirección de la puerta B

/*Programa de tratamiento de la interrupción que se produce al recibir un carácter. Analiza el
comando recibido ('0' -'7') y actua sobre la salida apropiada haciéndola cambiar de estado */

#int_rda            //Vector de interrupción al recibir por el UART
tratamiento()
{    switch(getc())        //Lee el carácter recibido
    {
        case '0': output_toggle(pin_b0);break;    //Si es el comando '0' , RB0 cambia de estado
        case '1': output_toggle(pin_b1);break;    //Si es el comando '1' , RB1 cambia de estado
        case '2': output_toggle(pin_b2);break;    //Si es el comando '2' , RB2 cambia de estado
        case '3': output_toggle(pin_b3);break;    //Si es el comando '3' , RB3 cambia de estado
        case '4': output_toggle(pin_b4);break;    //Si es el comando '4' , RB4 cambia de estado
        case '5': output_toggle(pin_b5);break;    //Si es el comando '5' , RB5 cambia de estado
        case '6': output_toggle(pin_b6);break;    //Si es el comando '6' , RB6 cambia de estado
        case '7': output_toggle(pin_b7);break;    //Si es el comando '7' , RB7 cambia de estado
    }    
}

main()
{  
    signed int Contador;

    SETUP_ADC_PORTS(NO_ANALOGS);    //Puerta A y B Digitales
    output_b(0x00);                    //Borra las salidas
    set_tris_b(0b00000000);            //Puerta B salida
    set_tris_c(0b10111111);            //RC6/TxD salida de datos y RC7/RxD entrada del EUSART    
    putc('\r');                        //Transmite CR
    putc('\n');                        //Transmite avance de línea

    enable_interrupts(INT_RDA);        //Activa interrupción en la recepción
    enable_interrupts(global);        //Habilita interrupciones

    while(1)
    {
        for (Contador=7;Contador>=0;Contador--)    //Contador con Nº de bits a chequear
            printf ("%c",bit_test(PORTB,Contador)+'0');    //Transmite los bits convertidos a ASCII
            putc('\r');                //Transmite CR
    }
}
26/12/2015 #29

Avatar de cosmefulanito04

Dejando de lado ciertas funciones que parecen propias del CCS (no las conozco), pareciera que si funcionaría.

Lo que te recomendaría, es utilizar una trama aunque sea bien sencilla, para descartar mensajes equivocados. La trama por ej. la podés hacer con 3 bytes:

Byte cabecera (tipo código) - Byte con el datos a leer - Byte de checksum (la suma de los dos bytes anteriores)

Si bien estás transmitiendo el triple de información, hacés más robusta la comunicación y a futuro te permite expandirla a enviar algo más complejo que un solo byte de datos, pensá que te permitiría tomar decisiones diferentes según el byte de código que envías, haciendo por ejemplo que el byte de datos se pueda convertir en un array de datos según ese código.

Otra alternativa sencilla para este caso, es agregar el bit de paridad.
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.