Control de Servomotores con SDCC- Original de RedPIC Parte 4

Control de Servomotores con SDCC- Original de RedPIC Parte 3

Control de Servomotores con SDCC- Original de RedPIC Parte 2

Bueno después de mucho trabajar, por fin creo que ya funca esta versión del programa realizado por Redpic, pero en SDCC, como características tiene las siguientes:

* Comunicación por el puerto RS232 a 57600bps, pero puede aumentarse a 115200bps
* La forma de control de los servos es secuencial, lo que no permite mover dos servos de forma simultánea.
* El formato de instrucción es [servo][valor en grados][velocidad]
-Para servo usamos un byte char [a|b|c|d|e|f]
-Para valor en grados usamos tres bytes ejemplos [090] [001] [175] 90°, 1°, y 175° respectivamente
* Envia códigos de error cuando son suministrados los datos por el puerto serial
Códigos de mensajes de error
0 -- Buffer lleno Se han enviado demasiados caracteres
1 -- turnPLus error no puedo mover servo seleccionado
2 -- turnMinus error no puedo mover servo seleccionado
3 -- commandProcess error o puedo elegir ese servo

Cuando el proceso termina satisfactoriamente se manda la cadena "ok"

Para definir los servos a mover, usamos las siguientes macros definidas al inicio del código

//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

Una característica mas, es que no es necesario usar los 8 pines como salida, sino que podemos elegir mediante el "bit"
boolean SERVO1_ON = true;
boolean SERVO2_ON = true;
boolean SERVO3_ON = true;
boolean SERVO4_ON = true;
boolean SERVO5_ON = true;
boolean SERVO6_ON = true;
boolean SERVO7_ON = true;
boolean SERVO8_ON = true;

Si necesitamos usar dos servos, un servo o los 8, como gustes Very Happy, (Esto tambien es original del código de RedPIC)


/* ----------------------------------------------------------------------- */

/* Plantilla generada por Piklab */

/*

La configuracion del micro nos permite trabajar un con XT de 20MHZ

y pero usar el PLL con el propósito de alcanzar los 12MIPS



Códigos de mensajes de error

0 -- Buffer lleno  Se han enviado demasiados caracteres

1 -- turnPLus error  no puedo mover servo seleccionado

2 -- turnMinus error no puedo mover servo seleccionado

3 -- commandProcess error o puedo elegir ese servo



ok -- Proceso terminado correctamente

*/

#include <pic18f2550.h>

#include <delay.h>

#include <uart18f2550.c>

#include <stdlib.h>

#include <string.h>

/* ----------------------------------------------------------------------- */

/* Bits de configuración: adapte los parámetros a su necesidad */

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__HS_PLL__USB_HS_1H & _FCMEN_ON_1H & _IESO_ON_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_OFF_RE3_ON_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



//boolean tuza = true;  este es solo un ejemplo

//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 = true;

boolean SERVO2_ON = true;

boolean SERVO3_ON = true;

boolean SERVO4_ON = true;

boolean SERVO5_ON = true;

boolean SERVO6_ON = true;

boolean SERVO7_ON = true;

boolean SERVO8_ON = true;



//definicion de teclas

#define INTRO 0x0D

#define RETROCESO 0x08

#define ESCAPE 0x1B



boolean flag_Phase;

unsigned short j=0xFF;

unsigned int posI;



/*Seccion para la comunicacion en serial*/



#define  lenbuff 10



unsigned char xbuff=0x00;

unsigned char cbuff[lenbuff];

char rcvchar=0x00;

boolean flagcommand = false;



//variables para timers

   unsigned char CounterA;

   unsigned char CounterB;



//Prototipos

void init_board(void);

void EnableTimer1Interrupt(void);

void Tmr1Carga(unsigned char high, unsigned char low);

void initBuff(void);

void add2cbuff(unsigned char c);

void echosel(char c);

void command_process(void);

void delay_ms(int milis);

void delay_us(int milis);

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

}





static void isr_Serial() interrupt 2  //Esta es una interrupcion de baja prioridad

{

   PIR1bits.RCIF=0;

   rcvchar=RCREG;

   add2cbuff(rcvchar);

   echosel(rcvchar);

}



//Funcion Principal

void main() {

//declaracion de variables

int i=0;

int button_down=1;

int valTimer=0;



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

init_board();

Print_str("Dispositivo inicializado");

Printf(INTRO);

Print_str("PIC18F2550 en SDCC");

Printf(INTRO);

delay_ms(500); //tiempo de espera

initBuff();



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)

{

   if(flagcommand)  //si ya presionaste enter

   {

   command_process();

   }

}

}



void init_board(void) {

   flagcommand= false;

ADCON1=0x7; // PORTA used for digital I/O

TRISAbits.TRISA4=true; // configure PORTA4 for input (pushbutton)



/* Configuramos las salidas de los servomotores*/

CSERVO1 = false;

CSERVO2 = false;

CSERVO3 = false;

CSERVO4 = false;

CSERVO5 = false;

CSERVO6 = false;

CSERVO7 = false;

CSERVO8 = false;



//Configuramos la comunicacion serial --rutina de jean Pierre Mandon

setup_UART(B57600);

}



