Jeal's Blog

Fanuc Alarm 466 – Z Axis: Motor/Amp Combination

noreply@blogger.com (Jeffrey Boy) — Sat, 1 Sep 2018 10:33:00 -0700

Regularmente cuando identificamos que un daño esta presente en un drive servo amplificador, es recomendable el reemplazo del mismo, cuando este nuevo drive es instalado regularmente el sistema nos propicia una alarma denotada como "Fanuc Alarm 466 - X Axis: Motor/Amp Combination".

Esta alarma 466 proviene del amplificador de reemplazo que tiene un servo software más nuevo que la unidad que está reemplazando. Como Fanuc ha fabricado unidades más nuevas, han actualizado el software / hardware dentro de estos amplificadores, por lo que solo necesita restablecer un parámetro para reiniciar la configuración y borrar la Alarma 466.
Los pasos están abajo:
1. - Poner la máquina en paro de emergencia.
2.- Ir al parámetro 2165 en el control Fanuc
3.- Establecer todos los valores en 0 o el valor de corriente demandado por el amplificador
4.- Reiniciar el equipo y remover el paro de emergencia del equipo.

Una vez que estos parámetros se cambian y la máquina se reinicia, la alarma se borrará y el amplificador se inicializará.

Download Zone!

Files:
B-63527EN01 [FANUC SERIES 16i 160i 160is - MODEL B] B-64115EN02 [FANUC SERIES OI - MODEL C] B-65285EN03 [FANUC AC SERVO MOTOR ALFA SERIES] FANUC Series Oi & Oi Mate Model D - MAINTENANCE MANUAL Fanuc-Alarms SPINDLE ALARM LIST TROUBLESHOOTING AND ACTION

Master Prog USB

noreply@blogger.com (Jeffrey Boy) — Fri, 29 Jan 2016 21:17:00 -0800

Master Prog es un Programador de Microcontroladores USB para todas las familias de Microcontroladores PIC, dsPIC, PIC32 y memorias EEPROM. Es una poderosa herramientas para programar estos dispositivos, compatible para cualquier computadora y con soporte para Windows 7, Windows 8 y Windows 10.

Entre las ventajas de este programador están:

La autoprogramacion (automáticamente cargas el programa en el pic al momento de compilar utilizando cualquier compilador).
Alta compatibilidad.
Protección contra corto circuito.
Soporte para múltiples encapsulados DIP, SSOP, TQFP y QFN.
Actualizable.

Master - Prog USB

Existen diferentes tipos de programadores en el mercado y cada uno de ellos dependerá del tipo de microcontrolador a emplear y me refiero específicamente al proveedor del mismo, para los microcontroladores de la compañía de Microchip comúnmente mas usados debido a la flexibilidad y accesibilidad de los mismos, se encuentra este tipo, y una basta gama de programadores hágalo usted mismo y los comerciales de las copañias proveedoras de los microcontroladores, en el mundo del hardware y software, es común entre comillas conocer a estos chips primero antes que a cualquier otro, sin embargo con la llegada del Arduino y las tarjetas de desarrollo cada vez mas es desplazado su uso, conocimiento y programación de los mismos, sin embargo para aquellos diseñadores y hobbistas que aun les gusta el hecho de programar desde cero sus proyectos aquí les dejo el software de estas tarjetas, si en algún momento los extraviaron.

Download Zone!

Files:
MASTER-PROG PIC-PROG II

Prácticas - Interpretacion de manuales Tecnicos

noreply@blogger.com (Jeffrey Boy) — Sat, 29 Nov 2014 12:54:00 -0800

Buen dia alumnos de la carrera de Ingeniería Mecánica automotriz de la Universidad Maya (UM).

les anexo una a una las prácticas que realizaremos durante estas dos semanas restantes de clases del periodo estudiantil - Septiembre/Diciembre 2014.

Practica No - 1 [ Resistencias ]

Practica No - 2 [ Capacitores ]

Practica No - 3 [ Diodos ]

Practica No - 4 [ Transistores ]

Practica No - 5 [ Compuertas Logicas ]

Sin mas por el momento nos vemos en inicio de semana para comenzar con las practicas en el salon, les recomiendo que aquellos que cuenten con barra de contactos llevenlas ya que no contamos con muchos contactos en el salon, les recuerdo nuevamente que es mejor un cargador de celular viejo, o un eliminador de voltaje, que la compra de baterias, no olviden de llevar pinzas, o herramientas para el corte de cables, etc, etc. Cualquier duda a comentario al final de la publicación la pueden hacer o directamente en Contact USS en la parte superior de la pagina.

El lunes no olviden de llevar sus laptos obviamente a los grupos que les toca clase conmigo el lunes, xD; para que hagamos el proceso de instalación del software de simulación "PROTEUS ISIS LAB". y el resto de los grupos haremos la misma dinamica el martes.

Saludos, Buen fin de semana.

Pinguino - Lecturas Digitales y Analogicas

noreply@blogger.com (Jeffrey Boy) — Fri, 26 Sep 2014 18:03:00 -0700

El día de hoy les traigo un vídeo explicativo de algunas funciones básicas para lecturas analógicas y digitales empleando la tarjeta de desarrollo Pinguino, así como también la manipulación de puertos completos de la misma tarjeta a partir de las función PORTX, donde la x son cada uno de los puertos con los que cuentan nuestro hardware cuales pueden ser 'A', 'B', 'C', 'D', etc... dependiendo las especificaciones de su propia tarjeta pinguino.

Ahora bien que es una lectura analógica, para comenzar con la definición hay que definir que es algo analógico y la mas clara definición seria todo aquello que no tiene una magnitud definida o un rango definido es decir que puede tomar una serie infinita de valores dependiendo su unidad, por ejemplo voltajes, corrientes, potencia, intensidad luminosa, etc... ahora bien una lectura analógica consiste en convertir toda esa serie de valores no definidos y definirlos en un rango lógico o digital es decir 0 y 1 claramente usando un sistema binario, decimal, hexadecimal o octadecimal. Ahora bien la mayoría de los microcontroladores cuentan con conversores analógicos - digitales, la diferencia regularmente entre uno y otros es la resolución, ¿Que es la resolución? algo muy simple la capacidad de poder representar esa magnitud analógica en un rango delimitado lógico, ¿Cuales son las resoluciones existentes en microcontroladores? de 8, 10 y 12 bits, los cuales representan para 8 bits 255 valores posibles, para 10 bits 1024 valores posibles y finalmente para 12 bits 4096.

Bueno finalmente eso seria la parte analógica, que sigue a continuación lo digital, lo digital se centra en solo dos estados 0 y 1, Verdadero y Falso, por lo que en ello radica la simplicidad y comodidad de este tipo de sistema, la comunicación entre dispositivos digitales consiste en una secuencia binaria es de decir de 0 y 1, por ejemplo y por asi decir ejemplo consideremos que para cambiar el canal de nuestro televisor nuestro control envía una secuencia binaria o paquete de datos hacia el televisor, como el siguiente 01011000 de 8 bits en el va codificado la instrucción de cambio y la información del canal a mover, esa complejidad de que un solo paquete de datos envíe mucha información es lo que lo hace sumamente atractivo en las telecomunicaciones.

A continuación muestro el sistema empleado en mi Pinguino 4550, como ven es bastante simple y versatil para todas las maravillas que puedo hacer con el.

Esquematico

Y por ello aquí los siguiente códigos usados durante el video con mi tarjeta Pinguino.

1.- Encender un puerto por completo (Función PORTB)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i=0;i<8;i++){
       pinMode(i,OUTPUT);
    }
    }

void loop() {
    //run repeatedly:
    PORTB = 255;
    }

2.- Contador Binario en el Puerto B (Funcion PORTB y FOR)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i=0;i<8;i++){
       pinMode(i,OUTPUT);
    }
    }

void loop() {
    //run repeatedly:
    int j;
    for(j=0;j<8;j++){
       PORTB = j;
       delay(1000); 
    }
    }

3.- Lectura Digital y switcheo de un Puerto Entero (Función digitalRead)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    if(digitalRead(13)){

      do{
      PORTB = 255;
      }
      while(digitalRead(13));
      PORTB = 0;
    }
    }

4.- Lectura Digital y ciclo For en Puerto Entero (Función digitalRead y For)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Buffer[] = {1,3,7,15,31,63,127,255};
    int j;
    
    if(digitalRead(13)){
       do{
          for(j=0; j<8;j++){
              PORTB = Buffer[j];
              delay(100);
          }
      }
       while(digitalRead(13));
    PORTB = 0;
    }
    }

5.- Lectura Digital y condicional if en Puerto Entero (Función digitalRead y If)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Buffer[] = {1,3,7,15,31,63,127,255};
    int j;
    
    if(digitalRead(13)){
       do{
          if(j > 0 && j < 8){
              PORTB = Buffer[j];
              delay(100);
          }
          else
              j = 0;
              j ++;
      }
       while(digitalRead(13));
    PORTB = 0;
    }
    }

6.- Efecto KID (Función digitalRead y If)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Buffer[] = {1,3,7,15,31,63,127,255,127,63,31,15,7,3,1};
    int j;
    
    if(digitalRead(13)){
       do{
          if(j > 0 && j < 16){
              PORTB = Buffer[j];
              delay(50);
          }
          else
              j = 0;
              j ++;
      }
       while(digitalRead(13));
    PORTB = 0;
    }
    }

7.- Lectura Analógica (Función analogRead)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Dato_Analogico = 0;
    delay(20);
    Dato_Analogico = analogRead(13);
    delay(20);
    PORTB = Dato_Analogico;
    }

7.- Lectura Analógica y parametrización de datos (Función analogRead y map)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: 
Description: - Manipulación de puertos completos -
- Lecturas Digitales y Analógicas -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Dato_Analogico = 0;
    delay(20);
    Dato_Analogico = analogRead(13);
    delay(20);
    Dato_Analogico = map(Dato_Analogico,0,1023,0,255);
    PORTB = Dato_Analogico;
    }

Download Zone!

Files:
Pinguino Board - Lecturas Analógicas y Digitales..

Pinguino Board - Primer Contacto

noreply@blogger.com (Jeffrey Boy) — Fri, 29 Aug 2014 19:11:00 -0700

Dando inicio con esta nueva etapa aquí les traigo este primer post y video de la seccion conociendo el proyecto Pinguino, bueno como muchas sabrán el proyecto Pinguino surgió por el interés de explotar las tecnología USB que nos proporciono la compañía Microchip agregando a este la necesidad de diseñar un sistema mínimo lo suficiente robusto y versátil para aplicarlo en cualquier aplicación o proyecto tipo profesional o diversión, he ahí el nacimiento del proyecto Pinguino siendo Jean-Pierre Mandon su iniciador o creador.

