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