void EnableTimer1Interrupt(void)

{

   T1CON=1;        //Timer1 preescaler 1 interno, carga de 8 bits

   PIE1bits.TMR1IE=1;

   INTCONbits.PEIE=1;

   INTCONbits.GIE=1;

}



void Tmr1Carga(unsigned char high, unsigned char low)

{

   TMR1H=high;

   TMR1L=low;

}

      

//Funcion de vaciado del buffer

void initBuff(void){

   int i;

   for (i=0; i< lenbuff;i++){

      cbuff[i]=0x0;

   }xbuff=0x00;

}



//agrega un caracter mas al buffer, o realiza un acción

void add2cbuff(unsigned char c)

{

   if(xbuff<lenbuff){  //Añade caracteres al buffer mientras no se llene el buffer

      switch(c){

         case INTRO: //Enter  --> Habilita flag para procesar comando

            flagcommand=true;

            break;

         case RETROCESO: //BackSpace --> Borra del buffer el ultimo caracter insertado

            if(xbuff>0) cbuff[--xbuff]=0x00;

            break;

         case ESCAPE: //ESC  --> Borra todo el buffer

            initBuff();

            break;

         default:  //añade caracter al buffer recibido

            cbuff[xbuff++]=c;

      }

   }

   else{

      initBuff();//Si el buffer esta lleno, vacialo

      Print_str("0");  //Envia mensaje de que el buffer esta lleno Error 0

      Printf(INTRO);

   }

}



//Solo imprime los caracteres imprimibles

void echosel(char c)

{

   switch(c){

      case 0x0D: //Si presionamos la tecla intro

             Printf(INTRO);

         break;

      case 0x08: //Si presionamos la tecla BackSpace

         Printf(RETROCESO);

         break;

      case 0x1B: //Si presionamos la tecla ESC

         Printf(ESCAPE);

         break;

      default:

         Printf(c); //Echo de cualquier otro caracter

   }

}



/*

El formato de los comandos es el siguiente:

[a...f] [123] [xx]

servo posicion velocidad

primer byte un caracter alfabético de entre a y e que define al servo

tres bytes para definir la posicion del servo

dos bytes para definir la velocidad de movimiento del servo

a12301 {enter}

mueve el servo 1 a 123 grados de la posicion de origen a la velocidad 01

*/

void command_process()

{

   int i=0;

   char DerIzq= 1; //bandera para saber si va a 180 o a 0 grados

  // DerIzq = 1  Indicará que vamos de 0 a 180 por tanto suma

  // DerIzq = 0  Indicará que vamos de 180 a 0 por tanto resta

   unsigned char cmd[lenbuff]; //comando tecleado

   unsigned char servo[2];

   unsigned char pos[4];  //para almacenar las posiciones

   unsigned char posicion;

   unsigned char velocidad[4];  //para almacenar los incrementos

   unsigned char vel;

  

   unsigned int posF;  //Es posible que estos valores los tengas que dividir

   unsigned int vueltas;

  

  

   flagcommand=false;

   //Recibe el nombre del servo a mover

   strcpy(cmd,cbuff);

   strncpy(servo,cmd,1);

   //guarda la posicion del servo

   strcpy(cmd,cbuff);

   for(i=1;i<4;i++){

      pos[i-1]= cmd[i];

   }

   posicion = atoi(pos);

   //guarda la velocidad a la que se moverá el servo

   strcpy(cmd,cbuff);

   for(i=4;i<7;i++)

   {

      velocidad[i-4]=cmd[i];

   }

   vel = atoi(velocidad);

   tempo = 0;

   tempoh=0;

   tempol=0;

   switch(servo[0]){

      case 'a':

         posI=SelectServo(0);

         break;

      case 'b':

         posI=SelectServo(1);

         break;

      case 'c':

         posI=SelectServo(2);

         break;

      case 'd':

         posI=SelectServo(3);

         break;

      case 'e':

         posI=SelectServo(4);

         break;

      case 'f':

         posI=SelectServo(5);

         break;

      default:

         Print_str("3"); //Error 3 opcion elegida no válida

         Printf(INTRO);

         break;

   }

   posF= 106.66 * posicion + 8399;



  

   if(posF>posI){

      vueltas = posF - posI;

      vueltas = vueltas / vel;

      DerIzq = 1;

   }

   else

   {

      vueltas = posI - posF;

      vueltas = vueltas/ vel;

      DerIzq = 0;

   }

  

   /********************************************************/

   /*

   Debe de leerse el valor que tiene del servo desde el array

   Žpara determinar el valor inicial y no unicamente dejarlo

   como valor final. esto causa el eeror de que al mover

   multiples motores con una unica variable se moveran en conse-

   cuencia del anterior

   */

  // posI = posF;  Esto no es correcto



   if(DerIzq)

   {

      switch(servo[0])

      {

         case 'a':  //mueve al servo uno en incrementos de vel hasta llegar a vueltas

            turnPlus(vueltas, vel, 0);

               break;

         case 'b':  //mueve al servo dos en incrementos de vel hasta llegar a vueltas

            turnPlus(vueltas, vel, 1);

               break;

         case 'c':



            

            turnPlus(vueltas, vel, 2);

               break;

         case 'd':



            turnPlus(vueltas, vel, 3);

               break;

         case 'e':



            turnPlus(vueltas, vel, 4);

               break;

         default:

            Print_str("1"); Printf(INTRO); //Error 1 turnPlusError

      }

   }

   else{

      switch(servo[0])

      {

         case 'a':  //mueve al servo uno en incrementos de vel hasta llegar a vueltas

            turnMinus(vueltas,vel,0);



               break;

         case 'b':  //mueve al servo dos en incrementos de vel hasta llegar a vueltas

            turnMinus(vueltas,vel,1);

               break;

         case 'c':

            turnMinus(vueltas,vel,2);

               break;

         case 'd':

            turnMinus(vueltas,vel,3);

               break;

         case 'e':

            turnMinus(vueltas,vel,4);

               break;

         default:

            Print_str("2");Printf(INTRO); // error 2 turnMinus Error

      }

   }

   initBuff();

   Print_str("ok");Printf(INTRO);

}

      