En que consiste Pinguino, Pinguino es un sistema mínimo de operación para prototipos simple y contundente, hablando técnicamente es una plataforma integrada de desarrollo o IDE por sus siglas en Ingles (Integrated Development Enviroment), es Open Hardware como Open Software interesante verdad! y aun lo es mas por que gran parte de sus librerías son basadas en Arduino, es decir que si sabes usar un Arduino podrás usar un Pinguino y lo que es aun mejor tu podrás armar el tuyo en función de tus necesidades o gustos tan simple y llano como eso, eso es genial así como también la facilidad de encontrar repuestos si en dado caso estos se dañaran por un mal uso o por un accidente electrónico. Eso es Pinguino o mas bien This is Pinguino!! Argggh!!!.

Que hacer con tu primer Pinguino, primero admirarlo si lo hiciste tu y magnificar lo grandioso que te quedo, segundo conectarlo y maravillarte aun mas por que funciona, y tercero encender y apagar un Led ver eso es mejor que cualquier acto de magia de Chris Angel, y lo es en verdad.

A continuacion muestro el sistema de minimo empleado en el diseño de mi Pinguino 4550, como ven es bastante simple y versatil para todas las maravillas que puedo hacer con el.

Esquematico

Y por ello aquí los siguiente códigos de como acceder al led indicador propio del Pinguino para su manipulación.

1.- Swithceo del Led Indicador (Funcion Toggle)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: Fri Aug 29 20:51:29 2014
Description:Primer contantoc con Pinguino
- Encendido de Leds -
-----------------------------------------------------*/


void setup() {
    //run once:
    pinMode(USERLED,OUTPUT);
    }

void loop() {
    //run repeatedly:
    toggle(USERLED);
    delay(1000);
    }

2.- Switcheo del Led Indicador (Funcion digitalWrite)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: Fri Aug 29 20:51:29 2014
Description:Primer contantoc con Pinguino
- Encendido de Leds -
-----------------------------------------------------*/


void setup() {
    //run once:
    pinMode(USERLED,OUTPUT);
    }

void loop() {
    //run repeatedly:
    //toggle(USERLED);
    //delay(1000);
    digitalWrite(USERLED,HIGH);
    delay(1000);
    digitalWrite(USERLED,LOW);
    delay(1000);
    }

3.- manipulacion de un Puerto Entero (Función digitalWrite)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: Fri Aug 29 20:51:29 2014
Description:Primer contantoc con Pinguino
- Encendido de Leds -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Pin_Out[8] = {0,1,2,3,4,5,6,7};
    int j;
    for (j = 0; j < 8; j++){
        digitalWrite(Pin_Out[j],HIGH);
        delay(1000);
        digitalWrite(Pin_Out[j],LOW);
        delay(1000);
        }

    }

4.- manipulacion de un Puerto Entero (Función Toggle)

/*----------------------------------------------------- 
Author: Jeals Blog --<>
Date: Fri Aug 29 20:51:29 2014
Description:Primer contantoc con Pinguino
- Encendido de Leds -
-----------------------------------------------------*/


void setup() {
    //run once:
    int i;
    for (i = 0; i < 8; i++){
        pinMode(i,OUTPUT);    
        }
    }

void loop() {
    int Pin_Out[8] = {0,1,2,3,4,5,6,7};
    int j;
    for (j = 0; j < 8; j++){
        toggle(Pin_Out[j]);
        delay(1000);
        }

    }

Download Zone!

Files:
Pinguino Board - Encendido de LEDs..

Instalando Pinguino

noreply@blogger.com (Jeffrey Boy) — Fri, 22 Aug 2014 12:44:00 -0700

Ha pasado mucho tiempo desde mi ultimo post!!!, y la verdad que ya extrañaba escribir y compartir lo poquito que sabemos con todo el que desee aprender. De entrada les comento que he empezado una nueva etapa como instructor y docente y para ello tengo que retomar y re-estudiar muchas cosas que pareciera que han sido olvidadas sin embargo aun las tengo muy presentes, que sin duda necesitan una pulida pero el conocimiento ahí esta, y para comenzar con el pie derecho y con muchas ganas he desempolvado mis libros y demás material y tarjetas electrónicas para comenzar.

Y si bien sabemos lo ultimo que publique era usando las tarjetas denominadas PINGUINO, yo no dudo de las capacidades de los desarrolladores de este proyecto puesto que son muy buenas yo las he probado en su momento y generaron en mi muchas expectativas, las cuales no logre consolidar debido a proyectos que surgieron a la par, pero ahora se ha dado el momento de continuar y ello haremos.

Como buen investigador y navegador, sabemos que el proyecto Pinguino tiene muchos adeptos si muchos pero pocos que aporten o mejoren o en su defecto documenten errores que se han encontrado y que hayan solucionado de alguna manera, esa es una cruda realidad ademas de muchas paginas que han sido abandonadas o des-actualizadas, y claro la constante innovación de muchas otras tarjetas electrónicas se vuelven mas llamativas, no he tenido la dicha se usarlas todas por que no es así, pero siempre es bueno ser un conocedor y por ello yo les recomiendo que si en sus posibilidades están adelante, y como segunda recomendación la siguiente, lo interesante de un proyecto cual fuese es hacer algo muy complejo o complejo que pareciera que fuera fácil de recrear. Lo que a mi en lo personal me encanta del pinguino es que tu mismo lo puedes hacer y puedes expandir tanto como tu lo desees ademas de que no te preocuparas por repuestos o piezas pues son de fácil acceso.

Y para comenzar a usar nuevamente o si fuera tu primera vez hay que comenzar por la instalación del compilador que es un IDE desarrollado en python que le da gran robustez y simplicidad aun a nuestra tarjeta pinguino, hay que mencionar que la persona que da soporte a este IDE es Yeison Cardona un Colombiano cual su pagina es la siguiente http://yeisoneng.appspot.com/.

En el link siguiente http://yeisoneng.appspot.com/post/pinguino_svn_windows/ se encuentra todo el proceso descrito por nuestro compañero Yeison para la instalación de este compilador.

Stepper Motor using a Pinguino Board

noreply@blogger.com (Jeffrey Boy) — Mon, 6 Jan 2014 22:30:00 -0800

A stepper motor is an electromechanical device which converts electrical pulses into discrete mechanical movements. The shaft or spindle of a stepper motor rotates in discrete step increments when electrical command pulses are applied to it in the proper sequence. The motors rotation has several direct relationships to these applied input pulses. The sequence of the applied pulse is directly related to the direction of motor shafts rotation is directly related to the frequency of the input pulses and the length of rotation is directly related to the number of input pulses applied.

Stepper motors are ideally suited for precision positioning of an object or/and precision control of speed without using closed-loop feedback for any automation systems. It is also translate switched excitation changes into precisely defined increments of rotor position {'steps'}. Accurate positioning of the rotor is generally achieved by magnetic alignment of iron teeth on the stationary and rotating parts of the motor.

The basic function of stepper motor is that its output shaft rotates in a series of discrete angular intervals or steps, one step being taken each time a command pulse is received. When a definite number of pulses are supplied, the shaft turns through a definite known angle. The name stepper is used because this motor rotates through a fixed angular step in response to each input current pulse received bi its controller. These controllers can be computers, microprocessor and programmable controllers.

Principle of Operation

A stepping motor may be compared with a synchronous motor as far as operation is concerned: a rotating field, here generated by the control electronics, pulls a magnetic rotor along. Stepping motors are sub divided according to the manner in which the rotating field is generated, that is with unipolar or bipolar stator windings and the material from which the rotator has been constructed -- permanent magnetic material or soft iron.

Step angle: The angle through which the motor shaft rotates foer each command pulse is called the step angle φ = 360°/(No. of stator faze × No of rotor teeth).

The angle can be as small as 0.72° or as large as 90°, but the most common step angle 1.8°, 2.5°, 7.5°, 15°...

Stepper Motor Advantages and Disadvantages

Advantages

The rotation angle of the motor is proportional to the input pulse.
The motor has full torque at standstill (if the windings are energized)
Precise positioning and repeatability of movement since good stepper motors have an accuracy of 3--5% of a step and this error is non cumulative from one step to the next.
Excellent response to starting/stopping/reversing.
Very reliable since the are no contact brushes in the motor. Therefore the life of the motor is simply dependant on the life of the bearing.
The motors response to digital input pulses provides open-loop control, making the motor simpler and less costly to control.
It is possible to achieve very low speed synchronous rotation with a load that is directly coupled to the shaft.
A wide range of rotational speeds can be realized as the speed is proportional to the frequency of the input pulses.

Disadvantages

Resonances can occur if not properly controlled.
Not easy to operate at extremely high speeds.

Pinguino — Stepper Motors

Well, now we know about what a stepper motor is and how to work it, but the point of this topic is how to use this device with an embedded board or microcontrollers, and why not with a pinguino board. In this case I’m using a stepper motor with the next specification: TYPE 4H4018X1616, 1.8°, 5 V, 1.0 A. As we can see this motor needs 5 volts and 1 amper for its efficient operation, there are two ways to powering this motor, with my computer that only provide 500 mA and it can be dangerous for my USB port or using a external power source, for avoid any risk with my computer I will use a external power source, and chose this choice because I don't have material for a good driver or controller that provide enough current and security at the same time using my USB port.

I'm using the next material:

Resistors (10 KΩ and 33 Ω)
Dip switch (8 switchs)
ULN2003A
LCD 16x2
Pinguino Board (PIC18F4550)
Bipolar Stepper Motor

Schematic

PIC C CCS COMPILER CODE

Fuses Code

#include <18F4550.h>
#device ADC=16

#fuses NOMCLR       //No Master Clear Reset. Used for I/O Instead 
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES NOFCMEN                  //Fail-safe clock monitor disabled
#FUSES NOIESO                   //Internal External Switch Over mode disabled
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOVREGEN                 //USB voltage regulator disabled
#FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
#FUSES NOLPT1OSC                //Timer1 configured for higher power operation
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)

#use delay(CLOCK=20000000)

#include "flex_lcd.c"

Main Code

#include 

//Normal Full Step
unsigned char Motor[4] ={0x0a,0x06,0x05,0x0b};

void Stepper_Motor_ClockWise(unsigned char Steps){
unsigned int Index = 0;
unsigned int Count = 0;
    do {
        OUTPUT_D(Motor[Index]);
        Index ++;
        delay_ms(100);
            if(Index > sizeof(Motor)-1){
                Index = 0;
                Count ++;
            } 
            else if(Count == Steps){
                OUTPUT_D(0); 
                Count = 0;
                Index = 0;              
                lcd_putc("\f");
                break;
            }  
        lcd_gotoxy(1, 0);
        printf(lcd_putc,"Clockwise");                  
        lcd_gotoxy(1, 1);
        printf(lcd_putc,"Value: %u",Count);   
    } 
    while(Count <= Steps);
}    


