Instalación de software para programar microcontroladores AVR en Manjaro Linux desde la consola

A continuación muestro en formato de video, la manera de instalar el software necesario para programar microcontroladores AVR en un ambiente Manjaro desde la terminal, cabe mencionar que esta instalación fue hecha desde una instalación limpia.

GHDL, UMHDL y Quartus en Fedora 25 y 26

Una serie de videos en relación a GHDL

Qucs 0.01.17 en Manjaro

Bien pues sigo probando el uso de Manjaro y pues de momento va muy bien, el desktop es ligero en la PC que tengo, ya es un poco viejita (Gateway con procesador Core 2 con 2GB de RAM y disco de 500GB ) Pues como les comento, estoy probando Qucs y de momento va muy bien y lo mejor es que a diferencia de Fedora 19, esta distro si me está generando el VHDL a partir del diagrama lógico sin problemas, de igual forma Scilab despueś del detalle de ayer, he instalado los atoms de Fuzzy Logic, el complemento Coselica y SIMM para simulación física, y pues las simulaciones han corrido, el problema que tengo es con el IDE de Pinguino X.4 que no me abre, pero ya veré como funciona, aun no he probado la grabación de archivos .hex con AVR y PIC, pero ya está en la pc SDCC y AVR-GCC con el codeblocks.

Creando Interfacez

Generalmente, he visto que para la creación de prototipos de interfaces hombre máquina, se usan herramientas de diseño de imagenes y/o presentaciones, pero en este caso, Fedora 18, en sus repositorios incluye a Pencil, el cual es un software para el diseño de interfaces, el cual es multiplataforma y muy agradable, pero mas que palabras, los invito a conocerlo a través del siguiente video:

http://ia700302.us.archive.org/29/items/IntroduccionAPencil/pencil.ogv

Espero les agrade.

etapa Regional de Innovación Tecnológica Tehuacan Puebla

Pues hace un buen rato que no escribo nada, y creo que tenia suficiente tiempo para hacerlo antes.

Ahora ya hay mas trabajo que antes, aunque esto, por el momento, no veo remuneración alguna, mas que la entera satisfacción, de hacer bien mi chamba.

Pues como uno de los resultados, el proyecto Gramatical, sigue adelante y ahora con un nuevo integrante, gramabot (aun está en condiciones de prototipo, pero ya está funcional)

el codigo fuente de control, está en lenguaje C, con el compiladr SDCC, programdo usando IDE beta MPLABX y libero el codigo con licencia GPL que anexo a continuación.