void delay_ms(int milis){

delay1ktcy(10*milis);



}



void delay_us(int milis){

delay10tcy(1*milis);

}



unsigned int SelectServo(unsigned char Servo)

{

         tempoh = Servo_PWMH[Servo];

         tempo = tempoh << 8;

         return (tempo | Servo_PWML[Servo]);

}



void turnPlus(int vueltas, unsigned char vel, unsigned char Servo)

{

int i=0;



for(i=0;i<vueltas;i++)

            {

               tempoh = Servo_PWMH[Servo];

               tempoh = tempoh << 8;

               tempo  = tempoh | Servo_PWML[Servo];

               tempo += vel;

               Servo_PWML[Servo] = tempo & 0x00FF;

               tempoh = tempo & 0xFF00;

               tempoh = tempoh >> 8;

               Servo_PWMH[Servo] = tempoh;

               delay_us(100);

            }

}



void turnMinus(int vueltas, unsigned char vel, unsigned char Servo)

{

int i=0;



for(i=0;i<vueltas;i++)

            {

               tempoh = Servo_PWMH[Servo];

               tempoh = tempoh << 8;

               tempo  = tempoh | Servo_PWML[Servo];

               tempo -= vel;

               Servo_PWML[Servo] = tempo & 0x00FF;

               tempoh = tempo & 0xFF00;

               tempoh = tempoh >> 8;

               Servo_PWMH[Servo] = tempoh;

               delay_us(100);

            }

}




Control de Servomotores con SDCC- Original de RedPIC Parte 1

Control de 8 servos de RC por puerto serie -- Original de RedPIC traducido a SDCC

Mensaje maigke el Vie 17 Sep 2010 - 9:32
Buenas noches a todos (Aquí en Mx es de madrugada)

Bien en esta ocasion les presento un codigo que es original de RedPIc, y que gracias a la lógica que el presenta en su sitio, he aprendido bastante. Pues bien, aqui esta el código que el nos presenta para controlar 8 servomotores con una sola interrupcion del timer1 a 16 bits, pero con las siguientes modificaciones:

-- El pic es un 18F2550
-- El lenguaje claro que es SDCC y pues así lo hace libre esto.
-- El oscilador es a 20MHz, pero basado en el proyecto Pinguino se establece que el micro trabaje a 12MIPS.
-- Tome algunos ejemplos de como trabaja el proyecto Pinguino de Jean - Pierre Mandon.
-- Aun el micro no entiende lo que le mandes por el puerto paralelo serial (andaba medio dormido). cyclops pero ya mero

sin mas preambulos, les muestro el código, que digamoslo así, es casí una copia fiel, pero con sus bueno retoques, algo importante, no se la causa del por que el SDCC no trabaja bien con las operaciones de 16bits, así que tuve que hacer algunos ajustes, así que tuve que gastar aun mas recursos de los que ya de por si SDCC requiere. posterior les presento algunas pantallas.

Espero sus notas y comentarios:, por cierto este post, se puede ligar al de GAMBAS + pic16f628 + puerto serial. Wink


/* ----------------------------------------------------------------------- */

/* Plantilla generada por Piklab */

/*

La configuracion del micro nos permite trabajar un con XT de 20MHZ

y pero usar el PLL con el propósito de alcanzar los 12MIPS

*/

#include <pic18f2550.h>

#include <delay.h>

#include <uart18f2550.c>

/* ----------------------------------------------------------------------- */

/* Bits de configuración: adapte los parámetros a su necesidad */

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__HS_PLL__USB_HS_1H & _FCMEN_ON_1H & _IESO_ON_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_OFF_RE3_ON_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;



//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;



static unsigned short Servo_PWMH[8];

static unsigned short Servo_PWML[8];

static unsigned short Servo_Idx = 0;



#define SERVO1_ON true

#define SERVO2_ON false

#define SERVO3_ON false

#define SERVO4_ON false

#define SERVO5_ON false

#define SERVO6_ON false

#define SERVO7_ON false

#define SERVO8_ON false



//definicion de teclas

#define INTRO 0x0D

#define RETROCESO 0x08

#define ESCAPE 0x1B



unsigned short flag_Phase;

unsigned short j=0xFF;