void Stepper_Motor_AntiClockWise(unsigned char Steps){
int8 Index = 3;
unsigned int Count = 0;
    do {
        OUTPUT_D(Motor[Index]);
        Index --;
        delay_ms(100);
            if(Index == -1){
                Index = 3;
                Count ++;
            } 
            else if(Count == Steps){
                OUTPUT_D(0); 
                Count = 0;
                Index = 0;              
                lcd_putc("\f");
                break;
            }    
        lcd_gotoxy(1, 0);
        printf(lcd_putc,"AntiClockwise");        
        lcd_gotoxy(1, 1);
        printf(lcd_putc,"Value: %u",Count);   
    } 
    while(Count <= Steps);
}    

void Stepper_Motor(unsigned int Function){
    switch (Function){
        case 1: //ClockWise 
            lcd_putc("\f");     
            Stepper_Motor_ClockWise(10);    
        break;
        case 2: //AntiClockWise
            lcd_putc("\f");    
            Stepper_Motor_AntiClockWise(10);
        break;            
        default: 
            lcd_gotoxy(1, 0);
            printf(lcd_putc,"Waiting for...");        
            lcd_gotoxy(1, 1);
            printf(lcd_putc,"Command!");                        
        }
    }
    
void main()
{
lcd_init();

   while(TRUE)
   {
      //TODO: User Code
      Stepper_Motor(input_a());
   }

}

PINGUINO BOARD CODE

/*----------------------------------------------------- 
Author:  Jefferson GoVa--<>
Date: Fri Jan 03 23:14:02 2014
Description:
Stepper Motor using a Pinguino Board :D
-----------------------------------------------------*/

unsigned int Btn_State;


//Normal Full Step
unsigned char Motor[4] ={0x0a,0x06,0x05,0x0b};
    
void Stepper_Motor_ClockWise(unsigned char Steps){
unsigned int Index = 0;
unsigned int Count = 0;
    do {
        PORTD = Motor[Index];
        Index ++;
        delay(100);
            if(Index > sizeof(Motor)-1){
                Index = 0;
                Count ++;
            } 
            else if(Count == Steps){
                PORTD = 0; 
                Count = 0;
                Index = 0;              
                lcd.clear();
                break;
            }  
        lcd.setCursor(0, 0);
        lcd.printf("Clockwise");                  
        lcd.setCursor(0, 1);
        lcd.printf("Value: %u",Count);   
    } 
    while(Count <= Steps);
}    

void Stepper_Motor_AntiClockWise(unsigned char Steps){
int Index = 3;
unsigned int Count = 0;
    do {
        PORTD = Motor[Index];
        Index --;
        delay(100);
            if(Index < 0){
                Index = 3;
                Count ++;
            } 
            else if(Count == Steps){
                PORTD = 0; 
                Count = 0;
                Index = 0;              
                lcd.clear();
                break;
            }    
        lcd.setCursor(0, 0);
        lcd.printf("AntiClockwise");        
        lcd.setCursor(0, 1);
        lcd.printf("Value: %u",Count);   
    } 
    while(Count <= Steps);
}    

void Stepper_Motor(unsigned int Function){
    switch (Function){
        case 1: //ClockWise 
            lcd.clear();      
            Stepper_Motor_ClockWise(10);    
        break;
        case 2: //AntiClockWise
            lcd.clear();     
            Stepper_Motor_AntiClockWise(10);
        break;            
        default: 
            lcd.setCursor(0, 0);
            lcd.printf("Waiting for...");        
            lcd.setCursor(0, 1);
            lcd.printf("Command!");                        
        }
    }
    
void Check_Btns(){
    char State[3]; 
    int i; 
        for (i = 0 ;i < 3 ;i ++){
            State[i] = digitalRead(i+13);    
        }
    Btn_State = State[0] + State[1]*2 + State[2]*4;
    Stepper_Motor(Btn_State);
}    
    
void setup() {
    //run once:
    //DIP Switch States
    pinMode(13,INPUT);
    pinMode(14,INPUT);
    pinMode(15,INPUT);
    
    //Motor Stepper
    pinMode(21,OUTPUT);
    pinMode(22,OUTPUT);
    pinMode(23,OUTPUT);
    pinMode(24,OUTPUT);
    
    // initialize the library with the numbers of the interface pins
    //lcd.pins(RS, E, D4, D5, D6, D7, 0, 0, 0, 0); //4bits
    //lcd.pins(RS, E, D0, D1, D2, D3, D4, D5, D6, D7); //8bits
    lcd.pins(0, 1, 2, 3, 4, 5, 0, 0, 0, 0); // RS, E, D4 ~ D8 

    // set up the LCD's number of columns and rows: 
    lcd.begin(16, 2);   
    }

void loop() {
    //run repeatedly:
    Check_Btns();
    }

Download Zone!

Files:
Stepper Motor Basics Stepper Motor Stepper Motor Controller ULN2003A Stepper Motor Codes Stepper Motor Schematic Stepper Motor Video..

How to Make Your Dreams Come True

noreply@blogger.com (Jeffrey Boy) — Thu, 2 Jan 2014 14:22:00 -0800

It has been said that whatever you can dream of, you can achieve. There is no greater time than now to begin to live your dreams. Your dreams are achievable if you will put in the effort needed to make it work. Your mind is such that it can only conceive what it can be achieve, whatever the dream is your mind believes it can achieve it, but you have to agree with your mind that you can achieve it, so that when you are in agreement you can work together to achieve your dreams.

Steps

1.- Be specific bout your dream.

The first thing you need to do is to be specific about your dream, at least the one you want to work on now, the way to be very specific about your dreams is to write them in your dream journal.
2.- Turn your dream into a burning desire.

You will need to turn your dream into a burning desire in your heart. A strong will to achieve your dreams boosts self-confidence and will aid you in pulling through some of the worst stage of life. The way to turn you dream into a burning desire is to believe that your dream is achievable and that you can achieve it.
- Once it has become a burning desire you are no longer to refer to it as a dream, because the very nature of a dream gives the impression that it is not real.
3.- Turn your burning desires into goals.

You then need to turn your burning desire into a goal. You had earlier turned your dream into a burning desire because you believe it can be done and that you can do it. But to actually turn it into a goal, you need to believe that you will do it. This kind of believing is based on your commitment that if it can be done then I can do it, and if I can do it then I will do it now. The thing about goals is they are time sensitive, so adding a time frame helps you to accept the fact that you are committed to doing it.
- Once you have turned your burning desire into a goal, you are no longer to call it a burning desire or a dream, it is now your goal in life, a goal that must be achieved by you.
4.- Plan.

create a strategic plan of action. You will need to create a strategy for the accomplishment of your goals; this strategy is usually called a plan or a plan of action.
- There is no universal plan of action for everyone, each strategy depends on the person involved and the goals they wish to accomplish, because of this fact the key to creating your own working plan of action lies in you and you need to seek it out.
5.- Take action now.

Once you have turned your goals into a plan of action tailored after you, because its creation took your person into consideration, you need to take action and utilize every opportunity that will come your way.
- The way of the universe is that like attracts like and where there is a need, the universe seems to find a way of meeting those needs through opportunities. You need to be prepared for them as you take action on your plans to achieve your goals which will help you actualize your burning desire and make your dream a reality.
6.- Set short-term goals.

Divide your main goal into sub-divisions, and set time periods for achieving each of them.
7.- Review your progress regularly.

Review your progress regularly and check.
- If you have achieved your goals for that time period.
- If you still have a desire to follow your dream.
- If you have deviated from the path toward fulfilling your goal.
8.- Knowledge; Knowing exactly what is your dream and accepting that is exactly what you want.

(e.g => Knowing that you want good grades) Also learn about the law of attraction. This law states that what you focus all your attention to is what you will receive.
9.- Visualization; Have a vivid picture in your mind or video of how your dream will be when you accomplish it.

Tell yourself that you have already received it (this is focusing on your subconscious mind which is 5/6 of your thinking mind on your goal which will lead your inner reality to becoming a physical reality).
10.- Be confident; Have no doubts in yourself what so ever, this will lead to reverse thinking which will surround you with negative energy and you will receive a corresponding negative result.
11.- Meditate; Relax and calm your mind, soul and body.

This will also help with step.
12.- USing the above steps and work towards your dream with all your focus, concentration and confidence.

Your goal will become a reality sooner that you could have ever imagined.

Edited by Michael Igioh, Puddy, Maluniu, Krystle and 20 others.

Great!! Post from WikiHow

Comunicación Serial (UART)

noreply@blogger.com (Jeffrey Boy) — Mon, 16 Dec 2013 21:38:00 -0800

Los PIC utilizan, entre otros, dos modos de transmisión serie:

El puerto serie síncrono (SSP).
La interfaz de comunicación serie (SCI) o receptor transmisor serie síncrono-asíncrono universal (USART).

El SSP se suele utilizar en la comunicación con otros microcontroladores o con periféricos. Las dos interfaces de trabaja son:

Interfaz serie de periféricos (SPI): desarrollada por Motorola para la comunicación entre microcontroladores de la misma, o diferente familia en modo maestro-esclavo; full-duplex.
Interfaz Inter-circuitos (I²C):Interfaz desarrollada por Philips, con una gran capacidad para comunicar microcontroladores y periféricos, half-duplex.

La configuración USART (transmisor-receptor serie síncrono-asíncrono universal), también conocido SCI (Interfaz de Comunicación Serie), permite la comunicación con un ordenador trabajando en modo full-duplex asíncrono o con periféricos trabajando en modo half-duplex. En general, pueden trabajar de dos formas:

Asincrono (full-duplex).
Sincrono (half-duplex).

Otros tipos de comunicación soportados por los PIc son: 1-Wire bus, LIN (Local Interconnect Network),USB(Universal Serial Bus), el CAN (Controller Area Network) y Ethernet

Figura 1.- UART - Diagrama a bloques simplificado.

Algunos PIC disponen del modulo de comunicación serie USART/SCI, tal vez el más utilizado entre los módulos de interfaz serie. La principal función del USART es la de transmitir o recibir datos en serie. Esta operación puede dividirse en dos categorias: síncrona o asíncrona. La transmisión síncrona utiliza una señal de reloj y una linea de datosl mientras que en la transmisión asíncrona no se envía la señal de reloj, por lo que el emisor y el receptor deben de tener relojes con la mismamfrecuencia y fase. Cuando la distancia entre el emisor y el receptor es pequeña se suele utilizar la transmisión síncrona, mientras que para distancias mayores se utiliza la transmisión asíncrona.

El USART puede transmitir o recibir datos serie. Puede transferir tramas de satos de 8 o 9 bits por transmisión y detectar errores de transmisióm. Tambien puede generar interrupciones cuando se produce una recepción de datos o cuando la transmisión ha sido completada.

