/*
* Firmware framework for USB I/O on PIC 18F2455 (and siblings)
* Copyright (C) 2005 Alexander Enzmann
* adapted to MCC18 by Alberto Maccioni on 1/8/09
* re-adapted to SDCC 2.9.0 by Enrique Olivares (EOL) on 22/06/10
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
* or see <http://www.gnu.org/licenses/>
*/
#include <pic18f4550.h>
#include <stdio.h>
#include <string.h>
#include "usb.h"
// Note: there are timing related problems associated with GET_FEATURE
// when run at less than 48 MHz
#define CLK_48MHZ 1
// Define configuration registers (fuses)
#if defined(pic18f2550) || defined(pic18f2455) || defined(pic18f4550) || defined(pic18f4455)
#if CLK_48MHZ
code char at 0x300000 CONFIG1L = 0x24; // USBDIV=2(0x20), CPUDIV=no dividido(0x00),PLLDIV=5(0x04) 20MHz
#else
code char at 0x300000 CONFIG1L = 0x3c; // USB, /6 post (16MHz), /5 pre (20 MHz)
#endif
code char at 0x300001 CONFIG1H = 0x0e; // (FOSC xtal alta velocidad,PLL enable) (0x01),FCMEN disable(0x00), IESO disable (0x00)
code char at 0x300002 CONFIG2L = 0x3d; // PWRTE disa(0x01),BODEN ena at start, disa on sleep (0x04),BORV 2.0(0x18),VREGEN ena (0x20)
code char at 0x300003 CONFIG2H = 0x1e; // WDT disable(0x00), WDTPS post scaler 1:32768(0x1e)
code char at 0x300004 CONFIG3L = 0xff; // Unused configuration bits
code char at 0x300005 CONFIG3H = 0x00; // CCP2MX RB3(0x00), PBADEN digital(0x00), LPT1OSC disa(0x00), MCLRE disa (a Vdd)(0x00)
code char at 0x300006 CONFIG4L = 0x81; // STVREN ena pila llena(0x01), LVP disa(0x00),XINST disa(0x00), DEBUG disa in-circuit(0x80)
code char at 0x300007 CONFIG4H = 0xff; // Unused configuration bits
code char at 0x300008 CONFIG5L = 0x0f; // Proteccion de codigo: disable CP_0(0x0), CP_1(0x02), CP_2(0x04), CP_3(0x08)
code char at 0x300009 CONFIG5H = 0xc0; // CPB disable(0x40)
code char at 0x30000A CONFIG6L = 0x0f; // WRT disable: WRT_0(0x01), WRT_1(0x02), WRT_2(0x04), WRT_3(0x08)
code char at 0x30000B CONFIG6H = 0xe0; // WRTC disable: WRTC disa (0x20), WRTB disa (0x40)
code char at 0x30000C CONFIG7L = 0x0f; // EBTR disable: EBTR_0 disa(0x01), EBTR_1 disa (0x02), EBTR_2 disa (0x04), EBTR_3 disa (0x08)
code char at 0x30000D CONFIG7H = 0x40; // EBTRB disable (0x40)
#endif
// HID feature buffer
//~ volatile unsigned char HIDFeatureBuffer[HID_FEATURE_REPORT_BYTES];
/******************************************************************************/
void high_isr(void) shadowregs interrupt 1
{
if(PIR2bits.USBIF)
{
ProcessUSBTransactions();
UIRbits.SOFIF = 0;
UIRbits.URSTIF = 0;
PIR2bits.USBIF = 0;
UEIR = 0;
}
}
/******************************************************************************/
void low_isr(void) shadowregs interrupt 2
{
;
;
}
// Allocate buffers in RAM for storage of bytes that have either just
// come in from the SIE or are waiting to go out to the SIE.
volatile char txBuffer[HID_INPUT_REPORT_BYTES];
volatile char rxBuffer[64];
unsigned int timestamp=0;
extern byte transferType;
//Probando ADC.
//Espacio temporal para el resultado de la conversion.
unsigned char adch = 0x00;
unsigned char adcl = 0x00;
//Cachureos para probar.
unsigned char adchaux = 0x00;
unsigned char adclaux = 0x00;
unsigned char esperaaux = 0x00;
unsigned char cuentasumaaux = 0x00;
//Campos de bits para banderas y semaforos.
typedef struct {
unsigned char flag01: 1;
unsigned char flag02: 1;
unsigned char flag03: 1;
} banderas;
//Un valor de 16 bit para el ADC.
unsigned int valor = 0;
//El resultado de la sumatoria de conversiones.
unsigned int sumavalor = 0;
//El promedio de las sumatorias.
unsigned int promedio = 0;
//El contador de las sumas de conversiones.
unsigned char cuentasumavalor = 0;
//Probando el ADC. Aqui el estado ADC GO/DONE. y otras cosas.
banderas estado_adc;
//Un contador para construir un tiempo de espera
unsigned char espera = 0;
/******************************************************************************/
// Entry point for user initialization.
void UserInit(void)
{
LATA=0;
TRISA=0b11111111; //Todas son entradas ahora, cuando pruebo el ADC.
LATB=0;
TRISB=0;
T0CON=0x80; // Timer0 period = T*2^16:2 = 5.46ms:2 = 10.93ms (PS=2)
LATC=0;
TRISC=0b00000000;
ADCON1 = 0b00001110; //Vref+=vss. Vref-=vdd. AN0 es entrada analoga, el resto es I/O digital.
TRISAbits.TRISA0=1;
ADCON0 = 0b00000000; //canal 0 (AN0). ADC en espera. ADC deshabilitado.
ADCON2 = 0b10000101; //justificado a la derecha. 0 Tad (inicio manual). Fosc/16
ADCON0bits.ADON = 1; //modulo ADC habilitado.
ADCON0bits.GO = 1; //Comienza conversion AD.
//Inicializa flags.
estado_adc.flag01 = 0;
estado_adc.flag02 = 0;
estado_adc.flag03 = 0;
//Inicializa cosas para el ADC.
sumavalor = 0;
espera = 0;
valor = 0;
cuentasumavalor = 0;
promedio = 0;
}
#define LOBYTE(x) (*((char *)&x))
#define HIBYTE(x) (*(((char *)&x)+1))
/******************************************************************************/
// If we got some bytes from the host, then echo them back.
static void USBEcho(void)
{
byte rxCnt,i=0;
if ((deviceState < CONFIGURED) || (UCONbits.SUSPND==1))
return;
// Find out if an Output report has been received from the host.
rxCnt=CDCgets(rxBuffer);
// If no bytes in, then nothing to do
if (rxCnt == 0)
return;
// Copy input bytes to the output buffer
// for (i=0;i<rxCnt;i++)
// txBuffer[i] = rxBuffer[i];
for(i=0;i<=32;i++)
{
while ( ADCON0bits.GO == 1 ){;}
txBuffer[2*i]=ADRESH;
if(i<32)
txBuffer[2*i+1]=ADRESL;
ADCON0bits.GO=1;
}
// As long as the SIE is owned by the processor, we let USB tasks continue.
while (EP_IN_BD(CDC_DATA_EP_NUM).Stat.UOWN)
// ProcessUSBTransactions();
;
if(strncmp(rxBuffer,"hola\r\n",6)==0)
CDCputs(txBuffer,62);
else
CDCputs("nada",4);
}
/******************************************************************************/
void ProcessIO(void)
{
// User Application USB tasks
if ((deviceState < CONFIGURED) || (UCONbits.SUSPND==1))
return;
// Process USB: Echo back any bytes that have come in.
USBEcho();
// Probando el ADC.
if ( ADCON0bits.GO == 0 )
{
if ( estado_adc.flag01 == 0 )
{
adch = ADRESH;
adcl = ADRESL;
estado_adc.flag01 = 1;
//Dos bytes de 8 en un word de 16.
valor = (int)ADRESL | ( (int)ADRESH << 8 );
sumavalor = sumavalor + valor;
cuentasumavalor++;
if ( cuentasumavalor >= 20 )
{
//Rescata el numero de sumatorias.
cuentasumaaux = cuentasumavalor;
//Calcula el promedio.
promedio = sumavalor / 20;
//Desarma el promedio de 16 bit en dos partes de 8 bits.
adchaux = HIBYTE(promedio);
adclaux = LOBYTE(promedio);
//Reinicia las areas de trabajo.
sumavalor = 0;
cuentasumavalor = 0;
promedio = 0;
}
}
espera++;
if ( espera >= 100 )
{
//Rescata tiempo de espera.
esperaaux = espera;
//Reinicia ADC.
ADCON0bits.GO=1;
//Reinicia flag de entrada.
estado_adc.flag01 = 0;
espera = 0;
}
}
}
/******************************************************************************/
// Handle control out. This might be an alternate way of processing
// an output report, so all that's needed is to point the output
// pointer to the output buffer
// Initialization for a SET_REPORT request. This routine will be
// invoked during the setup stage and is used to set up the buffer
// for receiving data from the host.
// void SetupOutputReport(byte reportID)
// {
// if (reportID == 0)
// {
// // When the report arrives in the data stage, the data will be
// // stored in HIDFeatureBuffer
// // inPtr = (byte*)&HIDRxBuffer;
// }
// }
/******************************************************************************/
// Post processing for a SET_REPORT request. After all the data has
// been delivered from host to device, this will be invoked to perform
// application specific processing.
// void SetOutputReport(byte reportID)
// {
//
// #if DEBUG_PRINT
// printf("SetOutputReport(0x%hx)\r\n", reportID);
// #endif
//
// // Currently only handling report 0, ignore any others.
// if (reportID != 0)
// return;
//
// // LATB=HIDRxBuffer[0];
//
// // x11 to signal SET_REPORT transfer
// LATBbits.LATB1=1;
// LATBbits.LATB0=1;
//
//
// // TBD: do something. Not currently implemented because the output
// // report is being handled by an interrupt endpoint.
// }
/******************************************************************************/
// Handle a control input report.
// void GetInputReport(byte reportID)
// {
//
// #if DEBUG_PRINT
// printf("GetInputReport: 0x%uhx\r\n", reportID);
// #endif
//
// if (reportID == 0)
// {
// byte i;
// // Send back the contents of the HID report
// // TBD: provide useful information...
// // outPtr = (byte *)&HIDTxBuffer;
//
// // // HIDTxBuffer[0]=PORTA;
// // // HIDTxBuffer[1]=0xF2; //this is to differentiate between different transfer types
// // // HIDTxBuffer[2]=HIBYTE(timestamp);
// // // HIDTxBuffer[3]=LOBYTE(timestamp);
// for(i=4;i<HID_INPUT_REPORT_BYTES;i++)
// // HIDTxBuffer[i]=HIDRxBuffer[i];
//
// // The number of bytes in the report (from usb.h).
// wCount = HID_INPUT_REPORT_BYTES;
// transferType=0;
// }
// }
void init_CDC()
{
INTCON=0;
INTCON2=0xC0;
UCON=0;
UCFG=0;
UEP0=0;UEP1=0;UEP2=0;UEP3=0;UEP4=0;UEP5=0;
UEP6=0;UEP7=0;UEP8=0;UEP9=0;UEP10=0;UEP11=0;
UEP12=0;UEP13=0;UEP14=0;UEP15=0;
// Initialize USB for CDC
UCFG = 0x14; // Enable pullup resistors; full speed mode
deviceState = DETACHED;
remoteWakeup = 0x00;
currentConfiguration = 0x00;
// And enable USB module
while(deviceState != CONFIGURED)
{
EnableUSBModule();
if(UCFGbits.UTEYE != 1)
ProcessUSBTransactions();
}
}
/******************************************************************************/
// Entry point of the firmware.
void main(void)
{
byte led_cnt=0;
// Set all I/O pins to digital
ADCON1 |= 0x0F;
PIE1=0;
PIE2=0;
// Initialize USB
// UCFG = 0x14; // Enable pullup resistors; full speed mode
//
// deviceState = DETACHED;
// remoteWakeup = 0x00;
// currentConfiguration = 0x00;
init_CDC();
PIE2bits.USBIE = 1;
INTCON = 0xC0;
// Call user initialization function
UserInit();
#define LED1 LATCbits.LATC0
//#define LED2 LATAbits.LATA2
while(1)
{
// Ensure USB module is available
// EnableUSBModule(); //esto es de usb.c, lo deja en el estado powered
//
// // As long as we aren't in test mode (UTEYE), process
// // USB transactions.
// if(UCFGbits.UTEYE != 1)//no se debe conectar el usb si UTEYE esta activo por que este genera un testeo
// ProcessUSBTransactions();//esta en usb.c tmb
// Application specific tasks
// ProcessIO();
USBEcho();
//Blink LED2 @ 1Hz when configured
if(INTCONbits.TMR0IF){
INTCONbits.TMR0IF=0;
timestamp++;
led_cnt++;
if (deviceState<CONFIGURED&&led_cnt>=10){
//LED2 = !LED2;
LED1 = !LED1;
led_cnt=0;
}
else if (deviceState == CONFIGURED&&led_cnt>=46){
//LED2 = !LED2;
LED1 = !LED1;
led_cnt=0;
}
}
}
}
Mostrar Temas
dodecaedro para recordar los comandos y maravillas de VIM, el cual publique en mi blog así que más información esta en el: 
... me gustaría me recomendaran o me contaran algo al respecto de la programación sin depender del SO, como se maneja el "video" (aun no tengo remota idea de como funciona), teclado, etc,etc... uds me entienden.. quiero saber como funciona.. 