/*Seccion para la comunicacion en serial*/



#define  lenbuff 10



unsigned char xbuff=0x00;

unsigned char cbuff[lenbuff];

char rcvchar=0x00;

unsigned char flagcommand = 0;





//Prototipos

void init_board(void);

void EnableTimer1Interrupt();

void Tmr1Carga(unsigned char high, unsigned char low);

void delay_ms(int milis);

void delay_us(int milis);





//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

//   RB7^=1;  <- dice que no se puede así

    PIR1bits.TMR1IF=0; //limpiamos la bandera de interrupcion

    PIE1bits.RCIE=1;  //habilitamos la interrupcion del puerto serie

    //Carga el timer para 1ms

    //Tmr1Carga(0xD1,0x1F);    //TMR1 = FFFF - FF00

}





static void isr_Serial() interrupt 2  //Esta es una interrupcion de baja prioridad

{

   PIR1bits.RCIF=0;

   rcvchar=RCREG;

   Printf(rcvchar);

}



//Funcion Principal

void main() {

//declaracion de variables

int i=0;

int button_down=1;

int valTimer=0;



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



init_board();

Print_str("Dispositivo inicializado");

Printf(INTRO);

Print_str("PIC18F2550 en SDCC");

Printf(INTRO);





for (i=0;i<9;i++)

{

   Servo_PWMH[i] = Ticks4MaximumH;

   Servo_PWML[i] = Ticks4MaximumL;

}

EnableTimer1Interrupt();

while (true)

{

}

}



void init_board(void) {

ADCON1=0x7; // PORTA used for digital I/O

TRISAbits.TRISA4=true; // configure PORTA4 for input (pushbutton)



/* Configuramos las salidas de los servomotores*/

CSERVO1 = false;

CSERVO2 = false;

CSERVO3 = false;

CSERVO4 = false;

CSERVO5 = false;

CSERVO6 = false;

CSERVO7 = false;

CSERVO8 = false;



//Configuramos la comunicacion serial --rutina de jean Pierre Mandon

setup_UART(B57600);

}



void EnableTimer1Interrupt()

{

   TMR1H=0xFF;

   TMR1L=0x00;    //TMR1 = FFFF - FF00

   T1CON=1;        //Timer1 preescaler 1 interno, carga de 8 bits

   PIE1bits.TMR1IE=1;

   INTCONbits.PEIE=1;

   INTCONbits.GIE=1;

}



void Tmr1Carga(unsigned char high, unsigned char low)

{

   TMR1H=high;

   TMR1L=low;

}

      

void delay_ms(int milis){

delay1ktcy(5*milis);

}



void delay_us(int milis){

delay10tcy(1*milis);

}


Y esta es la rutina de comunicacion serial de Jean Pierre que use

// UART Library for PIC 18F2550
// SDCC version / small device c compiler
// written by Jean-Pierre MANDON 2008 jp.mandon@free.fr
// www.pictec.org
/*
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 2, 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, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding!
*/
// this program is intended for an oscillator frequency of 20 Mhz


// SPBRG value for FOSC 20 Mhz

#define B300 1,0,0x27,0x0F
#define B1200 1,0,0x09,0xC3
#define B2400 1,0,0x04,0xE1
#define B4800 1,0,0x02,0x70
#define B9600 0,0,0x00,0x4D
#define B19200 0,0,0x00,0x26
#define B57600 1,1,0x00,0xCF
#define B115200 1,1,0x00,0x67

// local definition UART.C

#define BUFFER 128 // rx buffer length
char rx[BUFFER]; // this is the buffer
unsigned char wpointer,rpointer; // write and read pointer

#define charreceived (wpointer!=rpointer)
#define SERIAL

typedef struct
{
unsigned int
hhigh4:4,
hlow4:4,
lhigh4:4,
llow4:4;
} bitfield;

// setup PIC UART

void setup_UART(unsigned char brg16,unsigned char brgh,unsigned char highbyte,unsigned char lowbyte)
{
TXSTAbits.BRGH=brgh&1; // set BRGH bit
BAUDCONbits.BRG16=brg16&1; // set 16 bits SPBRG
SPBRGH=highbyte; // set UART speed SPBRGH
SPBRG=lowbyte; // set UART speed SPBRGL
RCSTA=0x90; // set RCEN and SPEN
BAUDCONbits.RCIDL=1; // set receive active
PIE1bits.RCIE=1; // enable interrupt on RX
INTCONbits.PEIE=1; // enable peripheral interrupts
IPR1bits.RCIP=0; // define low priority for RX interrupt
wpointer=1; // initialize write pointer
rpointer=1; // initialize read pointer
TXSTAbits.TXEN=1; // enable TX
INTCONbits.GIE=1;
}

// UART write char

void Printf(unsigned char caractere)
{
while (!TXSTAbits.TRMT);
TXREG=caractere; // yes, send char
}

// rxint is called by interruption service routine

void rxint(void)
{
char caractere;
unsigned char newwp;

PIR1bits.RCIF=0; // clear RX interrupt flag
caractere=RCREG; // take received char
if (wpointer!=BUFFER-1) // if not last place in buffer
newwp=wpointer+1; // place=place+1
else
newwp=1; // else place=1

if (rpointer!=newwp) // if read pointer!=write pointer
rx[wpointer++]=caractere; // store received char

if (wpointer==BUFFER) // if write pointer=length buffer
wpointer=1; // write pointer = 1
}