Algunos PIC tienen un USART direccionable o AUSART (Addresable USART) que utiliza el noveno bit de datos para distinguir entre la recepción de datos o de dirección. En algunos PIC se ha mejorado el modulo USART dando lugar al EUSART o USART mejorado, el cual permite la detección automatica de baudios, el despertar automatico al recibir la señal de sincronismo o la transmisión del caracter break de 12 bits, permitiendo su utilización en sistemas de redes de interconexión local (bus LIN). Basicamente la transmision serie consiste en enviar los datos bit a bit a traves de una linea comun en periodos de tiempos fijos, dando lugar a la llamada velocidad de transmisión o número de bits enviados por segundo (baudios). Tanto el emisor como el receptor poseen registros de desplazamiento para realizar la comunicación. Los bits estan codificados en NRZ (nivel alto:1, nivel bajo:0), NRZI (cambio de nievl:1, sin cambio de nivel:0)

La gran mayoría de los sistemas de comunicación de datos digitales actuales utilizan la comunicación en serie, debido a las grandes ventajas que representa esta manera de comunicar los datos:

Económica Utiliza pocas líneas de transmisión inclusive puede usar sólo una línea.
Confiable Los estándares actuales permiten transmitir datos con bits de paridad y a niveles de voltaje o corriente que los hacen poco sensibles a ruido externo. Además por tratarse de información digital, los cambios en amplitud de las señales (normalmente causadas por ruido) afectan muy poco o nada a la información.
Versátil No está limitada a usar conductores eléctricos como medio de transmisión, pudiendo usarse también: fibra óptica, aire, vacío, etc. Además el tipo de energía utilizada puede ser diferente: luz visible, infrarroja, ultrasonido, pulsos eléctricos, radio frecuencia, microondas, etc.

Una gran cantidad de periféricos se comunican actualmente en serie con una micro computadora: líneas telefónicas, terminales remotas, unidades de cassette magnético, el ratón, teclados, etc.

Esquematico

Comunicación Serial (UART)[Emisor Firmware "Emisor.h"]

#include <18F2520.h>
#device ADC=16

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES NOFCMEN                  //Fail-safe clock monitor disabled
#FUSES NOIESO                   //Internal External Switch Over mode disabled
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
#FUSES NOLPT1OSC                //Timer1 configured for higher power operation
#FUSES NOSTVREN                 //Stack full/underflow will not cause reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)

#use delay(clock=8MHz)
#use rs232(baud=115200,UART1,stream=Emisor)

Comunicación Serial (UART)[Emisor Firmware "Emisor.c"]

#include 

void Enviar(){
int i;
   for(i = 0; i < 10; i ++){
      fputc(i,Emisor);
      delay_ms(1000);
   }
}

void Mensaje(){
char Msj[64] = "Hola Mundo!";
int i;
   for(i = 0; i < sizeof(Msj); i ++){
      fputc(Msj[i], EMisor);
   }
}

void main()
{
   while(TRUE)
   {
      //TODO: User Code
      //Enviar();
      Mensaje();
      delay_ms(2000);
   }

}

Comunicación Serial (UART)[Receptor Firmware "Receptor.h"]

#include <18LF2520.h>
#device ADC=16

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES NOFCMEN                  //Fail-safe clock monitor disabled
#FUSES NOIESO                   //Internal External Switch Over mode disabled
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
#FUSES NOLPT1OSC                //Timer1 configured for higher power operation
#FUSES NOSTVREN                 //Stack full/underflow will not cause reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)

#use delay(clock=8MHz)
#use rs232(baud=115200,UART1,stream=Receptor)

Comunicación Serial (UART)[Receptor Firmware "Receptor.c"]

#include 

#define LCD_ENABLE_PIN PIN_B0
#define LCD_RS_PIN PIN_B1
#define LCD_RW_PIN PIN_B2
#define LCD_DATA4 PIN_A0
#define LCD_DATA5 PIN_A1
#define LCD_DATA6 PIN_A2
#define LCD_DATA7 PIN_A3

#include 

int i;
char Msj[64];
char Data;


void Leer(){
do{
   Data = fgetc(Receptor);
   if(Data == '\0'){
      break;
   }
   else{
   Msj[i] = Data;
   i++;
   }
}
while(Kbhit(Receptor));   
}

void Limpiar(char *var){
   int i = 0;
   while(var[i] != '\0'){
      var[i] = '\0';
      i ++;
   }
}

#INT_RDA
void  RDA_isr(void) 
{
   //i = fgetc(Receptor);
   //lcd_putc("\f");
   Leer();
}


void main()
{

   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);

   lcd_init();

   while(TRUE)
   {
      //TODO: User Code
      lcd_gotoxy(1,1);
      printf(lcd_putc,"%s",Msj);
      Limpiar(Msj);
   }
}

Download Zone!

Files:
Comunicación Serial entre PICs y PC USART Microchip Descripción detallada del puerto USART Firmware UART Simulacion UART Comunicacion Serial (UART) PIC..

USB HID CCS DEMO

noreply@blogger.com (Jeffrey Boy) — Wed, 11 Dec 2013 12:35:00 -0800

Well, some weeks ago I was thinking about, what can I post?, so I saw around my study room and I saw my old toolbox with my old development boards, for example my Pinguino32, Arduino, Stellaris and other boards that I made when I was studying my career, and among these things, I found Microchip's microcontrollers PIC16fxx and PIC18Fxx. Of all my microcontrollers that I found and I had one with USB interface, and this it's the reason why I made this post talking about USB HID.

Some years ago it was very common to use the RS232 communication between our boards and computers, but at this time you seldom can see that technology again in new boards, because it's old,in its moments it was a good technology with high functionalities but the time is changing, and always is necessary more speed when we talk about communication and performance. So, most microcontrollers have a USB interfaces or compatibility to adapt USB interfaces, and these adaptability improve the communication versatility between humans and computers, and finally our design will be better, stronger and complex for resolve any problem.

Finally in this post I try to make a simple program toggling leds, sending and receiving messages from computer to microcontroller and viceversa, in essence this means that you can rapidly develop and test a USB device and the Windows host-application with a minimum of USB Generic HID protocol knowledge. The class library gives you a very simple interface to the USB device from C# and the firmware serves as an example of how to create the specific software needed on the PIC for your device design. I used the CyUSB library from Cypress Company, this library has either a lot of function for USB Cypress HID or USB HID generic and that it's awesome. there are a lot of APIs to achieve communication between our microcontroller and computer, for example "Florian Project", "Easy PIC Project", "LVR Project",etc... and I chose this because it's new or more less, you can prove with other that's the challenge. So, below I put schematics, codes and videos about this post talking about USB HID Demo, enjoy it!!

Schematic

USB HID CCS[Microcontroller Firmware "USB_HID.h"]

#include <18F4550.h>
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES HSPLL                    //High Speed Crystal/Resonator with PLL enabled
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES BORV46                   //Brownout reset at 4.6V
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOCPD                    //No EE protection
#FUSES STVREN                   //Stack full/underflow will cause reset
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT                    //Program memory not write protected
#FUSES NOWRTD                   //Data EEPROM not write protected
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
#FUSES NOWRTC                   //configuration not registers write protected
#FUSES NOWRTB                   //Boot block not write protected
#FUSES NOEBTR                   //Memory not protected from table reads
#FUSES NOEBTRB                  //Boot block not protected from table reads
#FUSES NOCPB                    //No Boot Block code protection
#FUSES MCLR                     //Master Clear pin enabled
#FUSES NOLPT1OSC                //Timer1 configured for higher power operation
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#FUSES PLL5                     //Divide By 5(20MHz oscillator input)
#FUSES CPUDIV1                  //No System Clock Postscaler
#FUSES USBDIV                   //USB clock source comes from PLL divide by 2
#FUSES VREGEN                   //USB voltage regulator enabled

#use delay(clock=20000000)

/*-- Transmit and Receive Packet Size --*/
#define USB_CONFIG_HID_TX_SIZE 64 
#define USB_CONFIG_HID_RX_SIZE 64

/*---------- VENDOR ID AND PRODUCT ID -----------*/
#define USB_CONFIG_PID 66        //Chnage Vendor Id and Product Id
#define USB_CONFIG_VID 1240        //So that they will work with my Application
/*-----------------------------------------------*/

#define HID_USB_ON PIN_B0
int8 Pin_Table[] = {PIN_C0, PIN_C1, PIN_C2}; 

/*---- LCD Pin definition ----*/
#define LCD_ENABLE_PIN  PIN_B3                                    
#define LCD_RS_PIN      PIN_B2                                    
#define LCD_RW_PIN      PIN_B1                                    
#define LCD_DATA4       PIN_B4                                    
#define LCD_DATA5       PIN_B5                                    
#define LCD_DATA6       PIN_B6                                    
#define LCD_DATA7       PIN_B7

USB HID CCS [Microcontroller Firmware "USB_HID.c"]

#include "USB_HID.h"

/*---- Include the LCD include file ----*/
#include  

/*---- USB Libraries ----*/
#include 
#include "usb_desc_hid.h"
#include 

//Declare Variables
unsigned char HID_InData[64];
unsigned char HID_OutData[64];

char LED[3] = {'A','B','C'};
int i = 0;

void Message(){
//Welcome Text
printf(lcd_putc,"\f");
printf(lcd_putc,"Welcome to..\n Jeal's Blog!!");
}

void Buttons_Options(){
int Counter = 0;
while(TRUE){
   if(Counter < 100){  
      if (!input(PIN_A5)){    
         while((!input(PIN_A5)));         
         output_toggle(Pin_Table[i]);
         printf(lcd_putc,"\f");
         printf(lcd_putc,"Toggling LED %d \nwith buttons",i);
      }
      if (!input(PIN_E0)){    
         while((!input(PIN_E0)));
         output_toggle(Pin_Table[i]);
         printf(lcd_putc,"\f");
         printf(lcd_putc,"Toggling LED %d \nwith buttons",i);
      } 
   }
   else if(Counter == 100){
      break;
   }
   Counter ++;
   delay_ms(5);
}
}

void Reading_Buttons1(){
   if (!input(PIN_E1)){    
   delay_ms(100);             
      while((!input(PIN_E1))){        
/*--------------- MENU --------------------*/
         switch(LED[i]){
            case 'A':
            //Something        
            printf(lcd_putc,"\f");
            printf(lcd_putc,"Case 'A'");
            Buttons_Options();
            break;
            case 'B':
            //Something
            printf(lcd_putc,"\f");
            printf(lcd_putc,"Case 'B'");  
            Buttons_Options();
            break;
            case 'C':
            //Something
            printf(lcd_putc,"\f");
            printf(lcd_putc,"Case 'C'");
            Buttons_Options();
            break; 
            default:
            printf(lcd_putc,"\f");
            printf(lcd_putc,"Default"); 
            break;         
            }
      }
      i++;
      if(i>2) i = 0;
   }
}