/**
*
Copyright (C) <2011>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
#include

#define FOSC 48000000
#include "simple_delay.h"

__code char __at __CONFIG1L CONFIG1L = _PLLDIV_DIVIDE_BY_5__20MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_96MHZ_PLL_2_1L;
//code char at __CONFIG1H CONFIG1H = _OSC_HS__USB_HS_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
__code char __at __CONFIG1H CONFIG1H = _OSC_HS__HS_PLL__USB_HS_1H & _FCMEN_ON_1H & _IESO_ON_1H;
//_FOSC_HS_1H _FOSC_HS_1H
//_OSC_HS__HS_PLL__USB_HS_1H
__code char __at __CONFIG2L CONFIG2L = _PUT_ON_2L & _BODEN_ON_2L & _BODENV_4_2V_2L & _VREGEN_ON_2L;
__code char __at __CONFIG2H CONFIG2H = _WDT_DISABLED_CONTROLLED_2H & _WDTPS_1_32768_2H;
__code char __at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _PBADEN_PORTB_4_0__CONFIGURED_AS_DIGITAL_I_O_ON_RESET_3H & _LPT1OSC_ON_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
__code char __at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
__code char __at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L & _CP_3_OFF_5L;
__code char __at __CONFIG5H CONFIG5H = _CPB_OFF_5H;
__code char __at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L & _WRT_3_OFF_6L;
__code char __at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H;
__code char __at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L & _EBTR_3_OFF_7L;
__code char __at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;

//Definiciones de servos
#define SERVO1 LATBbits.LATB0
#define SERVO2 LATBbits.LATB1
#define SERVO3 LATBbits.LATB2
#define SERVO4 LATBbits.LATB3
#define SERVO5 LATBbits.LATB4
#define SERVO6 LATBbits.LATB5
#define SERVO7 LATBbits.LATB6
#define SERVO8 LATBbits.LATB7

#define CSERVO1 TRISBbits.TRISB0
#define CSERVO2 TRISBbits.TRISB1
#define CSERVO3 TRISBbits.TRISB2
#define CSERVO4 TRISBbits.TRISB3
#define CSERVO5 TRISBbits.TRISB4
#define CSERVO6 TRISBbits.TRISB5
#define CSERVO7 TRISBbits.TRISB6
#define CSERVO8 TRISBbits.TRISB7

typedef enum{false = 0, true = 1} boolean; //para definir variables booleanas

//Constantes para la definición de ventanas
const unsigned Ticks4WindowH = 0x75;
const unsigned Ticks4WindowL = 0x2F;
const unsigned Ticks4CenterH = 0x46;
const unsigned Ticks4CenterL = 0x4F;
const unsigned Ticks4MinimumH = 0x17;
const unsigned Ticks4MinimumL = 0x6F;
const unsigned Ticks4MaximumH = 0x6B;
const unsigned Ticks4MaximumL = 0xCF;
static unsigned int Ticks4NextInterruptH = 0xCF;
static unsigned int Ticks4NextInterruptL = 0x2C;


const unsigned Ticks4Window = 0x752F;
const unsigned Ticks4Minimum = 0x176F;
const unsigned Ticks4Center = 0x464F;
const unsigned Ticks4Maximum = 0x6BCF;
static unsigned int Ticks4NextInterrupt = 0xCF2C;
static unsigned int Servo_PWM[8];
static unsigned int tempom=0x0000;
static unsigned int tempo=0x0000;
static unsigned int tempol;
static unsigned int tempoh;

static unsigned int Servo_PWMH[8];
static unsigned int Servo_PWML[8];
static unsigned short Servo_Idx = 0;

boolean SERVO1_ON = false;
boolean SERVO2_ON = false;
boolean SERVO3_ON = false;
boolean SERVO4_ON = false;
boolean SERVO5_ON = false;
boolean SERVO6_ON = false;
boolean SERVO7_ON = true;
boolean SERVO8_ON = true;


boolean flag_Phase;
unsigned short j=0xFF;
unsigned int posI;

//Prototipos
void init_board(void);
void EnableTimer1Interrupt(void);
void DiSi(void);
void DiNo(void);
void Tmr1Carga(unsigned char tempoH,unsigned char tempoL);
unsigned int SelectServo(unsigned char Servo);
void turnPlus(int vueltas, unsigned char vel, unsigned char Servo);
void turnMinus(int vueltas, unsigned char vel, unsigned char Servo);


//Sección de interrupciones
static void isr_Tmr1() __interrupt 1 //Esta es una interrupcion de alta prioridad
{
PIE1bits.RCIE=0; //deshabilitamos la interrupcion del puerto serie
if(flag_Phase == 1)
{
if(Servo_Idx == 0 && SERVO1_ON) {SERVO1 = 1;}
if(Servo_Idx == 1 && SERVO2_ON) {SERVO2 = 1;}
if(Servo_Idx == 2 && SERVO3_ON) {SERVO3 = 1;}
if(Servo_Idx == 3 && SERVO4_ON) {SERVO4 = 1;}
if(Servo_Idx == 4 && SERVO5_ON) {SERVO5 = 1;}
if(Servo_Idx == 5 && SERVO6_ON) {SERVO6 = 1;}
if(Servo_Idx == 6 && SERVO7_ON) {SERVO7 = 1;}
if(Servo_Idx == 7 && SERVO8_ON) {SERVO8 = 1;}
Ticks4NextInterruptH = 0xFF - Servo_PWMH[Servo_Idx];
Ticks4NextInterruptL = 0xFF - Servo_PWML[Servo_Idx];
Tmr1Carga(Ticks4NextInterruptH,Ticks4NextInterruptL);
}

if(flag_Phase == 0)
{
if(Servo_Idx == 0 && SERVO1_ON) {SERVO1 = 0;}
if(Servo_Idx == 1 && SERVO2_ON) {SERVO2 = 0;}
if(Servo_Idx == 2 && SERVO3_ON) {SERVO3 = 0;}
if(Servo_Idx == 3 && SERVO4_ON) {SERVO4 = 0;}
if(Servo_Idx == 4 && SERVO5_ON) {SERVO5 = 0;}
if(Servo_Idx == 5 && SERVO6_ON) {SERVO6 = 0;}
if(Servo_Idx == 6 && SERVO7_ON) {SERVO7 = 0;}
if(Servo_Idx == 7 && SERVO8_ON) {SERVO8 = 0;}
Ticks4NextInterruptH = 0xFF - Ticks4WindowH;
Ticks4NextInterruptL = 0xFF - Ticks4WindowL;

if(Ticks4NextInterruptL + Servo_PWML[Servo_Idx] > 0xFF)
{
Ticks4NextInterruptL = Ticks4NextInterruptL + Servo_PWML[Servo_Idx];
Ticks4NextInterruptH = Ticks4NextInterruptH + Servo_PWMH[Servo_Idx] + 1;
}
else
{
Ticks4NextInterruptL = Ticks4NextInterruptL + Servo_PWML[Servo_Idx];
Ticks4NextInterruptH = Ticks4NextInterruptH + Servo_PWMH[Servo_Idx];
}
Tmr1Carga(Ticks4NextInterruptH, Ticks4NextInterruptL);
if(++Servo_Idx > 7 ) Servo_Idx = 0;
}
if(++flag_Phase > 1) flag_Phase = 0;

//Esta instruccion se esta ejecutando cada 13ms con un xtal de 20MHz
//LATBbits.LATB7^=1; //complementamos el valor del bit RB7
PIR1bits.TMR1IF=0; //limpiamos la bandera de interrupcion
PIE1bits.RCIE=1; //habilitamos la interrupcion del puerto serie
}



//Funcion Principal
int main(void)
{
//declaracion de variables
int i=0;
int button_down=1;
int valTimer=0;

RCONbits.IPEN=1; //interrupciones por prioridad habilitadas

init_board();


//Centrar los servos
for (i=0;i<9;i++)
{
Servo_PWMH[i] = Ticks4CenterH;
Servo_PWML[i] = Ticks4CenterL;
}

EnableTimer1Interrupt();
tempo = Ticks4Center;
tempoh = tempo & 0xFF00;
tempol = tempo & 0x00FF;
Tmr1Carga(tempoh, tempol);
posI = Ticks4Center;




while (true)
{
//Aquí va el código para si y no
if(!PORTBbits.RB0) //Termino exitosamente la actividad
{
PORTAbits.RA4 = 0;
DiSi();
// PORTAbits.RA4 = 1;
// delay_ms(20);
// PORTAbits.RA4 = 0;
// delay_ms(20);
}
if(!PORTBbits.RB1) //esta prendido el led amarillo del semaforo
{
PORTAbits.RA4 = 0;
DiNo();
}
else
{
PORTAbits.RA4 = 1; //Mientras no pase nada prende el testigo
delay_ms(20);
PORTAbits.RA4 = 0;
delay_ms(20);
}
}
return 0;
}


void init_board(void)
{
ADCON1=0x7; // PORTA used for digital I/O
TRISAbits.TRISA4=false; // configure PORTA4 como salida TESTIGO
/*Falta configurar RA0 y RA1 como entradas*/
/* Configuramos las salidas de los servomotores*/
CSERVO1 = true;
CSERVO2 = true;
CSERVO3 = true;
CSERVO4 = true;
CSERVO5 = true;
CSERVO6 = true;
CSERVO7 = false;
CSERVO8 = false;
//configurar Entradas para GRAMAKIT
TRISBbits.TRISB0 = true;
TRISBbits.TRISB1 = true;

}

