Muy bien, despues de dos dias de andar con jale de esta impresora, me encontré con un problema similar al que marcan en este link, sin embargo, los pasos que ahi marcan, no me funcionaron, y a pesar de haber bajado los drivers oficiales de Samsung, y luego encontre esta otra información, y de igual modo no me funcionó.
El detalle, despues de seguir buscando, es que se debe a un bug con el paquete the Gutenprint, la información la encontré aqui, y pues al desinstalar tal paquete, y al reinstalar el driver unificado de samsung desde AUR, todo funcionó de maravilla.
Como recomendación, la versión que instalé fue la 1 de aur, existen las versiones 4, pero estas, a mi, no me funcionaron.
viernes, 24 de julio de 2015
viernes, 17 de julio de 2015
Mi aventura para elaborar un componente nuevo para Fritzing (el CPLD EPM240 de Altera)
(Ví que en una página mencionaron este pequeño aporte - ¡gracias!)
Pues antes que nada, el desarrollo de material para prácticas de Electrónica digital, requiere de un buen tiempo y en este caso, me enfrente a la situación de que el material debe contener la conexión de una CPLD, en especifico, de un tipo de tarjeta, una Altera, la EPM240.El breakout que requiero es el siguiente:
El problema es que este elemento no se encuentra en las bibliotecas de Fritzing, y pues los vendedores en aliexpress, mercadolibre y otros mas, no me dan las medidas de este elemento.
Ahora bien, siguiente los tutoriales de aquí, aquí y aquí pude, después de algunas horas (inicie hoy a las 11 am y finalice mas o menos a las 2030 hrs) y con ayuda de Inkscape, logré el siguiente gráfico
El problema, después de terminar el gráfico, fue añadirlo al Fritzing, para lo cual, de acuerdo a los anteriores tutos, se puede tomar algún elemento y modificarlo para grabar nuestro nuevo componente.
De igual modo, un problema que encontré, es que la tarjeta contiene muchos terminales (aproximadamente 100), por lo cual me vi en la necesidad de usar un conector, sin embargo Fritzing contiene conectores con una capacidad máxima de 64 terminales. Para esto, de momento y de forma muy chapucera, deje muchos terminales sin conectar.
Otra situación que me encontre, es que Fritzing solo importa imágenes SVG con fuentes OCRA y/o tipo Droid, y lamentablemente mi PC no contaba con esa fuente; este problema se arregla agregando las fuentes requeridas (lee aquí y aquí).
Parecería que ya casi terminaba, pero me encontré con la situación de que a pesar de cambiar las fuentes que había anexado, las ubicaciones de los textos no correspondian con las terminales, y esto lo resolví al modificar una propiedad de los textos en Inkscape:
En el combobox espacio entre líneas, lo tenia a un porcentaje diferente al 100% y esto ocasionaba que al importar la imagen a Fritzing se modificaran las posiciones.
Ya con la imagen bien diseñada, ahora corresponde a la ubicación de los pines según su posición en la tarjeta y reutilizar aquellos que no se encuentran en la numeración. Esto si me llevo un tiempo ;)
Ya finalizado, ahora solo hay que jalar el componente nuevo y armar el proto, el resultado fue el siguiente (para un multiplexor de 4 a 1).
Gracias por leer y no aburrirse ........
lunes, 13 de julio de 2015
GHDL en Manjaro Linux 64 bits y error sufijo de instrucción inválido para `push' (Solucionado)
Bueno, mientras mi esposa canta canciones rancheras, mi hija juega plantas contra zombies y mi bebe esta viendo la tv, yo me dada de topes por simular un codigo de VHDL con GHDL en mi lap viejita de 64 bits.
El problema que tenia al tratar de analizar con ghdl un codigo que en Quartus II compila adecuadamente me salia lo siguiente en la consola
"Possible problems in Linux 64-bits
1. Problem: in Linux 64-bits the following errors are got when compiling:
/home/myworkspace/e~and_gate.s: Assembler messages:
/home/myworkspace/e~and_gate.s:40: Error: invalid instruction suffix for 'push'
/home/myworkspace/e~and_gate.s:42: Error: invalid instruction suffix for 'pop'
Solution: the problem is that GHDL is a 32-bit program. The solution is to append some extra options when invoking to GHDL.
$ ghdl -a -Wa,--32 ...
$ ghdl -e -Wa,--32 -Wl,-m32 ...
However, UMHDL already checks the Operating System when executing and take it into account, so that errors should not happen.
"
A partir de esta indicación, no es necesario instalar entonces el IDE para compilar y simular un codigo de VHDL, es por ellos que de acuerdo a la wikibooks de vhdl (https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_VHDL/Ap%C3%A9ndices/Instalaci%C3%B3n_y_uso_de_GHDL)
Se puede simular de la forma
[miguel@casita PracticaMux]$ ghdl -a mux4_1tb.vhd mux4_1tb.s: Mensajes del ensamblador: mux4_1tb.s:55: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:57: Error: sufijo de instrucción inválido para `pop' mux4_1tb.s:555: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:602: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:663: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:724: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:785: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:846: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:887: Error: sufijo de instrucción inválido para `push' mux4_1tb.s:929: Error: sufijo de instrucción inválido para `push' ghdl: compilation errorEl problema según lei en los foros de ghdl, se debe a que ghdl es un programa para 32 bits y el equipo que tengo tiene gcc de 64 bits, y buscando una solución encontre el wiki de UMHDL que está SourceForge y que es un IDE para trabajar de forma inicial con VHDL; en su wiki se indica lo siguiente de forma textual
"Possible problems in Linux 64-bits
1. Problem: in Linux 64-bits the following errors are got when compiling:
/home/myworkspace/e~and_gate.s: Assembler messages:
/home/myworkspace/e~and_gate.s:40: Error: invalid instruction suffix for 'push'
/home/myworkspace/e~and_gate.s:42: Error: invalid instruction suffix for 'pop'
Solution: the problem is that GHDL is a 32-bit program. The solution is to append some extra options when invoking to GHDL.
$ ghdl -a -Wa,--32 ...
$ ghdl -e -Wa,--32 -Wl,-m32 ...
However, UMHDL already checks the Operating System when executing and take it into account, so that errors should not happen.
"
A partir de esta indicación, no es necesario instalar entonces el IDE para compilar y simular un codigo de VHDL, es por ellos que de acuerdo a la wikibooks de vhdl (https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_VHDL/Ap%C3%A9ndices/Instalaci%C3%B3n_y_uso_de_GHDL)
Se puede simular de la forma
[miguel@casita PracticaMux]$ ghdl -a -Wa,--32 mux4_1.vhd [miguel@casita PracticaMux]$ ghdl -a -Wa,--32 mux4_1tb.vhd [miguel@casita PracticaMux]$ ghdl -e -Wa,--32 -Wl,-m32 mux4_1tb [miguel@casita PracticaMux]$ ghdl -r mux4_1tb --vcd=mux4_1.vcd [miguel@casita PracticaMux]$ gtkwave mux4_1.vcdLos códigos son los siguientes
-- mux4.vhd -- Multiplexor 4 a 1 -- Direcciona una de cuatro señales de entrada (d0 a d3) hacia la salida -- dependiendo del estado de los bits de selecci´on ENTITY mux4_1 is port( d0,d1,d2,d3 : in bit; --s : in bit_vector (1 downto 0); s0,s1 : in bit; y : out bit); END mux4_1; architecture mux4to1 of mux4_1 is begin -- Asignaci´on de señales concurrentes y<= ((not(s1)) and (not(s0)) and d0) or ((not(s1)) and s0 and d1) or (s1 and (not s0) and d2) or (s1 and s0 and d3); end mux4to1;
--mux4_1tb.vhd
-- Multiplexor 4 a 1
-- Direcciona una de cuatro señales de entrada (d0 a d3) hacia la salida
-- dependiendo del estado de los bits de selecci´on
ENTITY mux4_1tb is
END mux4_1tb;
ARCHITECTURE muxtb OF mux4_1tb is
COMPONENT mux4_1
PORT(
d0,d1,d2,d3 : in bit;
--s : in bit_vector (1 downto 0);
s0,s1 : in bit;
y : out bit);
END COMPONENT;
SIGNAL d0,d1,d2,d3: bit;
SIGNAL s0,s1: bit;
SIGNAL y: bit;
BEGIN
u0: mux4_1 PORT MAP (d0,d1,d2,d3,s0,s1,y);
d0 <= '1' after 0 ns, '0' after 5 ns, '1' after 10 ns, '0' after 15 ns;
d1 <= '1' after 0 ns, '0' after 10 ns, '1' after 20 ns, '0' after 30 ns;
d2 <= '1' after 0 ns, '0' after 20 ns, '1' after 40 ns, '0' after 60 ns;
d3 <= '1' after 0 ns, '0' after 40 ns, '1' after 80 ns, '0' after 90 ns;
s0 <= '0' after 0 ns, '0' after 1 ns;
s1 <= '0' after 0 ns, '1' after 2 ns;
END muxtb;
La salida es la siguiente 
viernes, 22 de mayo de 2015
usando printf y scanf en avrgcc con ATmega48
El siguiente codigo hace uso de la libreria usart.h y usart.c que estaban disponibles en el sitio de
programacion de microcontroladores AVR de Shawn Johnson
Lo interesante de este ejemplo, es el uso de las funciones estandar de C printf y scanf para
el envio de cadenas preformateadas a través del puerto serie de este microcontrolador.
A continuación se muestran las fuentes utilizadas para este tipo de comunicacion
http://www.atmel.com/webdoc/AVRLibcReferenceManual/using_tools_1using_sel_gcc_opts.html#using_tools_1gcc_minusW
/*
* En las opciones de compilación del linker
* se deben agregar las siguientes lineas en eclipse
*
* -Wl, -u, vfprintf -lprintf_min, -u, vfscanf -lscanf_min -lm
*
* En la siguiente ruta
* Propiedades del proyecto
* C/C++ Build
* Valores
* Toolsettings
* AVR C Linker
* General
En codebloacks
Para agregarlas solo da clic derecho en el nombre del proyecto
elige la opcion que dice Properties....
En la ventana que se abre, da clic en el boton Project's Build options...
Te abre una nueva ventana
Da clic en el Tab Linker Setting
y del lado izquierdo encuentras las opciones del linker
quedan de la siguiente manera
-mmcu=atmega48
-Wl,-Map=$(TARGET_OUTPUT_DIR)$(TARGET_OUTPUT_BASENAME).map,--cref
-u
vfprintf -lprintf_min
-u
vfscanf -lscanf_min -lm
* */
#include <avr/io.h>
#define F_OSC 1000000UL
#include <util/delay.h>
#include "usart.h"
int main(void)
{
char name[30];
usart_init();
puts("\n\r Enviando datos");
puts("\n\r Mecatronica\n\r ITST\n\r");
puts("Como te llamas?:\n\r");
scanf("%s\n\r", name);
printf(" Hola %s",name);
while(1);
}
Librerias
/****************************************************************************** * FileName: usart.h * Overview: Macros y prototipos de funciones para el USART0 en modo Asíncrono * Processor: ATmel AVR con USART0 * Compiler: AVR IAR C y AVR GCC (WinAVR) * Author: Shawn Johnson. http://www.cursomicros.com. * * Copyright (C) 2008 - 2013 Shawn Johnson. All rights reserved. * * License: Se permiten el uso y la redistribución de este código con * modificaciones o sin ellas, siempre que se mantengan esta * licencia y las notas de autor y copyright de arriba. *****************************************************************************/ #include <avr/io.h> #define F_CPU 1000000UL #include <util/delay.h> #include <stdio.h> /* Define la velocidad de transmisión del USART (en bits/segundo), si aún no * ha sido definida. */ #ifndef USART_BAUD #define USART_BAUD 9600UL #endif /* Usar kbhit para ver si hay algún dato en el buffer de recepción antes de * llamar directamente a la función getchar para evitar esperas innecesarias. */ #define kbhit() (UCSR0A & (1<,<RXC0)) /* Descomentar el siguiente #define para que la funcion 'getchar' haga eco de * los caracteres recibidos. */ //#define __GETCHAR_ECHO__ /* Macros para AVR GCC */ #if defined( __GNUC__ ) #ifdef putchar #undef putchar #endif #ifdef getchar #undef getchar #endif #endif /* Definiciones de funciones */ void usart_init(void); int putchar(int); int getchar(void);
/******************************************************************************
* FileName: usart.c
* Overview: Implementa funciones para el USART0 en modo Asíncrono
* Processor: ATmel AVR con USART0
* Compiler: AVR IAR C y AVR GCC (WinAVR)
* Author: Shawn Johnson. http://www.cursomicros.com.
*
* Copyright (C) 2008 - 2013 Shawn Johnson. All rights reserved.
*
* License: Se permiten el uso y la redistribución de este código con
* modificaciones o sin ellas, siempre que se mantengan esta
* licencia y las notas de autor y copyright de arriba.
*****************************************************************************/
#include "usart.h"
//****************************************************************************
// Inicializa el USART0.
//****************************************************************************
void usart_init(void)
{
/* Configurar baud rate */
UCSR0A |= (1<<U2X0); //modo2
UBRR0 = F_CPU/(8*USART_BAUD)-1;
/* Configurar modo de operación Asíncrono y formato de frame a
* 8 bits de datos, 1 bit de stop y sin bit de paridad. */
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
/* Habilitar módulos Receptor y Transmisor */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
#if defined( __GNUC__ )
/* Asociar las funciones 'putchar' y 'getchar' con las funciones de entrada
* y salida (como printf, scanf, etc.) de la librería 'stdio' de AVR-GCC */
fdevopen((int (*)(char, FILE*))putchar, (int (*)(FILE*))getchar);
#endif
}
//****************************************************************************
// Transmite el byte bajo de 'dato' por el USART
//****************************************************************************
int putchar(int dato)
{
/* Esperar a que haya espacio en el buffer de transmisión */
while ((UCSR0A & (1<<,UDRE0)) == 0 );
/* Colocar dato en el buffer de transmisión */
UDR0 = dato;
return dato;
}
//****************************************************************************
// Recibe un byte de dato del USART
//****************************************************************************
int getchar(void)
{
/* Esperar a que haya al menos un dato en el buffer de recepción */
while ((UCSR0A & (1<<RXC0)) == 0 );
/* Leer y retornar el dato menos reciente del buffer de recepción */
#if defined ( __GETCHAR_ECHO__ )
return (putchar(UDR0));
#else
return UDR0;
#endif
}
Paginas de referencia:
http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__stdio_1ga67bae1ad3af79809fd770be392f90e21.htmlhttp://www.atmel.com/webdoc/AVRLibcReferenceManual/using_tools_1using_sel_gcc_opts.html#using_tools_1gcc_minusW
domingo, 12 de abril de 2015
Sensor Ultrasónico en Arduino sin pulseIn ni Interupciones
Este post es probable que no parezca interesante, pero tiene su gracia.
Arduino cuenta con intrucciones como micros(), millis() y seconds(); las cuales incrementan un contador desde que arranca el programa y de acuerdo a su resolución, el desbordamiento va desde minutos hasta días.
Por lo leido en los foros de Arduino, la función PulseIn, usada por algunos para la lectura de sensor ultrasonico.
El siguiente es un código que hice solo como prueba para no usar PulseIn, pero con la ayuda de la intrucción micros()
Arduino cuenta con intrucciones como micros(), millis() y seconds(); las cuales incrementan un contador desde que arranca el programa y de acuerdo a su resolución, el desbordamiento va desde minutos hasta días.
Por lo leido en los foros de Arduino, la función PulseIn, usada por algunos para la lectura de sensor ultrasonico.
El siguiente es un código que hice solo como prueba para no usar PulseIn, pero con la ayuda de la intrucción micros()
int trig = 7;
int echo = 6;
int led = 13;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode (trig, OUTPUT);
pinMode (echo, INPUT);
pinMode (led, OUTPUT);
}
int count1=0, count2=0;
int valor;
void loop() {
// put your main code here, to run repeatedly:
count1 =count2 = 0;
digitalWrite(trig,LOW);
delay(1);
digitalWrite(trig,HIGH);
delayMicroseconds(10);
digitalWrite(trig,LOW);
while(!digitalRead(echo)){}
count1 = micros();
while(digitalRead(echo))
{
}
count2 = micros();
valor = count2-count1;
int cm = (valor/2)/29.1;
Serial.print(valor);
Serial.println(" ticks");
Serial.print(cm);
Serial.println(" cm");
delay(250);
digitalWrite(led,LOW);
}
Se realizo un comprativo entre este código y el que usa pulseIn, tal comparativo se utilizó un vaso con agua y en sensor como medido de distancia hacia el agua, la cantidad de muestras para ambos casos fue de 113 y se debe tomar en cuenta que la colocacion del sensor no fue la mas adecuada.
miércoles, 1 de abril de 2015
Manjaro Linux, casi sin problemas por el momento Intel graphics en Gateway Mx6947
Esta laptop viejita, desde la cual estoy escribiendo, aun funciona muy bien y tiene Manjaro Linux desde el 2013 y casi no ha dado problemas, solo uno con la tarjeta de video Intel que trae
ya que marcaba un error con ciertas aplicaciones, entre ellas
https://wiki.archlinux.org/index.php/Intel_graphics#InstallationSNA issues
Note que hay un link simbolico en la carpeta referida en el foro, por ello decidí echarme a la mar y navegar entre los directorios del etc
Aquí fue donde encontre el dichoso Option "AceelMethod" "sna" y lo cambie por uxa tal y como lo recomiendan y listo!!!!
incluso ya puedo correr el glxgear de open gl
Finalmente una imagen de mi lap viejita
00:02.0 VGA compatible controller: Intel Corporation Mobile 945GM/GMS, 943/940GML Express Integrated Graphics Controller (rev 03)
00:02.1 Display controller: Intel Corporation Mobile 945GM/GMS/GME, 943/940GML Express Integrated Graphics Controller (rev 03) ,
ya que marcaba un error con ciertas aplicaciones, entre ellas
- scilab
- vlc con algunos videos
- captura de mi escritorio con gtkRecordMyDesktop
https://wiki.archlinux.org/index.php/Intel_graphics#InstallationSNA issues
From man 4 intel: There are a couple of backends available for accelerating the DDX. "UXA" (Unified Acceleration Architecture) is the mature backend that was introduced to support the GEM driver model. It is in the process of being superseded by "SNA" (Sandybridge's New Acceleration). Until that process is complete, the ability to choose which backend to use remains for backwards compatibility. SNA is the default acceleration method in xf86-video-intel. If you are experience issues with SNA, try using UXA instead, which can be done by creating an X configuration file containing the following:
/etc/X11/xorg.conf.d/20-intel.conf
Section "Device"
Identifier "Intel Graphics"
Driver "intel"
Option "AccelMethod" "uxa"
EndSection
El problema es que mi distro, no tiene en esa dirección el archivo :S
[miguel@casita ~]$ cd /etc/X11/xorg.conf.d/
[miguel@casita xorg.conf.d]$ ls 20-keyboard.conf 90-mhwd.conf@
Note que hay un link simbolico en la carpeta referida en el foro, por ello decidí echarme a la mar y navegar entre los directorios del etc
[miguel@casita xorg.conf.d]$ cd /etc/X11/
[miguel@casita X11]$ ls mhwd.d/ xinit/ xorg.conf.d/
[miguel@casita X11]$ cd mhwd.d/
[miguel@casita mhwd.d]$ ls intel.conf
[miguel@casita mhwd.d]$ less intel.conf
Aquí fue donde encontre el dichoso Option "AceelMethod" "sna" y lo cambie por uxa tal y como lo recomiendan y listo!!!!
incluso ya puedo correr el glxgear de open gl
martes, 31 de marzo de 2015
jueves, 12 de marzo de 2015
Documentando con Doxygen Cabeceras
/** @file clk.h @code #include@endcode @brief Macros para definir la frecuencia de oscilacion del reloj principal */ #ifndef CLK_H #define CLK_H /** * @name Definitions for MCU Clock Frequency * Adapt the MCU clock frequency in Hz to your target. * Revisa las paginas 37-39 */ #define F_CPU 16000000L ///< Frecuencia de 16MHz #if F_CPU == 16000000L #define ADC_PRESCALER 0x07 /// Patebin link
Documentando con Doxygen programa Principal
Archivo Principal
/**@mainpage TecladoDriver.c * @brief Imprimir en un display de siete segmentos la tecla presionada por un teclado matricial @section intro Este programa imprime un numero desde un teclado matricial y lo pone en un display de siete segmentos de catodo comun es posible el uso de un display de anodo comun, a traves de una interfaz con un ULN2803 @section Uso Solo se presiona una tecla del matricial y el numero aparece en el display * @author: Miguel Montiel */ #include#include "clk.h" #include "keyb.h" #include "sevseg.h" /** @file TecladoDriver.c @brief Programa que escribe un numero a un display de 7 segmentos @author Miguel Montiel */ int main(void) { unsigned char tecla; _init_Teensyduino_internal_(); vInitKeyPad(); InitSegSeg(); while(1) { //TODO:: Please write your application code tecla = ui8_TestKeyPad(); delay_ms(5); Print(tecla); } }
miércoles, 4 de marzo de 2015
domingo, 1 de marzo de 2015
viernes, 28 de marzo de 2014
Vector Linux 7.0 en Celeron 600MHz con 64MB en RAM
;) si fue posible instalar Vector Linux y compilar GCompris 12.05 en este equipo, el problema es que la velocidad en que corre gcompris es muuuy lenta, pero si corre, el audio funciona muy bien.
Creo se usará este equipo para hacer otras cosas como aun automatizacion pequeña
Creo se usará este equipo para hacer otras cosas como aun automatizacion pequeña
jueves, 20 de marzo de 2014
Reactivando el backlight en Manjaro Linux
Esto solo es un repost de
http://wiki.manjaro.org/index.php/Reactivating_the_Backlight
De acuerdo a la liga, no es posible ajustar el brillo de la pantalla, debido a que los fabricantes han deshabilitado mediante BIOS, el dimmer de las lamparas si no es detectado windows, de acuerdo al mismo texto, es posible recuperar el ajuste de brillo cuando entramos en una consola el siguiente comando
http://wiki.manjaro.org/index.php/Reactivating_the_Backlight
De acuerdo a la liga, no es posible ajustar el brillo de la pantalla, debido a que los fabricantes han deshabilitado mediante BIOS, el dimmer de las lamparas si no es detectado windows, de acuerdo al mismo texto, es posible recuperar el ajuste de brillo cuando entramos en una consola el siguiente comando
sudo sed "s/\(GRUB_CMDLINE_LINUX=\)\"\"/\1\"acpi_osi=Linux acpi_backlight=vendor\"/" /etc/default/grub -i
El cual permite reajustar el brillo en linux, esto pide ingresar nuestro passwd y ahora
solo queda por teclear en consola de nuevo, el siguiente comando
sudo update-grub
Al terminar se cierra la terminal, se reinicia el sistema y listo!!!
martes, 21 de enero de 2014
Led Blink ATmega32U4 a 16 MHz
La tarjeta de Teensyduinno V2.0 la cual contiene un ATmega32U4 puede ser programada por medio de un bootloader el cual está residente en la memoria FLASH del microcontrolador.
Una gran ventaja de esta tarjeta ademas de que puede ser programada como un arduino, tambien puede ser programada como un AVR normal, por medio de avr-Gcc
En el siguiente programa se muestra un ejemplo de como hacer que encienda y apague un LED e intervalos de un segundo,
fuente:
http://forum.pjrc.com/threads/21825-Fuses-Teensyduino-sets-for-Teensy-2-0
Una gran ventaja de esta tarjeta ademas de que puede ser programada como un arduino, tambien puede ser programada como un AVR normal, por medio de avr-Gcc
En el siguiente programa se muestra un ejemplo de como hacer que encienda y apague un LED e intervalos de un segundo,
fuente:
http://forum.pjrc.com/threads/21825-Fuses-Teensyduino-sets-for-Teensy-2-0
#define F_CPU 16000000L #if F_CPU == 16000000L #define ADC_PRESCALER 0x07 #define CPU_PRESCALER 0x00 #elif F_CPU == 8000000L #define ADC_PRESCALER 0x06 #define CPU_PRESCALER 0x01 #elif F_CPU == 4000000L #define ADC_PRESCALER 0x05 #define CPU_PRESCALER 0x02 #elif F_CPU == 2000000L #define ADC_PRESCALER 0x04 #define CPU_PRESCALER 0x03 #elif F_CPU == 1000000L #define ADC_PRESCALER 0x03 #define CPU_PRESCALER 0x04 #else #error "Teensyduino only supports 16, 8, 4, 2, 1 MHz. Please edit boards.txt" #endif //#include//#include //#include void _init_Teensyduino_internal_(void); int main(void) { _init_Teensyduino_internal_(); DDRB |= (1 << DDB0); while(1){ PORTB |= (1 << PB0); _delay_ms(1000); PORTB &= ~ (1 << PB0); _delay_ms(1000); } return 0; } void _init_Teensyduino_internal_(void) { cli(); CLKPR = 0x80; CLKPR = CPU_PRESCALER; }
jueves, 2 de enero de 2014
MyOpenLab contadores en Manjaro Linux
Xfuzzy en Manjaro un ejemplo
jueves, 26 de diciembre de 2013
Compilando en GCC una funcion creada en XFuzzy en Manjaro Linux
XFuzzy es un programa de Open Source desarrollado por el centro Nacional de microelectronica de Sevilla, España. este software permite el desarrollo de sistemas difusos, para su implementación, monitoreo, y simulación con planta, además permite la implementación de código fuente a partir del sistema propuesto
En la imagen se muestra como esta implementado un sistema difuso y su monitorización.
Para generar un fuente a partir del sistema, dar clic en Synthesis -> To C, ahora elige la carpeta donde se van a almacenar los archivos generados que tendrán el mismo nombre del sistema, por ejemplo, para este caso el sistema se denomina example.xfl y los archivos generados se llaman example.c y example.h
Dentro del archivo example.h se encuentra la función que se puede llamar desde lenguaje , esta funcion incluye el nombre del sistema difuso diseñado en XFuzzy seguido de las palabras "Inference Engine", en este caso:
Esta función tiene igual número de parámetros que entradas y salidas tiene el sistema
El código fuente se muestra en la imagen anterior, revise que la salida del sistema se almacena en la variable sal, la cual inicialmente se le asigna un valor de 0.0 por ser una variable de tipo double. notese que se usa paso por referencia.
Para compilar el programa (http://stackoverflow.com/questions/8999975/strange-behaviour-of-gcc-and-math-h) se usan algunos parámetros como son Wall y lm pque sirven para imprimir todas las advertencias que se generan (-Wall) durante la compilación del programa y -lm para el uso de la libreria math.h
En la imagen se aprecian las líneas para compilar el programa mostrado y la forma en que se ejecuta, es importante el orden de los archivos a compilar.
Para este caso se podrá notar la salida del sistema cuando las variables val1=val2 = 50.0 y val3 = 0.4 da el compilador de C un resultado de salida de 0.15 y en la imagen siguiente se muestra la salida del sistema difuso definido en XFuzzy cuando las entradas son 50.0, 50.0, 0.4
Esta portabilidad hace interesante a la herramienta, ya que es posible en cierta medida, colocar este código generado en un sistema embebido como lo es un microcontrolador.
hasta el momento les puedo comentar que en avr-gcc funciona muy bien pero con Pinguino PIC no se puede compilar a causa de que SDCC no permite el paso de estructuras como argumentos de funciones. Esto tambien lo probé al tratar de compilar en SDCC puro con el IDE PIKLAB
A fin de confirmarles el uso de la libreria generada por Xfuzzy en AVR-GCC se usa como IDE el code-blocks en su versión 12.11
y programando un ATmega32u4 (vea los siguientes links http://iemontiel.blogspot.mx/2013/05/mexican-arduino-usb-en-fedora-18.html y http://iemontiel.blogspot.mx/2013/12/teensyduino-en-manjaro.html) con cristal de 16MHz integrado en la tarjeta, es posible su compilación y el empleo de EASYDFU (como supervaca) para enviar la información al microcontrolador.
Vea que es interesante el hecho de que solamente se ocupó el 17.30% del total de la memoria del microcontrolador en cuestión.
Para generar un fuente a partir del sistema, dar clic en Synthesis -> To C, ahora elige la carpeta donde se van a almacenar los archivos generados que tendrán el mismo nombre del sistema, por ejemplo, para este caso el sistema se denomina example.xfl y los archivos generados se llaman example.c y example.h
Dentro del archivo example.h se encuentra la función que se puede llamar desde lenguaje , esta funcion incluye el nombre del sistema difuso diseñado en XFuzzy seguido de las palabras "Inference Engine", en este caso:
exampleInferenceEngine
Esta función tiene igual número de parámetros que entradas y salidas tiene el sistema
Para compilar el programa (http://stackoverflow.com/questions/8999975/strange-behaviour-of-gcc-and-math-h) se usan algunos parámetros como son Wall y lm pque sirven para imprimir todas las advertencias que se generan (-Wall) durante la compilación del programa y -lm para el uso de la libreria math.h
Para este caso se podrá notar la salida del sistema cuando las variables val1=val2 = 50.0 y val3 = 0.4 da el compilador de C un resultado de salida de 0.15 y en la imagen siguiente se muestra la salida del sistema difuso definido en XFuzzy cuando las entradas son 50.0, 50.0, 0.4
hasta el momento les puedo comentar que en avr-gcc funciona muy bien pero con Pinguino PIC no se puede compilar a causa de que SDCC no permite el paso de estructuras como argumentos de funciones. Esto tambien lo probé al tratar de compilar en SDCC puro con el IDE PIKLAB
A fin de confirmarles el uso de la libreria generada por Xfuzzy en AVR-GCC se usa como IDE el code-blocks en su versión 12.11
y programando un ATmega32u4 (vea los siguientes links http://iemontiel.blogspot.mx/2013/05/mexican-arduino-usb-en-fedora-18.html y http://iemontiel.blogspot.mx/2013/12/teensyduino-en-manjaro.html) con cristal de 16MHz integrado en la tarjeta, es posible su compilación y el empleo de EASYDFU (como supervaca) para enviar la información al microcontrolador.
martes, 17 de diciembre de 2013
Disparo de TRIAC por deteccion de cruce por cero y PWM con QUCS en Manjaro
En esta ocasión presento un circuito simulado que aprendí en la facultad, ya hace algunos ayeres para el disparo de un triac, usando la detección de cruce por cero para el disparo de un TRIAC, empleando un circuito para modular en PWM un voltaje ajustable (Vcomp en el circuito), este voltaje puede provenir de un simple pot, hasta de la salida de una DAC de un microcontrolador, debemos tomar en cuenta que hace falta un optoacoplador, pero no lo encontre en QUCS. a continuación presento el circuito:
En la gráfica se puede apreciar las partes que componen al circuito general; se coloca el diodo ya que el opamp de QUCS no permite poner fuentes, razon por la cual se tiene saturaciones en +Vcc y -Vcc lo cual es correcto si alimentamos con fuente bipolar, pero para este caso no es necesaria una señal en -Vcc, es por ello la razon del diodo
Aqui se muestran las imagenes de las gráficas resultantes de la simulación con QUCS, como verán son muy buenas estas imágenes.
domingo, 15 de diciembre de 2013
Comunicacion HID ATmega32U4 en Manjaro
En la siguiente captura de pantalla se muestra como se establece la comunicacion entre un Atmega32U4 y la caja Manjaro que tengo a 64bits.
Se usa un script de Teensy denominado HID Listen, el cual según dice en la página de Teensy, solo corre en máquinas de 32 bits, pero en la máquina que tengo que es a 64 bits corre sin ningun problema.
Los fuentes de ejemplo los he descargado de este Link, donde se pone el ejemplo que se muestra en la pantalla y se siguen las recomendaciones de esta otra página para corregir los errores LINK
En la siguiente se muestra como se compila el programa, solo con un simple comando $make
Suscribirse a:
Entradas (Atom)