void Setup_USB_HID(){
   usb_init();                      
   usb_task();                     
   usb_wait_for_enumeration();      
}

void Status_USB_HID(){
   int1 Attached_HID = 0; 
   int1 Enumerated_HID = 0;
   Attached_HID = usb_attached();
   Enumerated_HID = usb_enumerated();
   
      if(Attached_HID && Enumerated_HID){
         output_high(HID_USB_ON);
      }
      else{
         output_toggle(HID_USB_ON);
         delay_ms(100);
      }
}
 
void Clear_HID_Bus(char *var) {
    int i = 0;
    while(var[i] != '\0') {
        var[i] = '\0';
        i++;
    }
} 

void Toggling_LEDs(){
switch(HID_InData[1])
      {
      case 0:  //LED # 1
         output_toggle(Pin_Table[HID_InData[1]]);
         printf(lcd_putc,"\f");
         printf(lcd_putc,"Toggling LED %d \nby USB",HID_InData[1]);
         break;
      case 1:  //LED # 2
         output_toggle(Pin_Table[HID_InData[1]]);
         printf(lcd_putc,"\f");
         printf(lcd_putc,"Toggling LED %d \nby USB",HID_InData[1]);         
         break;
      case 2:  //LED # 3
         output_toggle(Pin_Table[HID_InData[1]]);
         printf(lcd_putc,"\f");
         printf(lcd_putc,"Toggling LED %d \nby USB",HID_InData[1]);         
         break;
      }

}

void Writitng_Messages(){
int j = 0,k= 0,x=1;
char Buffer[64];
printf(lcd_putc,"\f");
   for(j = 1; j<=sizeof(HID_InData); j++){   
   Buffer[k] = (HID_InData[j]);
   if(Buffer[k] == '\0'){
   break;
   }
   else{
      if(x > 16){
         lcd_gotoxy(x-16,2);
         printf(lcd_putc,"%c",Buffer[k]);
         }
      if(x > 32){
         printf(lcd_putc,"\f");  
         printf(lcd_putc,"Overflow!!\n Lack of space");      
      }
      else{
         lcd_gotoxy(x,1);
         printf(lcd_putc,"%c",Buffer[k]);
         }
   }
   k++;
   x++;
   }  
}

Reading_ADC(){
int i= 0;
for (i=0;i<64;i++){
HID_OutData[i]=read_adc();
delay_us(20);
}
usb_put_packet(1,HID_OutData,64,USB_DTS_TOGGLE);
}

void Reading_HID(){
   usb_get_packet(1,HID_InData,64);
    switch(HID_InData[0])
      {
      case 1:  //Toggle LEDS
         Toggling_LEDs();
         break;
      case 2:  //Message.
         Writitng_Messages();
         break;
      case 3:  //Reading ADCs.
         Reading_ADC();
         break;
      }
}

void main()
{
   setup_adc_ports(AN0|VSS_VDD);
   setup_adc(ADC_CLOCK_INTERNAL);
/*
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_wdt(WDT_OFF);
   setup_timer_0(RTCC_INTERNAL);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
   setup_ccp1(CCP_OFF);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
*/

   //TODO: User Code
   lcd_init(); 
   Message();
      
   //Init the USB
   Setup_USB_HID();
    
   while(TRUE)
   {        
   Reading_Buttons1();        
   
        usb_task();
        Status_USB_HID();
        if(usb_enumerated())
        {
            if(usb_kbhit(1))
            {    
                //Clean array for fixing problems
                Clear_HID_Bus(HID_InData);
                Clear_HID_Bus(HID_OutData);
                
                //Get the Data
                Reading_HID();               
           }
        }         
    }
}

C# Software [USB HID Demo]

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using CyUSB;

namespace USB_HID_Project
{
    public partial class Form1 : Form
    {
        public static int[] PID_USB = new int[10];
        public static int[] VID_USB = new int[10];
        bool Led1_state = false;
        bool Led2_state = false;
        bool Led3_state = false;
        public static Int64 ticks = 0;
        int My_Device;
        bool Status_HID = false;        
        USBDeviceList USB_Devices;
        CyHidDevice USB_Host;

        public Form1()
        {
            InitializeComponent();
            USB_Devices = new USBDeviceList(CyConst.DEVICES_HID);

            USB_Devices.DeviceAttached += new EventHandler(USB_Devices_DeviceAttached);
            USB_Devices.DeviceRemoved += new EventHandler(USB_Devices_DeviceRemoved);
        }

        void Read_HID()
        {
            if (USB_Host.ReadInput())
            {
                richTextBox2.Clear();
                byte[] rcv = USB_Host.Inputs.DataBuf;
                for (int i = 1; i < USB_Host.Inputs.RptByteLen; i++)
                {
                    richTextBox2.Text += USB_Host.Inputs.DataBuf[i].ToString();
                    richTextBox2.Text += Environment.NewLine;
                }                 
            }
             
        }

        void USB_Devices_DeviceRemoved(object sender, EventArgs e)
        {
            USBEventArgs usbEvent = e as USBEventArgs;
            //label3.Text = usbEvent.FriendlyName + " removed.";             
        }

        void USB_Devices_DeviceAttached(object sender, EventArgs e)
        {
            USBEventArgs usbEvent = e as USBEventArgs;
            //label4.Text = usbEvent.Device.FriendlyName + " connected.";
        }
        
        private void button2_Click(object sender, EventArgs e)
        {            
            string text = richTextBox1.Text;
            byte[] data = System.Text.Encoding.ASCII.GetBytes(text); 
            var NewArray = new byte[data.Length + 2];
            data.CopyTo(NewArray, 2);
            NewArray[1] = 0x02;
            data = NewArray;
            USB_Host.Outputs.DataBuf = data;
            USB_Host.WriteOutput();            
        }

        private void detectHIDDevicesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            int i;
            HID_Connected.DropDownItems.Clear();
            ToolStripMenuItem[] items = new ToolStripMenuItem[USB_Devices.Count];
            for (i = 0; i < USB_Devices.Count; i++)
            {
                USBDevice Devices = USB_Devices[i];
                PID_USB[i] = Devices.ProductID;
                VID_USB[i] = Devices.VendorID;
                items[i] = new ToolStripMenuItem();
                items[i].Name = "SubItem" + i.ToString();
                items[i].Text = Devices.Product;
                if (Devices.Product == "CCS HID Demo")
                {
                    items[i].Click += new EventHandler(MenuItemClickHandler);
                    My_Device = i;
                }                
            }
            HID_Connected.DropDownItems.AddRange(items);
        }        

        private void MenuItemClickHandler(object sender, EventArgs e)
        {
            ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
            // Take some action based on the data in clickedItem
            USB_Host = USB_Devices[VID_USB[My_Device], PID_USB[My_Device]] as CyHidDevice;
            if (USB_Host != null)
            {
                Status_HID = true;
                ovalShape1.FillColor = Color.GreenYellow;
                ovalShape1.FillGradientColor = Color.WhiteSmoke;
                ovalShape1.BorderColor = Color.LawnGreen;
                label1.Text = "On";
            }
            else
            {
                Status_HID = false;
                label1.Text = "Off";
            }

        }      
        
        private void Led1(object sender, EventArgs e)
        {
            if (Led1_state == false)
            {
                ovalShape2.FillColor = Color.Red;
                ovalShape2.FillGradientColor = Color.WhiteSmoke;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x00;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();   

            }
            else
            {
                ovalShape2.FillColor = Color.Maroon;
                ovalShape2.FillGradientColor = Color.SaddleBrown;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x00;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();  
            }
            Led1_state = !Led1_state;
        }

        private void Led2(object sender, EventArgs e)
        {
            if (Led2_state == false)
            {
                ovalShape3.FillColor = Color.CornflowerBlue;
                ovalShape3.FillGradientColor = Color.WhiteSmoke;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x01;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();  
            }
            else
            {
                ovalShape3.FillColor = Color.MidnightBlue;
                ovalShape3.FillGradientColor = Color.DarkSlateBlue;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x01;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();  
            }
            Led2_state = !Led2_state;
        }

        private void Led3(object sender, EventArgs e)
        {
            if (Led3_state == false)
            {
                ovalShape4.FillColor = Color.GreenYellow;
                ovalShape4.FillGradientColor = Color.WhiteSmoke;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x02;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();  
            }
            else
            {
                ovalShape4.FillColor = Color.DarkGreen;
                ovalShape4.FillGradientColor = Color.DimGray;
                var NewArray = new byte[64];
                NewArray[1] = 0x01;
                NewArray[2] = 0x02;
                USB_Host.Outputs.DataBuf = NewArray;
                USB_Host.WriteOutput();  
            }
                Led3_state = !Led3_state;
        }

        private void button2_Click_1(object sender, EventArgs e)
        {
            richTextBox1.Clear();
        }      

        private void button4_Click(object sender, EventArgs e)
        {
            var NewArray = new byte[64];
            NewArray[1] = 0x03;
            USB_Host.Outputs.DataBuf = NewArray;
            USB_Host.WriteOutput();
            Read_HID();
        }

        private void TimerTicks(object sender, EventArgs e)
        {
            var NewArray = new byte[64];
            NewArray[1] = 0x03;
            USB_Host.Outputs.DataBuf = NewArray;
            USB_Host.WriteOutput();
            Read_HID();
        }

        private void Switch(object sender, EventArgs e)
        {
            int value = 0;
            if (trackBar1.Value == 0)
            {
                textBox1.Clear();
                timer1.Stop();
                timer1.Enabled = false;
            }
            else
            {
                value = Int16.Parse(textBox1.Text);
                timer1.Interval = value;
                timer1.Start();
                timer1.Enabled = true;
            }
        }          
    }
     
}

Download Zone!

Files:
USB HID CCS Demo - Microcontroller USB HID Demo - Visual C# Simulation USB HID Demo USB HID Video..

Human Interface Devices

noreply@blogger.com (Jeffrey Boy) — Thu, 5 Dec 2013 13:27:00 -0800

History of the Universal Serial Bus (USB) is quite short compare to RS232 for example. Development started in 1994 by effort of six companies - IBM, Compaq, Intel, Microsoft, NEC, Nortel and DEC. The first idea was to develop universal bus simple to use with small and compact connectors (to reduce many connectors in the personal computers). To have a possibility to connect devices such as digital cameras, webcams (or any other devices with big data transfers in a short time), there was also requirement for high transfer speeds.

1995 - USB Implementers Forum (USB-IF) was formed on the First Windows Hardware Engineering <>Conference (WinHec). During this conference Intel introduced first USB silicon.
1996 - USB Specification 1.0 was released.
1997 - Membership increased in the USB-IF to 400 members. In the world was developed more than 500 USB products this year.
2000 - USB 2.0 was released.
2001 - Standardization of USB 2.0 by USB-IF.
2008 - USB 3.0 announced by USB 3.0 Prometer Group.