void EnableTimer1Interrupt(void)
{
T1CON=1; //Timer1 preescaler 1 interno, carga de 8 bits
PIE1bits.TMR1IE=1;
INTCONbits.PEIE=1;
INTCONbits.GIE=1;
}

void DiSi(void)
{
unsigned char posicion[] = {60,90,60,90,60,90}; //posiciones en grados a mover la cabeza para decir SI
unsigned char i, DerIzq = 1;
unsigned char vel=1; //AQUI SE DEFINE LA VELOCIDAD DEL SERVO
//si quieres ver como se puede modificar este valor por medio
//de rs232, ve el archivo timer1.c


unsigned int posF;
unsigned int vueltas;

for(i = 0;i<4;i++)
{
posI = SelectServo(6); //El servo conectado a RB6
posF = 106.66 * posicion[i] + 8399;

if(posF>posI){
vueltas = posF - posI;
vueltas = vueltas / vel;
DerIzq = 1;
}
else
{
vueltas = posI - posF;
vueltas = vueltas/ vel;
DerIzq = 0;
}

if(DerIzq)
{
turnPlus(vueltas,vel,6);
}
else
{
turnMinus(vueltas,vel,6);
}
delay_ms(10);
}
}

void DiNo(void)
{
unsigned char posicion[] = {60,120,60,90}; //posiciones en grados a mover la cabeza para decir NO
unsigned char i, DerIzq = 1;
unsigned char vel=1; //AQUI SE DEFINE LA VELOCIDAD DEL SERVO
//si quieres ver como se puede modificar este valor por medio
//de rs232, ve el archivo timer1.c


unsigned int posF;
unsigned int vueltas;

for(i = 0;i<4;i++)
{
posI = SelectServo(7); //El servo conectado a RB7
posF = 106.66 * posicion[i] + 8399;

if(posF>posI){
vueltas = posF - posI;
vueltas = vueltas / vel;
DerIzq = 1;
}
else
{
vueltas = posI - posF;
vueltas = vueltas/ vel;
DerIzq = 0;
}

if(DerIzq)
{
turnPlus(vueltas,vel,7);
}
else
{
turnMinus(vueltas,vel,7);
}
delay_ms(10);
}

}