// get char

unsigned char getch()
{
unsigned char caractere=0;

if (charreceived)
{
caractere=rx[rpointer++];
if (rpointer==BUFFER)
rpointer=1;
}
return(caractere);
}

// clear rx buffer

void clear_buffer(void) {
wpointer=1;
rpointer=1;
}

// write a string on the UART

void Print_str(const char* text)
{
unsigned char i=0;
while ( text[i] != 0 )
Printf( text[i++] );
}

// convert 16 bits binary value to DEC and send it on the UART

void Print_dec(unsigned int valeur)
{
unsigned char result;
unsigned char zero=1;


result=valeur/10000;
if (result!=0) {
Printf(result+0x30);
zero=0;
}
valeur=valeur%10000;
result=valeur/1000;
if (result!=0) {
Printf(result+0x30);
zero=0;
}
else if (zero==0) Printf('0');
valeur=valeur%1000;
result=valeur/100;
if (result!=0) {
Printf(result+0x30);
zero=0;
}
else if (zero==0) Printf('0');
valeur=valeur%100;
result=valeur/10;
if (result!=0) {
Printf(result+0x30);
zero=0;
}
else if (zero==0) Printf('0');
result=valeur%10;
Printf(result+0x30);
}

// convert 16 bits binary value to HEX and send it on the UART