Low speed and full speed baud rates were included in the USB 1.1 specification. High speed came with USB 2.0 in the year 2000. High speed USB was some attack to compete with Firewire Serial Bus (IEEE1394a), which was developed and presented in 1995 by Apple. It was basically developed for big data transfers (e.g. digital video transfers), so the baud rates were 100, 200, or 400 Mbits/s. In 1995 Firewire had no competitors, because USB 1.0 could not compete wit it. USB 2.0 was little bit faster than Firewire400, but it was changed in the year 2002 by presenting Firewire800 (IEEE1394b with maximal baud rate 800 Mbits/s).

Hardware Description

Figure 1.- USB Connectors

On the figure 1 are shown the three most used types of USB connectors. Typically we can find sockets type 'A' on the computer main boards and on the hubs. Type 'B' sockets are situated on the devices ('B' plug are always connected downstream). So the upstream and downstream connectors are not mechanically interchangeable. Cables, where are e.g. both connectors of the same type, are prohibited by the specification (except cables for bridges used to connected two computers together). Because Type 'B' connector is not suitable for small devices (9 because of its size), mini-USB 'B' connectors were developed. In the table 1 there is shown connection of the pins.

Table 1.- Description of the USB pins

Pin	Name	Cable Color	Description
1	VCC	Red	+ 5 V DC
2	D -	White	Data -
3	D +	Green	Data +
4	GND	Black	Ground
x	may not be used, connected to GND or used as attachment identification for some devices

Voltage levels of the USB communication depend of course on the baud rate. In the USB specification are defined three different baud rates:

Low speed - 1.5 Mbits/s
Full speed - 12 Mbits/s
High speed - 480 Mbits/s

Low speed is usually used for HIDs (Human Interface Devices) like a mouse, joystick, keyboard. USB cable contains four wires. On the borders are wires V_BUS and GND, in the center is twisted pair marked as D+ and D- (see figure 2). Power supply wires (V_BUS and GND) are useful, because smaller devices can be powered directly from the bus by these wires. USB is a half-duplex bus with differential coding. Thanks to this fact, it is robust to the electromagnetic disturbances. This bus uses NRZI (Non Return to Zero Inverted) coding. This means, that small logical values are not directly represented by different voltage levels. Important for this bus is changing state (transition)from one voltage level to another. Transition means logical zero and steady state means logical one. Although this bus is so fast, there is no extra wire for clock synchronization, but if the state is not changed 6x(six long. ones), one synchronization zero is added.

Figure 2.- USB cable structure

Voltage levels for logical values are different for different baud rates. For full and low speed devices are shown typical configurations on the figure 3 and figure 4.

Figure 3.- Typical configuration for the full speed devices Figure 4.- Typical configuration for the low speed devices

If no device is connected to the host, pull-down resistors (15 KΩ) cause ground on both data lines. This state is also called SE0 (Single Ended Zero) and because it can not appear during ordinary data transfer, it's used for special events (e.g. reset, end of packet). Full speed devices have installed pull-up resistor on the D+ line while low speed devices on the D- line. If the device is connected to the host, only on one line will be voltage different from the ground (voltage will be approximately 3V thanks to the voltage divider - 1,5 KΩ : 15KΩ). This is used to recognize baud rate of the device. If it is high speed device, it has 1,5KΩ resistor on the D+ (as full speed device, but with additional identification after reset). If both sides support high speed USB, 1,5 KΩ resistor in the device is unplugged by transistor and another 90 Ω resistor is connected between D+ and D-, that is necessary for impedance adjustment with twisted pair.

What is a HID?

The human interface in the name suggests that HIDs interact directly with people, and many HIDs do. A mouse may detect when someone presses a key or moves the mouse, or the host may send a message that translates to a joystick effect that the user experiences. Besides keyboards, mice, and joysticks, the HID class encompasses front panels with knobs, switches, buttons, and sliders; remote controls, telephone keypads; and game controls such as data gloves and steering wheels.

But a HID doesn't have to have a human interface. The device just need to be able to function within limits of the HID class specification. These are the major abilities and limitations of HID-class devices:

All data exchanged resides in structures called reports. The host sends and receives data by sending and requestiing reports in control or interrupt transfers. The report format is flexible an can handle just about any type of data, but each defined report has a fixed size.
A HID interface must have and interrupt IN endpoint for sending Input reports.
A HID interface can have at most one interrupt IN endpoint and one interrupt OUT endpoint. If you need more interrupt endpoints, you can create a composite device that contains multiple HIDs. An application must obtain a separate handle for each HID in the composite device.
The interrupt IND endpoint enables the HID to send information to the host at unpredictable times. For example, there's no way for the computer to know when a user will press a key on the keyboard, so the hosts drive uses interrupt transactions to poll the device periodically to obtain new data.
The rate of data exchange is limited, especially at low and full speeds. A host can guarantee a low-speed interrupt endpoint no more than 800 bytes/sec. For full-speed endpoints, the maximum is 64 kilobytes/sec., and for high-speed endpoints, the maximum is about 24 Megabytes/sec. if the host supports high-bandwidth endpoints and about 8 Megabytes/sec. if not. Control transfers have no guaranteed bandwidth except for the bandwidth reserved for all control transfers on the bus.
Windows 98 Gold (original edition) supports USB 1.0, so interrupt OUT transfers aren't supported and all host to device reports must use control transfers.

Any device that can live within the class's limits is a candidate to be a HID. THe HID specification mentions bar-code readers, thermometers, and voltmeters as example of HIDs that might not have a conventional human interface. Each of these sends data to the computer and may also receive requests that configure the device. Examples of devices that mostly receive data are remote displays, control panels for remote devices, robots, and devices of any kind that receive occasional or periodic commands from the host.

A HID interface may be just one of multiple USB interfaces supported by a device. For example, a USB speaker that uses isochronous transfers for audio may also have a HID interface for controlling volume, balance, treble and bass. A HID interface is often cheaper than traditional physical controls on a device.

References

Sources:
Human Interface Device (HID) Profile Device Class Definition for Human Interface Devices USB interface for data recording from the heat meter USB Complete 3rd Edition

Fiber-Optic Sensors

noreply@blogger.com (Jeffrey Boy) — Tue, 26 Nov 2013 20:07:00 -0800

The development of fiber-optic technology was mainly driven by the requirement of the telecommunications industry. Nonetheless one should not overlook that telecommunications is not the only application of fiber optics. The other major application area is in metrology and data acquisition.

Why Sensors? Why Fiber-Optics?

It used to be that in any major machinery or installation, gauges were located wherever that relevant information was present: a thermometer at the boiler, a tachometer at the shaft, a fuel gauge at the tank, etc. Staff could then go to these locations and take readings. Meanwhile the trend is that data acquisition and display are separated. For example, consider an airplane: Sticking out a mercury thermometer is obviously not a good idea for measuring the outside temperature. Fuel tanks are in the wings; who would climb out there to check a level tube? Instead,a ll data of interest are acquired at their respective location with sensors. The sensor's response is transmitted, usually by cable, to a central monitoring station where all displays are side by side to provide an overview. In the airplane this location is in the cockpit where the pilot can check all instruments without leaving his seat.

Industrial installations, too, have a central control room where all information comes together. It is not only time.saving when staff do not need to walk around the premises to take instrument readings, but it also minimizes risks to human because often date are taken in hard-to-reach or dangerous places, such as inside chimneys, in high-voltage apparatus, or in numerous places inside nuclear power stations.

To go by such a remote sensor concept, there are three ingredients required:

Sensors for any physical quantity that may be of interest. This includes temperature, pressure, stress and strain, distance, filling level, speed, force, vibration, etc. The sensors must translate such quantities into a format that can easily be transmitted.
Transmission lines.
Displays that translate the transmitted data into a format accessible to human senses, i.e., typically make them visible or audible.

Of course, the scheme also facilitates the keeping of records of relevant data; witness the "flight recorder" which is of central importance after a plane crash. It has often been taken for granted that for the transmission one uses an electric quantity: most often a voltage, but there is at least one standard where this is a current. The lines are then usually copper cables. The advantages of this approach is that there are innumerably many suppliers, and sensors can be picked from an unfathomable variety of hardware. Also, there is an abundant supply of well-trained engineers and technicians who are knowledgeable about this technology and can use it very efficiently.

Now enter optical fiber. First, one might have the idea of using sensors that do not translate the original data into an electric format, but rather into some optical format, like a light intensity or wavelength. There is no difficulty in converting this to a display because optical formats are easily assessed at the receiver. All it takes is a photodetector, and one is back to a voltage or current that can be displayed in a routine way. Of course, the question is: if one eventually converts to electrical anyway, why bother with optics?.

The point is that during transmission, the data are in an optical format. While on its way across the distance, plenty of adverse effects can act on the transmitted signal. In the case of electric cables, one severe problem is interference from external electromagnetic fields. To avoid such difficulty, one usually provides shielding, which in the case of strong external fields is quite involved. Optical fiber, by contrast, is immune to that kind of interference.

There are some other properties of optical fibers that are advantageous in this context. As we saw earlier, they are small and lightweight. The accompanying savings in space and weight can be quite important, e.g., in vehicles, in particular in aircraft or spacecraft. Also, optical fibers withstand extreme temperatures better than electrical cables. They are also more robust in the presence of aggressive chemicals. Finally, fibers provide perfectly separated electrical potentials, a fact that is greatly appreciated, e.g., in petrochemical installations. We see, one might have benefits from an optical technology. It is good news that a wide variety of optical sensors is available. There is hardly any physical quantity for which no optical sensor exist. New sensor are added all the time for chemical and other quantities, too.

When we look at these fiber-optic sensors, we nee to broadly distinguish two classes (figure 1): There are sensors that are mounted in front of, next to, or in proximity of the fiber, read the quantity under investigation, and launch a corresponding light signal into the fiber. In this case, the fiber is merely the transmission medium and has nothing to do with the acquisition of the original quantity. Such sensors are called extrinsic. In contrast, intrinsic sensors use the fiber itself or part of it directly to read the original quantity. Then the fiber is both sensor and cable at he same time. We will look at examples of both types.

Figure 1.- Classification of sensor types. extrinsic and intrinsic sensors.

In this case an optical fiber leads up to a "black box" that impresses information onto the light beam in response to an environmental effect. The information could be impressed in terms of intensity, phase, frequency, polarization, spectral content, or other methods. An optical fiber then carries the light with the environmentally impressed information back to an optical and/or electronic processor.In some cases the input optical fiber also acts as the output fiber. The intrinsic or all-fiber sensor shown in figure 1 (a) uses an optical fiber to carry the light beam, and the environmental effect impresses information onto the light beam it is in the fiber. Each of these classes of fibers in turn has many subclasses with, in some cases, sub-subclasses that consist of large numbers of fiber sensors. In some respects the simplest type of fiber optic sensor is the hybrid type that is based on intensity modulation.