//Funcion para cargar el timer1 con valor dado por el usuario
void Tmr1Carga(unsigned char tempoH,unsigned char tempoL)
{
TMR1H=tempoH;
TMR1L=tempoL;
}


//Función para elegir el valor de tiempo que tiene un servo

unsigned int SelectServo(unsigned char Servo)
{
tempoh = Servo_PWMH[Servo];
tempo = tempoh << 8;
return (tempo | Servo_PWML[Servo]);
}


//Funcion para dar un valor incremental a la posición de un servo determinado
void turnPlus(int vueltas, unsigned char vel, unsigned char Servo)
{
int i=0;

for(i=0;i> 8;
Servo_PWMH[Servo] = tempoh;
delay_us(100);
}
}

//Funcion para dar un valor decremental a la posicion de un servo determinado
void turnMinus(int vueltas, unsigned char vel, unsigned char Servo)
{
int i=0;

for(i=0;i> 8;
Servo_PWMH[Servo] = tempoh;
delay_us(100);
}
}

Piklab PIC18F2550 sdcc y proteus en Ubuntu 10.04

Mensaje maigke Hoy a las 5:10
Saludos amigos y compañeros del foro, esta ocasión, postearé algo que me puso a trabajar, se que hay que usar software libre, pero en ocasiones, las herramientas que tenemos, aún no están lo suficientemente maduras como para realizar ciertas simulaciones (es posible que este comentario, podría general un flame, espero que no sea el caso, gracias, no es mi intención), esto nos lleva a pasarnos al enemigo , para realizar cierto tipo de simulaciones un tanto complejas, por eso mismo, he encontrado algo muy interesante (al menos eso me parece a mi).

Programar un PIC18F2550 usando como IDE Piklab, en lenguaje C SDCC, y simular el código en Proteus, usando WineHQ, y además de eso simular paso a paso y ver el código fuente de SDCC en proteus, sin usar una máquina virtual, les dejo unas pantallas, y posteriormente subo un video con una explicacion un poco mas detallada, y las razones por las cuales estoy usando proteus.

(El codigo fuente, lo tome de uno de los temas de nuestro querido Foro, no recuerdo la liga, para enlazarlo, pero cuando la tenga, lo haré.)
Gracias



Uploaded with ImageShack.us





Uploaded with ImageShack.us

Mecanismo del Rally Mecatronico

Como parte de las actividades de final de Semestre, el M.C. J.C. Camargo encargo a los chicos de mecatronica trabajar en un prototipo electromecanico para participar en el Rally Mecatronico del ITST.

El video solo muestra uno de los tantos participantes.

Curso de PCB de fin de semana

Estos tres fines de semanas, han sido de mucha actividad, y pues dentro de tantas cosas que han sido realizadas y otras a medias, pues dimos un curso muy breve con una duración de 15hrs para los chicos de Mecatrónicas de segundo semestre sobre el como usar Kicad para el diseño de tarjetas de circuito impreso, usando la técnica de la plancha, pero sin mas palabras mejor, y aqui están las fotos

Dosificación de Materias

Para mis alumnos de Escolarizado, les presento en este apartado los links para la descarga de la dosificación del avance programático, notese que no son los avances programáticos que están abajo, sino que esta es la dosificación

Matemáticas Discretas
Análisis de Circuitos Eléctricos

Gracias!

Semana Académica 2009 invierno Mecatronica

Esta vez me toco ser jurado y no me fue posible tomar tantas fotos como hubiese querido, pero aqui están algunas

AFASA

MEMCD

Java + CCS + Proteus + servos + rs232 + compim

El siguiente post trata de como podemos programar una aplicación desarrollada en JAVA, usando la libreria RXTX para comunicarse con un microcontrolador PIC16F877 simulado en proteus a través de componente COMPIM, para controlar posiciones simples de 3 servomotores. El desarrollo es interesante, ya que además no necesitas nada de hardware con estas herramientas para hacer las pruebas. El código de la comunicación se basa en la de que se muestra en picmania de RedPic.
Cabe mencionar que el desarrollo de este pequeño proyecto fué desarrollado por mis alumnos Ismael Pérez Amaro, Alejandra Karina Rojas Guzmán y Magdalena López Tiburcio de la carrera de Ing. en Sistemas Computacionales que cursan el 7to. Semestre en el ITST. a continuación coloco el texto e imagenes que me hicieron favor de redactar, así como los links de descarga.
************************************************************************************


http://www.scribd.com/doc/22497242/InterfazSerialJAVAPROTEUS

InterfazSerialJAVAPROTEUS

stands-Quehacer Académico 2007

stands-Quehacer Académico 2007 por maigke