void Print_hex(unsigned int valeur)
{
const char hexa[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

Printf(hexa[(valeur>>12)&0x000F]);
Printf(hexa[(valeur>>8)&0x000F]);
Printf(hexa[(valeur>>4)&0x000F]);
Printf(hexa[valeur&0x000F]);
}

// convert 16 bits binary value to byte and send it on the UART

void Print_byte(unsigned int valeur)
{
unsigned int result;
result=valeur;
Printf(result);
}

Referencias


http://picmania.garcia-cuervo.net/picc.php#COMBUF232
http://picmania.garcia-cuervo.net/picc_servos_x_8.php
http://sdcc.sourceforge.net/doc/sdccman.pdf
http://pinguino.walii.es/archives/161
http://karoshi.auic.es/index.php?topic=1689.0
http://jpmandon.blogspot.com/

Primer concurso de proyectos con Pinguino

Gracias al OpenSourceHardware el proyecto Pinguino (Arduino-Like) basado inicialmente en microcontrolador PIC18F2550 de Microchip, el Primer concurso de proyectos basados en Pinguino, esta realizandose para participantes de habla inglesa y española.

Los premios son buenos!, y pues el objetivo inicial es darle una mayor difusión a Pinguino de Jean Pierre Mandon.
El link para ver las bases y premios es aqui

Un poco radical, pero que razon tiene

Estoy escribiendo un poco debido a que tanta lectura ya me dio dolor de cabeza, y como debo continuar con buen animo en mi trabajo, pues me puse a leer unas notas en internet.

Le sugiero la lectura que esta colocada en el Blog Fresno Libre, propiedad de un colaborador de las Listas de usuarios Debian.

http://fresnolibre.fresnodigital.info/?p=267

La carta expone algunos puntos sobre un usuario OOo, aunque yo creo que debido a la compra de Sun par parte de Oracle, deberiamos usar LibreOffice en lugar de OpenOffice, pero ya es cuestion de gustos.

Saludos

pense que esto solo pasaria en el DF y con gusto leo que no

Lyendo la lista de correos GNU Linux, a la que estoy suscrito, el Dr. Ing. Gengis Toledo envia una nota del diario el informador sobre la propuesta de un legislador para el uso del software libre para la administración publica del Estado de Jalisco, leo con agrado que poco a poco en nuestro País, las apuestas por el SL se hagan cada vez mas importantes.

Para leer la nota copia este link

http://www.informador.com.mx/jalisco/2010/251270/6/propone-raul-vargas-internet-gratuito.htm

Nota.- No coloco un hipervinculo ya que se puede prestar a malas interpretaciones de pishing, mejor copia y pega la dirección en tu navegador.

Saludos

Escribiendo

Hace un bue rato que nada habia escrito, y no es por falta de que escribir, sino mas bien es por falta de tiempo.

Pronto publicaré parte del trabajo que estoy elaborando y espero les agrade.

Saludos

Elementos Proyecto Investigacion

Esta muy buena esta presentación, muy recomendable echarle un ojo

Elementos Proyecto Investigacion

View more presentations from Euler.

WHY DO OPEN HARDWARE? - Limor Fried @ Open Hardware Summit

LibreOffice

Bien, pues como me lo suponia, parece que el proyecto OOo no va muy bien ya en manos de Oracle, puesto que ya muchos de los desarrolladores del original OOo, han salido del sitio, y ahora han fundado la http://www.documentfoundation.org/ y ahí encontraremos una version totalmente libre del OOo, cabe señalar que el conjunto de extensiones que recomiendan instalar para LibreOffice es un poco reducido http://libreplanet.org/wiki/Group:OpenOfficeExtensions/List, pero habrá que probar.

En mi caso espero que tenga una buena compatibilidad con el software Zotero, para seguir con mi trabajo. :D

Revision de lista de Alumnos en Plataforma

Buenas tardes jóvenes de Ing en Sistemas

Los siguientes, son los alumnos que han entrado a la plataforma

Barrientos Saavedra
García Casiano
Ramirez Luna
Sanchez Ramirez
Marquez Bonilla
Castillo Cosme
Valerio Romero
Mendez Melgarejo
Jimenez Secundino
García Romero
Reyes Hernandez

leyendo dos entradas y encendiendo dos leds

Este código les sirve para la practica del motor: saludos

*NOTA: En este caso puse el bit MCLR en ON, por lo que si quieren simular este código, pongan en estado alto el pin 4 del micro. si no quieres colocarlo, pon este "fuse" en OFF
/* ----------------------------------------------------------------------- */
/* Plantilla generada por Piklab */
#include <"\<">pic16f819.h<"\>">

/* ----------------------------------------------------------------------- */
/* Bits de configuración: adapte los parámetros a su necesidad */
typedef unsigned int word;
word at 0x2007 CONFIG = _WDT_OFF & _PWRTE_ON & _INTRC_IO & _MCLR_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_ENABLE_OFF & _DEBUG_OFF & _CCP1_RB2 & _CP_OFF;


void pausa(unsigned int tiempo);

void main() {
//Configurando el puerto A como digital
ADCON1=0x06;


TRISA0=1;
TRISA1=1;
TRISB0=0;
TRISB3=0;
TRISB4=0;
RB0=1;
RB3=1;
pausa(3);
while(1)
{
pausa(1);
RB4=0;
if(RA0==0)
{
RB0=1;
RB3=0;
}
if(RA1==0)
{
RB3=1;
RB0=0;
}
if(RA0 == 0 & RA1 == 0)
{
RB0=0;
RB3=0;
}
pausa(1);
RB4=1;
}

}

void pausa(unsigned int tiempo)
{
unsigned char i;
unsigned char j;
int temp=0;

for(i=0;i {
for(j=0;j<0xFF;j++)
{
tiempo=+1;
}
}
}

Saludos

Formato de los Archivos enviados

Buen día jóvenes, este pequeño post es para comunicarles y recordarles, que por favor envien sus archivos en formato PDF, ya que al enviarlos en formato de MS Office, se pierden muchas características propias de los documentos que ustedes editan, ya que, yo los abro con OOo.

Se que es elección suya usar MSOffice, pero por cuestiones de compatibilidad, le solicito que me envien sus archivos en formato PDF. Así nos evitamos problemas de forma, con lo que respecta a sus trabajos.

Por razones personales, dudo mucho instalar MSOffice en mi sistema GNU/Linux, así que no me pidan que haga tal cuestion.

Por su amable atención, gracias

Problemas con la plataforma

Saludos jóvenes

Pues bien, creo que hubo suficientes problemas para acceder a la plataforma, como lo leí en el mail. no se preocupen, en todo caso, realizaremos la autoevaluación en el día miércoles, permitanme ver con Centro de Cómputo la fecha de funcionamiento de la plataforma Moodle.

Gracias y que tengan buen día

Ya esta corriendo el tiempo

Saludos, el tiempo para que termine su acceso a la autoevaluacion ya esta corriendo, de momento, el único que esta dado de alta es Gamaliel.

Cualquier duda espero su email.

Función de Retardo en sdcc

Saludos aqui les dejo el código para generar un retardo en SDCC, para el PIC16F819

/* ----------------------------------------------------------------------- */
/* Plantilla generada por Piklab */
#include

/* ----------------------------------------------------------------------- */
/* Bits de configuración: adapte los parámetros a su necesidad */
typedef unsigned int word;
word at 0x2007 CONFIG = _WDT_OFF & _PWRTE_ON & _INTRC_IO & _MCLR_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_ENABLE_OFF & _DEBUG_OFF & _CCP1_RB2 & _CP_OFF;


void pausa(unsigned int tiempo);

void main() {

pausa(1000);

}

void pausa(unsigned int tiempo)
{
unsigned char i;
unsigned char j;
int temp=0;

for(i=0;i {
for(j=0;j<0x8000;j++)
{
tiempo=+1;
}
}
}

Por favor, contesta la encuesta

Saludos y bienvenidos todos

Hace un rato que no escribo nada, pero aquí andamos de nuevo. bueno pues te pido, amigo visitante, que nos puedas contestar la encuesta que se encuentra en la barra lateral, espero te sea cómoda, y si hay alguna observación, házmela saber, te lo agradecería.

Calendario de Practicas esta arriba

Saludos a todos, dejo en la parte lateral el calendario de prácticas y actividades varias, para que vayan tomando previsiones y no les tome el tiempo por sorpresa.

Muchas gracias y saludos

Control motor PaP Bipolar con CCS e "interrupcion" por USART programado en Linux

Como es sabido el uC PIC16F84A no cuenta con USART, sin embargo para controlar un motor de pasos bipolar en posición bidireccional, podemos usar un pequeño artilugio para hacer responder a una interrupcion al PIC, usando el protocolo rs232

bueno el codigo fuente es el siguiente

#include <16F84a.h>

#fuses XT,NOWDT

#use delay (clock=4000000)

//#use fixed_io(b_outputs=pin_b3)

//#use fixed_io(a_outputs=pin_a0,pin_a1,pin_a2,pin_a3)



#use rs232(xmit=PIN_B3,rcv=PIN_A4,bits=8)



//variables globales

int1 flagA=FALSE, flagB=FALSE;

int value=50;

//Interrupciones

#INT_EXT

void int_rb0(void){

char letra;

disable_interrupts(GLOBAL);

delay_ms(10);

letra=getc();

letra= toupper(letra);

switch(letra){

case 'D':printf("Derecha\r\n");

flagA=TRUE;

flagB=FALSE;

break;

case 'I':printf("Izquierda\r\n");

flagA=FALSE;

flagB=TRUE;

break;

}

enable_interrupts(GLOBAL);

}



//prototipos

void adelante(void);

void atras(void);







main(){

enable_interrupts(GLOBAL);

ext_int_edge(L_TO_H); //interrupcion en flanco de bajada

enable_interrupts(int_ext); //habilitada interrupcion Externa RB0

printf("Control de\n\r Motor de pasos Bipolar");

while(1){

if(flagA==TRUE)

adelante();

if(flagB==TRUE)

atras();

};

return 0;

}



void adelante(void){





Output_A(input_A()|0x05);

delay_ms(value);

Output_A(input_A()|0x06);

delay_ms(value);

Output_A(input_A()|0x0A);

delay_ms(value);

Output_A(input_A()|0x09);

delay_ms(value);

}





void atras(void){

Output_A(input_A()|0x09);

delay_ms(value);

Output_A(input_A()|0x0A);

delay_ms(value);

Output_A(input_A()|0x06);

delay_ms(value);

Output_A(input_A()|0x05);

delay_ms(value);

}


Aqui el circuito

Zinjal y PSeInt interesante

Saludos a todos, esta ocasion presento a ustedes algo que me encontre en la red, buscando informacion sobre, si existía, un software que pudiera ser capaz de hacer el diagrama de flujo a partir de el codigo fuente, y pues fui a dar con estos dos proyectos de la Universidad Nacional del Litoral en Santa Fe, Argentina, los cuales se me hacen muy interesantes, ya que PSeInt, es un programa que ayuda a los iniciados en programación, específicamente en algoritmia, y el segundo Zinjal es un IDE para lenguaje C/C++ que al igual que el primer proyecto pueden generar diagramas de Flujo a partir de fuente, lo que te da una mejor panorámica, en mi caso, he probado Zinjal usando codigo para CCS y pues si funciona muy bien, aun me falta probar con SDCC y con pic-gcc, pero supongo que no hay ningun problema.

Les dejo los links de las páginas de los autores:
http://zinjai.sourceforge.net/
http://pseint.sourceforge.net/

impresora xerox phaser 3117 en slackware

Bien, hasta ahora Slackware 13.1 me ha funcionado muy bien como maquina de escritorio, por el momento tuve un problema al instalar la impresora Xerox Phaser 3117, incluso baje el driver del fabricante pero no funciono, debido a la version del cups, pero eso, no fue problema, ya que buscando en la red una solucion para Ubuntu, me funciono muy bien en Slackware, y es la de instalar el driver para una impresora Samsumg. El vinculo al hilo es el siguiente
http://ubuntuforums.org/showthread.php?t=206009
Ya que estas ahi, solo baja el driver, descomprime con
tar zxvf Samsumg---XXXX.gz entra al menu System (XFCE) -- Impresoras, dar de alta una nueva impresora --- password de root --- dar clic en la impresora detectada ---- Seleccionar la opcion "Provide PPD file --- examinar --- ir a la carpeta donde descomprimiste el archivo -- aceptar -- imprimir la `pagina de prueba.

Bueno a grosso modo estos son los pasos para dejar funcionando esta impresora en Slackware 13.1

Video PIklab, SDCC, Proteus en Ubuntu con PIC18F2550

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

Slackware 13.1 en MS9327E

Hace rato que no escribo nada, pero ando haciendo pruebas con slackware 13.1 que acabo de bajar este fin de semana, y realice la instalción en una PIV a 1.6GHZ sobre una mother MS9327E con 512MB de RAM, disco duro de 20GB, y tarjeta de video S3 Trio 64V2/DX y una tarjeta de red inalambrica, encore enpwi-g2, esta ultima no funciona ni puedo compilar hasta este momento ndiswrapper, ni aun usando los scrips bajados de SlackBuilds.org, pero no desistiré y pronto los daré noticias

Con respecto a la instalacion, la hice en modo full, con xfce4 como gestor de ventanas (muy rapido!), hubo que modificar el fstab, ya que no lee de inicio los cd's, pero no hay problema con las memorias usb que tengo, aun no conecto el celular ^_^.

El sonido trabaja muy bien, solo hay que habilitar el audio desde la BIOS de la mother. y al entrar en modo consola teclear

#alsaconf

reconoce el audio! y bueno me puse a escuchar musica de Oasis! ^_^!
lo malo que aun no la puedo conectar a internet, pero a ver si en estos dias
tiene instalado el jdk 1.6_20 + netbeans 6.9 + rxtx y funciona muy bien.

Hice tambien las pruebas con kde4, y pues jala!, al menos no se arrastra!

El por que busque instalar slackware?

Es facil, por que ningun otro linux trabajo bien en esta mother. entre las distros que probe para esta maquina

Ubuntu 7.04 .--- Solo Video
Xubuntu 10.04 ---- No video
Lubuntu 10.04 ---- No video
Debian 5 ---- AL iniciar el instalador se muere
Mandriva 2008 Spring One --- Al iniciar el disco se muere
Slax --- No arranca
Beatrix Linux --- Trabaja muy bien!, pero es muy viejo Dapper Drake Ubuntu based si no mal recuerdo
PCLinuxOS 2009 --- Pense que esta funcionaria muy bien, incluso instalo, pero se freezea cuando se trata de conectar a internet, pero este problema tambien lo presenta slackware, solo que PCLinuxOS es mas pesado.

El problema es debido al chip realtek de la tarjeta inalambrica, rtl8180, que es la que detecta el SO, pero al tratar de cargardo

modprobe

se muere, muy bien muerta X_x

hay que pasarla a blacklist, y luego tratar de hacerla funcionar con ndiswrapper, asi lo han hecho otros linuxeros.

Solo que no me ha funcado a mi.

Si todo va ejor, le instalare pk2cmd, piklab, gputils, gpsim, para usar mi programador de pics

Curso de Verano Interfaces

Buenos Días!

Espero que el día de hoy mis alumnos del curso de Verano de ISC esten leyendo esto, aqui podrán encontrar un poco de información, que les será util para desarrollar sus prácticas y proyectos, además de otras cosas. bueno les deseo mucha suerte y buen inicio de Curso

Atte
Miguel Montiel Mtz

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.

DEV-C++ instalacion ThenewBoston

Entre mis suscripciones de Youtubw, encontre este buen tutorial, les dejo el primer video, aclaro, no es mio, pertecene al autor thenewboston, que incluye a multiples tutoriales de programacion muy buenos. (Estan en ingles).

Fotos Generador Van de Graff Semiescolarizado

Lecturas para Fisica 2 Ing Industrial

El material para las lecturas esta disponible en el siguiente link

http://www.filefactory.com/file/b0a6088/n/lecturas.zip

El video de abajo te muestra como descargar este archivo y el mismo procedimiento es para las descargas de los avances programáticos.


bajarInformacionBlog
Cargado por maigke. - Descubre más videos de ciencia y hi tech.

Generador de Van de Graff

Videos en Youtube
http://www.youtube.com/watch?v=jqSoDmweudk
http://www.youtube.com/watch?v=2YAEguvgntM

Mas información al email que me proporcionaron:

Si no accesan aqui unos links de referencia

http://www.google.com.mx/imgres?imgurl=http://www.cienciafacil.com/small_step_9.jpg&imgrefurl=http://ylvy.net/blog/%3Fp%3D5&h=527&w=640&sz=43&tbnid=9SaMq-xUkNUEDM:&tbnh=113&tbnw=137&prev=/images%3Fq%3Dgenerador%2Bvan%2Bde%2Bgraff&hl=es&usg=__WhJxRfDp0hI5cPAzt4dvmJMUrKY=&ei=3viTS9erN5OkswOZ7838Aw&sa=X&oi=image_result&resnum=5&ct=image&ved=0CBYQ9QEwBA

http://www.taringa.net/posts/info/900763/Generador-Van-de-Graaff-+-como-hacer-uno-en-casa.html

Crisis aun más profunda que en el "error de diciembre"

Saludos pues leyendo un email que mi compañera y amiga Elba Candanedo V. se me hizo muy interesante la nota que me envio y el ver que tan cerrados los ojos tenemos a las circunstancias nacionales, y solo nos interesan cosas como el futbol o las las transmisiones de TV.

¿Es posible que podamos hacer algo?---

Referencia:
http://www.jornada.unam.mx/2010/02/23/index.php?section=opinion&article=002a1edi&partner=rss

Agradecimiento

Un cordial agradecimiento para el Ing. Hector Vicenteño, quien dio acceso al blog de un servidor para que su acceso desde ITST fuese posible.

Gracias

Miguel Montiel Mtz

Calendario de Actividades

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!

Avances Programaticos TEC2010A

Revisados Links de descarga ahora ya hay una version alternativa.
********************************************************************************************
Buen día, después de no tener mis datos, por fin pondre unos links para que descarguen los avances programaticos, las fecha tentativas para practicas, los criterios de evaluación y las fechas para examenes extra ordinarios, saludos a todos


Analisis de Circuitos Electricos A Alternativo


Analisis de Circuitos Eléctricos Alternativo -- B

Nuevos Links
Matemáticas Discretas B

Matemáticas Discretas A



Física 2 Semiescolarizado

Electricidad y Electrónica Industrial Semiescolarizado

El mundo se va a acabar!-- molotov??

Bueno este es un breve comentario sobre las profecias Mayas, disfrutenlo



y aca abajo un video con la canción del buen grupo Molotov