References

Sources:
Fedor Mitschke,Fiber Optics, Physics and Technology Shizhuo Yin, Fiber Optic Sensors

Nature and properties of light

noreply@blogger.com (Jeffrey Boy) — Sun, 24 Nov 2013 18:54:00 -0800

Photonic is defined as the generation, manipulation, transport, detection, and use of light information and energy whose quantum unit is the photon. Photonics is based on the science of optics and electronics. The origins of optical technology (photonics) date back to the remote past. In the coming century, photonics promises to be a vital part of the information revolution.

To enable us to understand and apply photonics, it is necessary to have a basic understanding of the behavior and properties of light.

Photonics Opportunities

There are ten broad areas of employment that are likely to need increasing numbers of photonics technicians:

Table 1.- Photonics Opportunities

Photonics Opportunities
1.- Medicine - biomedical	2.- Environmental
3.- Energy	4.- Transportation
5.- Defense	6.- Public safety
7.- Aerospace	8.- Computers
9.- Energy	10.- Manufacturing with photonics and test and analysis
11.- Communication and information technology

What is light? This question has been debated for many centuries. The sun radiates light, electric lights brighten our darkness, and many others uses of light impact our lives daily. The answer, in short, is light is a special kind of electromagnetic energy.

The speed of light, although quite fast, is not infinite. The speed of light in the vacuum is expressed as c = 2.99 x 10⁸ m/s. Light travels in the vacuum at a constant speed, and this pseed is considered a universal contant. It's important to note that speed changes for light traveling trough nonvacuum media such as air (0.03% slower) or glass (30.0% slower)

For most purpose, we may represent light in terms of its magnitud and direction. In a vacuum, light will travel in a straight line at fixed speed, carrying energy from one place to another. Two key properties of light interacting with a medium are:

1.- It can be deflected upon passing from one medium to another (refraction).
2.- It can be bounced off a surface (reflection).

The field of detection and measurement of light energy is called radiometry. It uses a standardized system for characterizing radiant energy. Table 2 defines the standard terms used.

Table 2.- Radiometric Definition and Units

Term	Definition	Symbol	Units
Quantity	Radiant energy	Q	Joule (J)
Flux	Rate of radiant energy	Φ	Watt (W); Joule/second (J/s)
Flux density(irradiance)	Flux per unit area	E	Watts per square meter (W/m²)
Intensity	Flux per solid angle	I	Watts per steradian (W/sr)
Radiance	Flux per unit area per unit solid angle	L	Watts per square meter per steradian (W/m²⋅sr)
Spectral radiance	Radiance per unit wavelength	L_λ	Watts per square meter steradian per nanometer ^W⁄_{(m²⋅sr⋅Δλ)}

Dual Nature of Light

Scientist build models of physical processes to help them understand and predict behavior. So it is with light energy. It is through seeing the effects of light that the models are developed. Scientists have observed that light energy can behave like a wave as it moves through space, or it can behave like a discrete particle with a discrete amount of energy (quantum) that can be absorbed and emitted. As we study and use light, both models are helpful

Concept of a photon

The particle-like nature of light is modeled with photons. A photon has no mass and no charge. It is carrier of electromagnetic energy and interacts with others discrete particles (e.g., electrons, atoms, and molecules).

A beam of light is modeled as a stream of photons, each carrying a well-defined energy that is dependent upon the wavelength of the light. The energy of a given photon can be calculated by:

Photon energy (E = hc/λ)

Where E is in joules

h = Planck's constant = 6.625 x 10 ^-34 J⋅s.
c = Speed of light = 2.998 x 10 ^{8/sup> m/s.

λ = Wavelength of the light in meters.}

When ultraviolet light shines on some metal surfaces, it causes electrons to be emitted. This effect is shown in figure 1, the photoelectric effect did not produce results that matched the early predictions of wave theory. Two concerns were:

Figure 1.- Photoelectric effect

1.- More intense radiation (larger-amplitude waves) did not cause emitted electrons to have more energy.
2.- The energy of the emitted electron was dependent on the wavelength of the light, not the amplitude of the wave.

In the photoelectric effect experiment shown in figure 1, light strikes as a metal plate. Electrons are immediately released. The flow of electricity in the external circuit can be measured and the number of electrons generated for a given light signal can be determinated

If light were a continuous wave, it might wash over the metal surface and interact with the electrons to give them the needed energy to escape at lower light levels (intensities), but only after long delays. However, faint light at high frequencies (short wavelengths) caused the immediate release of electrons. Thus, light knocked the electrons out of the metal surface as if the light were made of particles — photons.

There is a minimum energy threshold for an electron to escape from the metal. Photons with frequencies below a given threshold eject no electrons, no matter how intense the light. Photons with frequencies above the threshold do eject electrons, no matter how low the intensity. The energy of the released electrons can be calculated from the next equation:

E_e-= hc/λ - p

where:
p = Characteristic escape energy for the metal.
E_e- = The kinetic energy of an escaping electron.
hc/λ = The energy of the photon of wavelength λ.

Wave Model

The particle-like model of light describes large-scale effects such as light passing through lenses or bouncing off mirrors. However, a wavelike model must be used to describe fine-scale effect such as interference and diffraction that occur when light passes through small openings or by sharp edges. The propagation of light or electromagnetic energy through space can be described in terms of a traveling wave motion. The wave moves energy — without moving mass — from one place to another at a speed independent of its intensity or wavelength.

This wave nature of light is the basis of physical optics and describes the interaction of light with media. Many of these processes require calculus and quantum theory to describe them rigorously.

Characteristics of light waves

To understand light waves, it is important to understand basic wave motion itself. Water waves are sequence of crest (high points) adn troughs (low points) that "move" along the surface of the water. When ocean waves roll in toward the beach, the line of crests and troughs is seen as profiles parallel to the beach. An electromagnetic wave is made of an electric field and a magnetic field that alternately get weaker and stronger. The directions of the fields are at right angles to the direction the wave is moving, just as the motion of the water is up and down while a water wave moves horizontally. Figure 2 is the representation of the electric and magnetic field.

Figure 2.- Representation of the electromagnetic wave.

The maximum value of the wave displacement is called the amplitude (A) of the wave. The cycle starts at zero and repeats after a distance. This distance is called the wavelength (λ). Light can have different wavelengths, such as the blue light and red light shown in figure 2. The inverse of the wavelength (1/λ) is the wave number (v), which is expressed in cm^-1. The wave propagates at a wave speed (v). This wave speed in a vacuum is equal to c, and is less than c in a medium. At a stationary point along the wave, the wave passes by in a repeating cycle. The time to complete one cycle is called the cycle time or period (τ) and can be calculated using the next equation:

τ = λ/v

Another important measure of a wave is its frequency (f). It is measured as the number of waves that pass a given in one second. The unit for frequency is cycles per second, also called hertz (Hz). As can you see, the frequency and the period are reciprocals of one another. If the wave speed and wavelength are known, the frequency can be calculated with the next equation:

f = 1/τ = v/λ

It is possible for a wave to have other than sinusoidal shapes; however, the important concept to remember is that light waves are transverse electric and magnetic fields changing in space and time and propagating at the speed of light in a given medium, as we show below.

Figure 3.- A wire-grid polarizer converts an unpolarized beam into one with a single linear polarization.

Light waves are complex. They are not one-dimensional waves but rather are composed of mutually perpendicular electric and magnetic fields with wave motions at right angles to both fields, as illustrated in figure 3. The wave carries light energy with it. The amount of energy that flows per second across a unit area perpendicular to the direction of travel is called the irradiance (flux density) of the wave.

Electromagnetic waves share six properties with all forms of wave motion:

Polarization
Superposition
Reflection
Refraction
Diffraction
Interference

References

Sources:
Linda J. Vandergriff,Fundamentals of photonics Ajoy Ghatak, Introduction to fiber optic Gerd Keiser, Optical fiber communications Fedor Mitschke, Fiber Optics

TMP100 - Pinguino OTG

noreply@blogger.com (Jeffrey Boy) — Sat, 16 Nov 2013 15:18:00 -0800

El TMP100 y TMP101 son dispositivos comúnmente conocidos como "two-wire", caracterizado por soportar transmisiones en dos direcciones simultáneamente, disponibles en encapsulados SOT23-6. Para su funcionamiento estos no requieren de circuiteria adicional, agregando también que la resolución de estos sensores es de 0.0625 °C. Ademas estos presentan compatibilidad SMBus e I2C, permitiendo hasta 8 dispositivos en el mismo bus.

TMP100 y TMP101 son ideales para la medición de temperatura en diferentes medios. El rango de operación oscila entre los -55 °C y 125 °C.

Conexionado

Sistema de Conexionado Pinguino OTG - TMP 100

La interfaz de conexion es simple y no necesita de muchos componentes para su optimo funcionamiento, mas solo 2 resistores de 10 Kohm en modo pull-up necesarios para el SCL (clock input) y SDA (data I/O) del TMP100 que son requeridas por las especificacion I2C de Phillips.

Sistema de Operacion

La configuración de llamado del TMP100 soporta hasta 8 dispositivos por bus I2C mediante 2 pin de direccionamiento. En esta aplicación, ambos pines ADD0 y ADD1 serán puestos a GND, por lo que la dirección del TMP100 sera 0b1001000. Todo acceso al TMP100 requiere la dirección apropiada que consiste en la dirección del dispositivo mas 1 bit de lectura/escritura (adress+WR) seguido por la dirección del registro deseado a manipular, mas la configuración de dicho registro.

Proceso de configuración TMP100
1.- Inicio el I2C
2.- Envió la dirección apropiada del dispositivo (0x90 = 0b1001000(Adress) + 0(R/W))
3.- Direccion del registro 0x01 (configuracion de resolucion)
4.- Envio configuracion de resolucion (0x00 (9 bits),0x20 (10 bits), 0x40 (11 bits),0x60 (12 bits))
5.- Finalizo I2C
Proceso de lectura TMP100
1.- Inicio el I2C
2.- Envió la dirección apropiada del dispositivo (0x90 = 0b1001000(Adress) + 0(R/W))
3.- Direccion del registro 0x00 (lectura de temperatura)
4.- Envio peticion de lectura del registro (0x91 = 0b1001000(Adress) + 1(R/W))
5.- Finalizo I2C

Tabla 1.- Correspondencia al proceso de escritura/lectura TMP100.

La información mas detallada del funcionamiento del TMP100 se encontrara al final de la pagina en sus respectivo datasheet.

Codigo

/*----------------------------------------------------- 
Author: Jefferson Gova O'Neil--<>
Date: Sun Dec 23 23:35:47 2012
Description: Pinguino OTG - TMP 100, usando comunicacion I2C
programado y compilado en Windows x64, usando el IDE x.3 desatendido para windows.
-----------------------------------------------------*/
int Buffer[2];
float PRECISION = 0.00001;

void initI2C() 
     { 
         I2C1CON |= (1 << 15); 
         // 1 = Slew rate control disabled for Standard Speed mode (100 kHz); also disabled for 1 MHz mode 
         I2C1CONbits.DISSLW = 1; 
         // I2C1BRG = ((Fcy/FSCL) - (Fcy/10,000,000)) - 1 
         // In our case, Fcy = Fosc/2 => 40,000,000/2 => 20,000,000 
         // The desired FSCL = 100 kHz 
         // I2C1BRG = ((20,000,000/100,000) - (20,000,000/10,000,000)) - 1 
         // I2C1BRG = ((200) - (2)) - 1 
         // I2C1BRG = (198) - 1 = 197    
         I2C1BRG = 196; 
         //IntSetVectorPriority(INT_I2C1_VECTOR,2,2); 
         IFS0bits.I2C1MIF = 0; 
         IFS0bits.I2C1SIF = 0; 
         IFS0bits.I2C1BIF = 0; 
         IEC0bits.I2C1MIE = 0; 
         IEC0bits.I2C1SIE = 0; 
         IEC0bits.I2C1BIE = 0; 
     }
 
 void i2c_start(void) 
     { 
 
           int x = 0; 
 
           I2C1CONbits.ACKDT = 0; //Reset any previous Ack 
           delayMicroseconds(10); 
           I2C1CONbits.SEN = 1; //Initiate Start condition 
           Nop(); 
 
           //the hardware will automatically clear Start Bit 
           //wait for automatic clear before proceding 
           while (I2C1CONbits.SEN) 
           { 
           delayMicroseconds(1);            
           x++; 
           if (x > 100) break; 
           } 
 
          delayMicroseconds(2); 
 
     } 
 //*************************************************** 
     //function iniates a restart condition on bus 
     void i2c_restart(void) 
     { 
 
           int x = 0; 
 
           I2C1CONbits.RSEN = 1; //Initiate restart condition 
           Nop(); 
 
           //the hardware will automatically clear restart bit 
           //wait for automatic clear before proceding 
           while (I2C1CONbits.RSEN) 
           { 
           delayMicroseconds(1); 
           x++; 
           if (x > 100) break; 
           } 
 
           delayMicroseconds(2); 
 
     } 
 //*************************************************** 
     //Resets the I2C bus to Idle 
     void reset_i2c_bus(void) 
     { 
 
           int x = 0; 
 
           //initiate stop bit 
           I2C1CONbits.PEN = 1; 
 
           //wait for hardware clear of stop bit 
           while (I2C1CONbits.PEN) 
           { 
           delayMicroseconds(1); 
           x ++; 
           if (x > 100) break; 
           } 
 
           I2C1CONbits.RCEN = 0; 
           IFS0bits.I2C1MIF = 0; // Clear Interrupt 
           I2C1STATbits.IWCOL = 0; 
           I2C1STATbits.BCL = 0; 
           delayMicroseconds(10); 
 
     } 
 //*************************************************** 
     //basic I2C byte send 
     char send_i2c_byte(int data) 
     { 
 
           short i; 
 
           while (I2C1STATbits.TBF) { } 
           IFS0bits.I2C1MIF = 0; // Clear Interrupt 
           I2C1TRN = data; // load the outgoing data byte 
 
           // wait for transmission 
           for (i=0; i<5000; i++) 
           { 
           if (!I2C1STATbits.TRSTAT) break; 
           delayMicroseconds(1); 
           } 
           if (i == 5000) 
           { 
           return(1); 
           } 
 
           // Check for NO_ACK from slave, abort if not found 
           if (I2C1STATbits.ACKSTAT == 1) 
           { 
           reset_i2c_bus(); 
           return(1); 
 
           } 
           delayMicroseconds(2); 
           return(0); 
 
     } 
 
 
 //*************************************************** 
     //function reads data, returns the read data, no ack 
     char i2c_read(void) 
     { 
 
           int i = 0; 
           char data = 0; 
 
           //set I2C module to receive 
           I2C1CONbits.RCEN = 1; 
 
           //if no response, break 
           while (!I2C1STATbits.RBF) 
           { 
           i ++; 
           if (i > 5000) break; 
           } 
 
           //get data from I2CRCV register 
           data = I2C1RCV; 
 
           //return data 
           return data; 
 
     } 
 //*************************************************** 
     //function reads data, returns the read data, with ack 
     char i2c_read_ack(void) //does not reset bus!!! 
     { 
 
           int i = 0; 
           char data = 0; 
 
           //set I2C module to receive 
           I2C1CONbits.RCEN = 1; 
 
           //if no response, break 
           while (!I2C1STATbits.RBF) 
           { 
           i++; 
           if (i > 5000) break; 
           } 
 
           //get data from I2CRCV register 
           data = I2C1RCV; 
 
           //set ACK to high 
           I2C1CONbits.ACKEN = 1; 
 
           //wait before exiting 
           delayMicroseconds(10); 
 
           //return data 
           return data; 
 
     }  
 
 
 //*************************************************** 
     void I2Cwrite(char addr, char subaddr, char value) 
     { 
 
           i2c_start(); 
           send_i2c_byte(addr); 
           send_i2c_byte(subaddr); 
           send_i2c_byte(value); 
           reset_i2c_bus(); 
 
     }     
 //*************************************** 
 void I2Cgets(int addr, int subaddr,int length, int *data){
           int i = 0,counter = 0;
           i2c_start(); 
           send_i2c_byte(addr); 
           send_i2c_byte(subaddr); 
           delayMicroseconds(10); 
 
           i2c_restart(); 
           send_i2c_byte(addr | 0x01); 
           //set I2C module to receive 
           I2C1CONbits.RCEN = 1; 
 
           //if no response, break 
           while (!I2C1STATbits.RBF) 
           { 
           i++; 
           if (i > 5000) break; 
           }
         data[0] = I2C1RCV;  // store received data 
         while (IFS0bits.I2C1MIF == 0); 
         IFS0bits.I2C1MIF = 0;     counter = 1; 
         while (length != counter) 
         { 
             I2C1CONbits.ACKDT = 0; //Ack received data 
             I2C1CONbits.ACKEN = 1; 
             while (I2C1CONbits.ACKEN == 1);         I2C1CONbits.RCEN = 1; 
             while (I2C1CONbits.RCEN == 1); 
             data[counter] = I2C1RCV; 
             while (IFS0bits.I2C1MIF == 0); 
             IFS0bits.I2C1MIF = 0; 
             counter++; 
         } 
         I2C1CONbits.ACKDT = 1; //NAck received data 
         I2C1CONbits.ACKEN = 1;
 reset_i2c_bus(); 
 }
 
 char I2Cread(char addr, char subaddr) 
     { 
 
           char temp; 
 
           i2c_start(); 
           send_i2c_byte(addr); 
           send_i2c_byte(subaddr); 
           delayMicroseconds(10); 
 
           i2c_restart(); 
           send_i2c_byte(addr | 0x01); 
           temp = i2c_read(); 
 
           reset_i2c_bus(); 
           return temp; 
 
     } 
 //************************************     
     unsigned char I2Cpoll(char addr) 
     { 
 
           unsigned char temp = 0; 
 
           i2c_start(); 
           temp = send_i2c_byte(addr); 
           reset_i2c_bus(); 
 
           return temp; 
 
     }

void ReadTemperature(){
float Temperature;
unsigned char BufferTemperature[20]={};
char* StringTemperature =&BufferTemperature;

Temperature =((((Buffer[0]*256)|Buffer[1])>>4)*.0625);
StringTemperature = dtoa(BufferTemperature,Temperature);
CDC.printf("Temperatura : %s C\r\n", StringTemperature);
} 



void setup() {
    //run once:
    initI2C(); 
    }

void loop() {
    //run repeatedly:
    char dato = 0;
    I2Cwrite(0x90, 0x01, 0x60);
    I2Cgets(0x90,0x00,2,Buffer); 
    delay(1000);
    ReadTemperature();
    }

Download Zone

Float to String
TMP100.pdf
PINGUINO OTG - TMP100

Jeal's Blog

Fanuc Alarm 466 – Z Axis: Motor/Amp Combination

Download Zone!

Master Prog USB

Download Zone!

Prácticas - Interpretacion de manuales Tecnicos

Pinguino - Lecturas Digitales y Analogicas

Esquematico

Download Zone!

Pinguino Board - Primer Contacto

Esquematico

Download Zone!

Instalando Pinguino

Stepper Motor using a Pinguino Board

Principle of Operation

Stepper Motor Advantages and Disadvantages

Pinguino — Stepper Motors

Schematic

PIC C CCS COMPILER CODE

PINGUINO BOARD CODE

Download Zone!

How to Make Your Dreams Come True

Steps

1.- Be specific bout your dream.

2.- Turn your dream into a burning desire.

3.- Turn your burning desires into goals.

4.- Plan.

5.- Take action now.

6.- Set short-term goals.

7.- Review your progress regularly.

8.- Knowledge; Knowing exactly what is your dream and accepting that is exactly what you want.

9.- Visualization; Have a vivid picture in your mind or video of how your dream will be when you accomplish it.

10.- Be confident; Have no doubts in yourself what so ever, this will lead to reverse thinking which will surround you with negative energy and you will receive a corresponding negative result.

11.- Meditate; Relax and calm your mind, soul and body.

12.- USing the above steps and work towards your dream with all your focus, concentration and confidence.

Edited by Michael Igioh, Puddy, Maluniu, Krystle and 20 others.

Comunicación Serial (UART)

Esquematico

Comunicación Serial (UART)[Emisor Firmware "Emisor.h"]

Comunicación Serial (UART)[Emisor Firmware "Emisor.c"]

Comunicación Serial (UART)[Receptor Firmware "Receptor.h"]

Comunicación Serial (UART)[Receptor Firmware "Receptor.c"]

Download Zone!

USB HID CCS DEMO

Schematic

USB HID CCS[Microcontroller Firmware "USB_HID.h"]

USB HID CCS [Microcontroller Firmware "USB_HID.c"]

C# Software [USB HID Demo]

Download Zone!

Human Interface Devices

Hardware Description

What is a HID?

References

Fiber-Optic Sensors

Why Sensors? Why Fiber-Optics?

References

Nature and properties of light

Photonics Opportunities

Dual Nature of Light

Concept of a photon

Wave Model

References

TMP100 - Pinguino OTG

Conexionado

Sistema de Operacion

Codigo

Download Zone