Tiago Shimizu

22 de setembro de 2017

2 minutos atrás, vtrx disse:

Fiquei com preguiça de ler tudo,mas uma dica para estes Pic com USB,é que voce deve evitar de ativar,no fuses,LVP,se ativar vai ficar desconectando.

kkkk, bastante coisa né.

Pois é, já havia percebido essa questão do LVP. Já deixei desligado até. Mas mesmo assim obrigado pela ajuda.

22 de setembro de 2017

#Bommu Perneta, obrigado pela ajuda.
Então, quebrei um pouco mais a cabeça e avancei um pouquinho mais na resolução.
Lendo um livro que tenho sobre programação c para o 18F4550, ele dizia que todas as configurações com respeito a comunicação usb deveriam ser colocadas no arquivo usb_descriptor.c porém não dava mais detalhes sobre que informações esse arquivo contém. Abri ele então e fui lendo, linha a linha. Uma das informações dizia respeito a "máxima corrente" consumida pelo dispositivo. A mesma estava bem baixa, o que as vezes, conforme a utilização de alguns outras dispositivos, acabava reiniciando o microcontrolador. Aumentei essa corrente máxima e parou de reiniciar por conta disso. Ainda não consegui fazer uma análise mais detalhada com o osciloscópio para ver a corrente máxima que estava sendo consumida pela placa.
Bom, mas para entender, a "USB" que me refiro, é a comunicação entre o microcontrolador e e o computador, utilizando a interface usb do dispositivo.
Quanto a "coleta de dados", utilizo deste os pinos I/O do microcontrolador, memórias externa, placas RF entre outros.
Assim como você, já estava tão cansado de quebrar a cabeça que decidi ir dormir pois já não estava conseguindo mais pensar direito.
#Isadora Ferraz, obrigado pela ajuda. Admiro muito seu conhecimento pois vejo e obsorvo várias dicas suas em outros post's. Vou revisar o software para ver se não estou tendo esse problema de uso conjunto das variáveis.
"Mascare uma no início da outra e desmascare no fim" - tipo, seria mais ou menos isso:

#pragma interrupt YourHighPriorityISRCode

void YourHighPriorityISRCode() {
    INTCON3bits.INT0IE = 0;  <-- Desabilita as interrupções da INT0
#if defined(USB_INTERRUPT)
    if (PIR2bits.USBIF)
        USBDeviceTasks();
#endif
    if (USBDeviceState < CONFIGURED_STATE) return 0;
    INTCON3bits.INT0IE = 1; <-- Habilita as interrupções da INT0
}

#pragma interruptlow YourLowPriorityISRCode

void YourLowPriorityISRCode() {
 // Trata informações da INT0 
}

Quanto a não poder postar o código, infelizmente é uma decisão da empresa.

Agradeço desde já a ajuda de todos.

21 de setembro de 2017

Olá a todos. Tenho um desenvolvimento em MPLAB C18 com PIC 18F2550 em que preciso coletar algumas informações externas por meio da porta usb desse pic. Utilizo o programa exemplo da microship para isso porém, a conexão fica bem instável, onde em alguns momentos o dispositivo é desconectado. Só para entenderam o que preciso:

1º - Conexão estável com o PC, sem quedas e/ou perda de dados;

2º - Coletar esses dados por meio da porta serial e/ou outros métodos e enviar esses valores ao PC;

3º - Enviar pelo PC algumas informações para o microcontrolador para que ele realize algumas funções;

Já possuo isso porém, como mencionado, está instável. Utilizo as interrupções de nível alto para a comunicação USB e a nível baixo para a coleta de dados. Visto se tratar de uma aplicação comercial, não posso postar o fonte do mesmo contudo, gostaria de verificar se alguém teria disponibilidade de me dar uma consultoria e ajuda para a correção do problema, quer ele seja físico (desenvolvimento da placa), quer seja software.

Desde já agradeço a todos.

adicionado 26 minutos depois

Pessoal, atualizando o status:

Separei em partes as comunicações: USB e coleta de dados.

Se deixo somente a USB, funciona perfeitamente. A comunicação fica 100% e consigo Receber e enviar dados perfeitamente do controlador. Agora, se ativo a coleta de dados, no caso, as interrupções nível baixo, ferra com tudo. É possível digamos que, colocar isso em um "processamento paralelo" no microcontrolador para que ele opere os dois sem um interferir no outro?

Sei que na rotina de nível baixo estou utilizando alguns delay's, pois é necessário. Contudo até onde sei, caso entre uma nova interrupção de nível alto ele aborta a de nível baixo e vai para a nível alto, não é isso?

Obrigado.

28 de dezembro de 2016

Isadora Ferraz, obrigado pela ajuda. Na realidade, estava simulando tanto pelo proteus quanto pelo PicKit3 diretamente no pic.

Resolvi primeiro verificar se estava tudo certo e rodei o código diretamente no pic só que com a biblioteca de hardware do controlador e funcionou tudo certinho, então matei a parte de fuses e de montagem. porém, meu projeto utiliza os pinos padrões do I2C do pic para outra comunicação, e nessa altura do projeto, é melhor eu alterar a comunicação i2c para software mesmo.

Utilizo essa comunicação para controlar outros dois dispositivos já, uma memória (24C128) e um expansor de I/O (PCF8574), ambos por meio da I2C por software e tudo funciona ok.

Depois que coloquei a última mensagem aqui, quebrei mais a cabeça testando e percebi que quando acessava via hardware e logo após via software, ele pegava as informações certinho, porém reiniciava o controlador e tentava acessar via software direto não ia.

Tentei alterar tudo que era coisa na comunicação via software mas não foi.

porém, uma hora sem querer, realizei duas leituras consecutivas e na segunda leitura lê normal.

Sempre, sem exceção, na primeira leitura ele faz todos os passos porém só retorna zero nos valores, daí posso ler e escrever a vontade no ds que ele aceita todos os comando certinho.

Não entendi direito o porque disso pois via hardware não tenho esse problema.

Sendo assim, sempre que inicio o controlador, realizo uma leitura porém descarto ela e as demais funcionam 100%.

Obrigado pela ajuda.

28 de dezembro de 2016

Olá, tive de dar uma pausa no projeto mas agora retomei nele, porém até agora nada. Filtrei todo o código e ficou assim:

#include <p18f2550.h> 
#include "../Bibliotecas/i2c.h"

unsigned char LeRelogio(void);
unsigned char GravaRelogio(void);
  
typedef struct {

    struct {
        unsigned char Horas;
        unsigned char Minutos;
        unsigned char Segundos;
    } Horario;

    struct {
        unsigned char Dia;
        unsigned char Mes;
        unsigned char Ano;
    } Data;
} RELOGIO_CONFIG;
RELOGIO_CONFIG Relogio;
  
void main(void) {
    LeRelogio();

    Temp[0] = '1';
    Temp[1] = '7';
    Relogio.Horario.Horas = StrToLong(Temp, 0, 2);
    Temp[0] = '2';
    Temp[1] = '3';
    Relogio.Horario.Minutos = StrToLong(Temp, 0, 2);
    Temp[0] = '5';
    Temp[1] = '6';
    Relogio.Horario.Segundos = StrToLong(Temp, 0, 2);

    Temp[0] = '2';
    Temp[1] = '8';
    Relogio.Data.Dia = StrToLong(Temp, 0, 2);
    Temp[0] = '1';
    Temp[1] = '2';
    Relogio.Data.Mes = StrToLong(Temp, 0, 2);
    Temp[0] = '1';
    Temp[1] = '6';
    Relogio.Data.Ano = StrToLong(Temp, 0, 2);

    GravaRelogio();
    LeRelogio();
}

../Biblioteca/i2c.h

#include <delays.h>

#define  DATA_LOW   TRISBbits.TRISB2 = 0; // define macro for data pin output
#define  DATA_HI    TRISBbits.TRISB2 = 1; // define macro for data pin input
#define  DATA_LAT   LATBbits.LATB2        // define macro for data pin latch
#define  DATA_PIN   PORTBbits.RB2         // define macro for data pin

#define  CLOCK_LOW  TRISBbits.TRISB3 = 0; // define macro for clock pin output
#define  CLOCK_HI   TRISBbits.TRISB3 = 1; // define macro for clock pin input
#define  SCLK_LAT   LATBbits.LATB3        // define macro for clock pin latch
#define  SCLK_PIN   PORTBbits.RB3         // define macro for clock pin

void SWStopI2C(void);
void SWStartI2C(void);
void SWRestartI2C(void);
void SWStopI2C(void);

signed char SWAckI2C(void);
signed char Clock_test(void);
signed int SWReadI2C(void);
signed char SWWriteI2C(unsigned char data_out);
signed char SWGetsI2C(unsigned char *rdptr, unsigned char length);
signed char SWPutsI2C(unsigned char *wrptr);

#define  SWPutcI2C    SWWriteI2C
#define  SWGetcI2C    SWReadI2C
#define  SWDelay      Delay10TCYx(20)
void SWNotAckI2C(void);

far unsigned char I2C_BUFFER; // temp buffer for R/W operations
far unsigned char BIT_COUNTER; // temp bufffer for bit counting

void I2CRead(unsigned char Device, unsigned address, char *out, char length);
void I2CWrite(unsigned char Device, unsigned address, const rom unsigned char *texto);

// <editor-fold defaultstate="collapsed" desc="SWAckI2C">

signed char SWAckI2C(void) {
    SCLK_LAT = 0; // set clock pin latch to 0  
    CLOCK_LOW; // set clock pin to output to drive low
    DATA_HI; // release data line to float high 
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
    CLOCK_HI; // release clock line to float high
    Delay1TCY(); // 1 cycle delay
    Delay1TCY(); // 1 cycle delay
    if (DATA_PIN) // error if ack = 1, slave did not ack
    {
        return ( -1); // return with acknowledge error
    } else {
        return ( 0); // return with no error
    }
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWNotAckI2C">

void SWNotAckI2C(void) {
    CLOCK_LOW; // make clock pin output to drive low
    DATA_LAT = 0; // set data pin latch to 0
    DATA_LOW; // make data pin output to drive low
    //Delay10TCY();               // user may need to modify based on Fosc
    SWDelay;
    CLOCK_HI; // release clock line to float high 
    //Delay10TCY();               // user may need to modify based on Fosc
    SWDelay;
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="Clock_test">

signed char Clock_test(void) {
    //Delay10TCYx(3);                 // user may need to adjust timeout period
    //DelayMs(1);
    SWDelay;
    if (!SCLK_PIN) // if clock is still low after wait 
    {
        return ( -2); // return with clock error
    } else {
        return ( 0); // return with no error
    }
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWReadI2C">

signed int SWReadI2C(void) {
    BIT_COUNTER = 8; // set bit count for byte 
    SCLK_LAT = 0; // set clock pin latch to 0

    do {
        CLOCK_LOW; // set clock pin output to drive low
        DATA_HI; // release data line to float high
        //Delay10TCY();                 // user may need to modify based on Fosc
        SWDelay;
        CLOCK_HI; // release clock line to float high
        //Delay1TCY();                  // user may need to modify based on Fosc
        //Delay1TCY();
        SWDelay;

        if (!SCLK_PIN) // test for clock low
        {
            if (Clock_test()) // clock wait routine
            {
                return ( -2); // return with error condition       
            }
        }

        I2C_BUFFER <<= 1; // shift composed byte by 1
        I2C_BUFFER &= 0xFE; // clear bit 0

        if (DATA_PIN) // is data line high
            I2C_BUFFER |= 0x01; // set bit 0 to logic 1

    } while (--BIT_COUNTER); // stay until 8 bits have been acquired

    return ( (unsigned int) I2C_BUFFER); // return with data
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWGetsI2C">

signed char SWGetsI2C(unsigned char *rdptr, unsigned char length) {
    unsigned int thold; // define auto variable

    while (length--) // stay in loop until byte count is zero
    {
        thold = SWGetcI2C(); // read and save 1 byte
        if (thold & 0xFF00) {
            return ( -1); // return with error condition
        } else {
            *rdptr++ = thold; // save off byte read
        }

        if (!length) // initiate NOT ACK
        {
            CLOCK_LOW; // make clock pin output to drive low
            DATA_HI; // release data line to float high 
            //Delay10TCY();               // user may need to modify based on Fosc
            SWDelay;
            CLOCK_HI; // release clock line to float high 
            //Delay10TCY();               // user may need to modify based on Fosc
            SWDelay;
        } else // else initiate ACK condition
        {
            CLOCK_LOW; // make clock pin output to drive low
            DATA_LAT = 0; // set data pin latch to 0
            DATA_LOW; // make data pin output to drive low
            //Delay10TCY();               // user may need to modify based on Fosc
            SWDelay;
            CLOCK_HI; // release clock line to float high 
            //Delay10TCY();               // user may need to modify based on Fosc
            SWDelay;
        }
    }
    return ( 0); // return with no error
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWWriteI2C">

signed char SWWriteI2C(unsigned char data_out) {
    BIT_COUNTER = 8; // initialize bit counter
    I2C_BUFFER = data_out; // data to send out
    SCLK_LAT = 0; // set latch to 0

    do {
        if (!SCLK_PIN) // test if clock is low
        { // if it is then ..
            if (Clock_test()) // wait on clock for a short time
            {
                return ( -1); // return with error condition      
            }
        }
        else {
            I2C_BUFFER &= 0xFF; // generate movlb instruction
            _asm
            rlcf I2C_BUFFER, 1, 1 // rotate into carry and test  
                    _endasm

            if (STATUS & 0x01) // if carry set, transmit out logic 1
            {
                CLOCK_LOW; // set clock pin output to drive low
                DATA_HI; // release data line to float high 
                //Delay10TCY();              // user may need to modify based on Fosc
                SWDelay;
                CLOCK_HI; // release clock line to float high 
                //Delay10TCY();              // user may need to modify based on Fosc
                SWDelay;
            } else // transmit out logic 0
            {
                CLOCK_LOW; // set clock pin output to drive low
                DATA_LAT = 0; // set data pin latch to 0
                DATA_LOW; // set data pin output to drive low 
                //Delay10TCY();             // user may need to modify based on Fosc
                SWDelay;
                CLOCK_HI; // release clock line to float high 
                //Delay10TCY();             // user may need to modify based on Fosc
                SWDelay;
            }

            BIT_COUNTER--; // reduce bit counter by 1
        }
    } while (BIT_COUNTER); // stay in transmit loop until byte sent 

    return ( 0); // return with no error
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWPutsI2C">

signed char SWPutsI2C(unsigned char *wrptr) {
    while (*wrptr) {
        if (SWPutcI2C(*wrptr++)) // write out data string to I2C receiver
        {
            return ( -1); // return if there was an error in Putc()
        } else {
            if (SWAckI2C()) // go read bus ack status
            {
                return ( -1); // return with possible error condition 
            }
        }
    }
    return ( 0); // return with no error
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWRestartI2C">

void SWRestartI2C(void) {
    SCLK_LAT = 0; // set clock pin latch to 0
    CLOCK_LOW; // set clock pin to output to drive low
    DATA_HI; // release data pin to float high
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
    CLOCK_HI; // release clock pin to float high
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
    DATA_LAT = 0; // set data pin latch to 0
    DATA_LOW; // set data pin output to drive low
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWStopI2C">

void SWStopI2C(void) {
    SCLK_LAT = 0; // set clock pin latch to 0
    CLOCK_LOW; // set clock pin to output to drive low
    DATA_LAT = 0; // set data pin latch to 0
    DATA_LOW; // set data pin output to drive low
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
    CLOCK_HI; // release clock pin to float high
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
    DATA_HI; // release data pin to float high
    //Delay1TCY();                    // user may need to modify based on Fosc
    //Delay1TCY();
    SWDelay;
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="SWStartI2C">

void SWStartI2C(void) {
    DATA_LAT = 0; // set data pin latch to 0
    DATA_LOW; // set pin to output to drive low
    //Delay10TCY();                   // user may need to modify based on Fosc
    SWDelay;
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="I2CWrite">

void I2CWrite(unsigned char Device, unsigned address, const rom unsigned char *texto) {
    SWStartI2C();
    SWWriteI2C(Device);
    if (!SWAckI2C()) //Checa o bit ACK.
    {
        SWWriteI2C(((char*) &address)[1]);
        if (!SWAckI2C()) {
            SWWriteI2C(((char*) &address)[0]);
            if (!SWAckI2C()) {
                while (*texto) {
                    if (*texto == '\n')
                        break;
                    SWWriteI2C(*texto++);
                    SWAckI2C();
                }
            }
        }
    }
    SWStopI2C();
}
// </editor-fold>

// <editor-fold defaultstate="collapsed" desc="I2CRead">

void I2CRead(unsigned char Device, unsigned address, char *out, char length) {
    SWStartI2C();
    SWWriteI2C(Device); // EndereÃ§o slave
    if (!SWAckI2C()) //Checa o bit ACK.
    {
        SWWriteI2C(((char*) &address)[1]);
        if (!SWAckI2C()) {
            SWWriteI2C(((char*) &address)[0]);
            if (!SWAckI2C()) {
                SWRestartI2C();
                SWWriteI2C(Device + 1);
                if (!SWAckI2C()) {
                    while (length-- > 1) {
                        *out = SWGetcI2C();
                        SWNotAckI2C();
                        out++;
                    }
                    *out = SWGetcI2C();
                    SWAckI2C();
                    SWStopI2C();
                }
            }
        }
    }
}
// </editor-fold>

Quando simulo pelo proteus ele funciona perfeitamente contudo, quando monto o circuito, não vai de jeito nenhum... O problema anterior de ele se perder nas informações estava ocorrendo pois no arquivo i2c.h, o valor da linha #define SWDelay Delay10TCYx(20) estava #define SWDelay Delay10TCYx(2) e como estou utilizando um cristal de 20MHz, gerava erro.

Alguma luz para esse problema?

Obrigado desde já.

28 de novembro de 2016

Isadora Ferraz, primeiramente muito obrigado pela ajuda.

Então, já havia feito exatamente isso que comentou. Por exemplo, até no código coloquei o endereço do DS como 0xD0 porém, percebi depois que ele não estava aceitando dessa forma, por isso alterei para 0b1101000 e ele começou a aceitar pelo menos o primeiro SWWriteI2C mas depois do comando de leitura e/ou escrita (SWWriteI2C(0x00); / SWWriteI2C(0x01);), já recusa o Ack.

28 de novembro de 2016

Olá pessoal. Estou precisando fazer um relógio utilizando o PIC 18F2550 e o DS1307 programando em C18 porém, não estou conseguindo de jeito algum...!

Já tentei utilizando o I2C do pic via hardware e via software porém em nenhum dos dois funcionou. Descartei a comunicação pois tenho uma memória I2C e consigo ler e escrever na mesma sem problemas.

Alguém poderia me ajudar?

Obrigado.

#include <p18f2550.h> 
#include <sw_i2c.h>
  
#pragma config FOSC = HS
#pragma config CPUDIV = OSC1_PLL2
#pragma config DEBUG  = OFF
#pragma config PWRT   = OFF        
#pragma config WDT    = OFF        
#pragma config PBADEN = OFF      
#pragma config MCLRE  = ON        
#pragma config LVP    = OFF 
  
unsigned char horas, minuto, segundo;
unsigned char dia, mes, ano, semana;  
  
  
void ds1307_init(void)
{
    BYTE seconds = 0;

    SWStartI2C();
    SWWriteI2C(0xD0);      // WR to RTC
    SWWriteI2C(0x00);      // REG 0
    SWRestartI2C ();
    SWWriteI2C(0xD1);      // RD from RTC
    if (!SWAckI2C ( )) //Checa o bit ACK.
    {
        seconds = SWGetcI2C(); // Read current "seconds" in DS1307
        SWStopI2C();
        seconds &= 0x7F;
        DelayMs(3);
        SWStartI2C();
        SWWriteI2C(0xD0);      // WR to RTC
        SWWriteI2C(0x00);      // REG 0
        SWWriteI2C(seconds);     // Start oscillator with current "seconds value
        SWRestartI2C ();
        SWWriteI2C(0xD0);      // WR to RTC
        SWWriteI2C(0x07);      // Control Register
        SWWriteI2C(0x10);     // Disable squarewave output pin
    }
    SWStopI2C();
}  
  
BYTE bin2bcd(BYTE binary_value)
{
  BYTE temp;
  BYTE retval;

  temp = binary_value;
  retval = 0;

  while(1)
  {
    // Get the tens digit by doing multiple subtraction
    // of 10 from the binary value.
    if(temp >= 10)
    {
      temp -= 10;
      retval += 0x10;
    }
    else // Get the ones digit by adding the remainder.
    {
      retval += temp;
      break;
    }
  }
  return(retval);
}

// Input range - 00 to 99.
BYTE bcd2bin(BYTE bcd_value)
{
  BYTE temp;

  temp = bcd_value;
  // Shifting upper digit right by 1 is same as multiplying by 8.
  temp >>= 1;
  // Isolate the bits for the upper digit.
  temp &= 0x78;

  // Now return: (Tens * 8) + (Tens * 2) + Ones

  return(temp + (temp >> 2) + (bcd_value & 0x0f));
}  
  
void ds1307_set_date_time(BYTE day, BYTE mth, BYTE year, BYTE dow, BYTE hr, BYTE min, BYTE sec)
{
    sec &= 0x7F;
    hr &= 0x3F;

    SWStartI2C();
    SWWriteI2C(0xD0);            // I2C write address
    SWWriteI2C(0x00);            // Start at REG 0 - Seconds
    SWWriteI2C(bin2bcd(sec));      // REG 0
    SWWriteI2C(bin2bcd(min));      // REG 1
    SWWriteI2C(bin2bcd(hr));      // REG 2
    SWWriteI2C(bin2bcd(dow));      // REG 3
    SWWriteI2C(bin2bcd(day));      // REG 4
    SWWriteI2C(bin2bcd(mth));      // REG 5
    SWWriteI2C(bin2bcd(year));      // REG 6
    SWWriteI2C(0x10);            // REG 7 - Disable squarewave output pin
    SWStopI2C();
}  
  
void main(void)
{   
  ADCON1 = 0x0F;
  ds1307_init();
  ds1307_set_date_time(28, 11, 16, 2, 2, 25, 16);
  ds1307_get_date(dia, mes, ano, semana);
}

1 de novembro de 2016

Pessoal, já não sei mais se estou fazendo certo agora.... ou se meus cálculos estão certos.

Estou utilizando um cristal de 20MHz. Até onde sei, para microcontroladores da família 18F, o cálculo seria:

// Fmaq = Fosc / 4 => Fmaq = 20MHz / 4 => 5MHz
#define GetSystemClock()  (20000000ul)   // 20MHz
#define GetInstructionClock() (GetSystemClock()/4) // 5MHz
#define GetPeripheralClock()  (GetSystemClock()/4) // 5MHz

Nessas configurações, o ENC28J60 começa a querer comunicar mas logo em seguida desliga. Agora, se altero o valor de divisão do GetSystemClock() de 4 para valores bem mais altos, 40 por exemplo, ele começa a comunicar com o PC, fica uns 2 segundos, e cai a comunicação.

Estou certo em meus cálculos?

31 de outubro de 2016

Olá pessoal, estou tendo problemas em configurar um módulo ENC28J60 em um microcontrolador 18F2550 no C18. Basicamente preciso abrir um socket de comunicação entre o pic e o pc para obter algumas informações. Utilizo um cristal de 20MHz e meu código está assim:

#include <p18f2550.h>

#define _XTAL_FREQ 20000000      // cristal de 20 Mhz
#pragma config FOSC = HS
#pragma config CPUDIV = OSC1_PLL2
#pragma config WDT = OFF
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config PWRT = ON
#pragma config DEBUG= OFF
#pragma config MCLRE = OFF 
  
#pragma udata
void YourLowPriorityISRCode();
void YourHighPriorityISRCode();
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS	0x08
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS	    0x18

#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
void Remapped_High_ISR (void)
{
     _asm goto YourHighPriorityISRCode _endasm
}
#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
void Remapped_Low_ISR (void)
{
     _asm goto YourLowPriorityISRCode _endasm
}
#pragma code

#pragma interrupt YourHighPriorityISRCode
void YourHighPriorityISRCode()
{   
    
}	
#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode()
{
  TickUpdate();
}
  
void main(void)
{
  static TICK t = 0;
  while (1) 
  {
     TickInit();
     InitAppConfig();
     StackInit();
     while (1) 
     {
        if (TickGet() - t >= TICK_SECOND / 2ul) 
        {
           t = TickGet();
        }

        StackTask();
        StackApplications();
        #if defined(STACK_USE_TCP_SERVER)
          ServerSocketTCP();
        #endif
     }
  }
}
  
static ROM BYTE SerializedMACAddress[6] = {MY_DEFAULT_MAC_BYTE1, MY_DEFAULT_MAC_BYTE2, MY_DEFAULT_MAC_BYTE3,
    MY_DEFAULT_MAC_BYTE4, MY_DEFAULT_MAC_BYTE5, MY_DEFAULT_MAC_BYTE6};

void InitAppConfig(void) {
    AppConfig.Flags.bIsDHCPEnabled = TRUE;
    AppConfig.Flags.bInConfigMode = TRUE;
    memcpypgm2ram((void*) &AppConfig.MyMACAddr, (ROM void*) SerializedMACAddress, sizeof (AppConfig.MyMACAddr));
    memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*) MY_DEFAULT_HOST_NAME, 16);
    FormatNetBIOSName(AppConfig.NetBIOSName);
    AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 | MY_DEFAULT_IP_ADDR_BYTE2 << 8ul | MY_DEFAULT_IP_ADDR_BYTE3 << 16ul | MY_DEFAULT_IP_ADDR_BYTE4 << 24ul;
    AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
    AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2 << 8ul | MY_DEFAULT_MASK_BYTE3 << 16ul | MY_DEFAULT_MASK_BYTE4 << 24ul;
    AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
    AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2 << 8ul | MY_DEFAULT_GATE_BYTE3 << 16ul | MY_DEFAULT_GATE_BYTE4 << 24ul;
    AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2 << 8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3 << 16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4 << 24ul;
    AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2 << 8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3 << 16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4 << 24ul;
}

void ServerSocketTCP(void) {
    WORD lenA;
    BYTE i;
    static DWORD timeout[SERVER_CONNS];
    static TCP_SOCKET MySocket[SERVER_CONNS];
    //unsigned char buf[253];
    unsigned char buf[];
    static enum _TCPServerState {
        SM_HOME = 0,
        SM_LISTENING,

    } maquina_estado_servidor = SM_HOME;

    //maquina de estado
    switch (maquina_estado_servidor) {
            //----------------------------------------------------------------------
        case SM_HOME:
            for (i = 0; i < SERVER_CONNS; i++) {
                //faz alocação de de buffer para os sockets
                MySocket[i] = TCPOpen(0, TCP_OPEN_SERVER, SERVER_PORT, TCP_PURPOSE_GENERIC_TCP_SERVER);
                timeout[i] = TickGet();
            }
            maquina_estado_servidor = SM_LISTENING;
            break;
            //----------------------------------------------------------------------
        case SM_LISTENING:
            for (i = 0; i < SERVER_CONNS; i++) {
                if (TCPIsConnected(MySocket[i])) {

                    lenA = TCPIsGetReady(MySocket[i]);

                    //se passou 15 segundos e nao recebeu nada desconecta
                    if (TickGet() - timeout[i] >= TICK_SECOND * 15) {
                        TCPDisconnect(MySocket[i]);
                    }
                } else {
                    timeout[i] = TickGet();
                }
            }
            break;
            //----------------------------------------------------------------------
    }
}

O arquivo HardwareProfile.h está assim:

#ifndef __HARDWARE_PROFILE_H
#define __HARDWARE_PROFILE_H

#include "GenericTypeDefs.h"
#include "Compiler.h"

#define GetSystemClock()  (20000000ul)   // Hz
#define GetInstructionClock() (GetSystemClock()/4)
#define GetPeripheralClock()  (GetSystemClock()/4)

//ENC28J60 I/O pins
#define ENC_RST_TRIS	(TRISCbits.TRISC0)
#define ENC_RST_IO		(LATCbits.LATC0)
#define ENC_CS_TRIS		(TRISCbits.TRISC1)
#define ENC_CS_IO		(LATCbits.LATC1)
#define ENC_SCK_TRIS	(TRISBbits.TRISB1)
#define ENC_SDI_TRIS	(TRISBbits.TRISB0)
#define ENC_SDO_TRIS	(TRISCbits.TRISC7)
#define ENC_SPI_IF		(PIR1bits.SSPIF)
#define ENC_SSPBUF		(SSPBUF)
#define ENC_SPISTAT		(SSPSTAT)
#define ENC_SPISTATbits	(SSPSTATbits)
#define ENC_SPICON1		(SSPCON1)
#define ENC_SPICON1bits	(SSPCON1bits)
#define ENC_SPICON2		(SSPCON2)

Alguém poderia me ajudar?

Obrigado.

15 de dezembro de 2010

Olá a todos. Tenho o PSP2001 e um PS3 Slim junto com o Gran Turismo 5. Ouvi dizer que tem como utilizar o PS como retrovisor e como controle no jogo, mas não estou conseguindo. Algum sabe como fazer isso?

25 de julho de 2009

Olá pessoal,
É possível dar Boot através de um HD externo?

Devido ao fato de tudo estar sendo acessado no HD externo ( sistema operacional, programas, arquivos ) o desempenho seria muito pior do que um HD convencional?

Sou profissional liberal e estou pensando em comprar o HD portátil da Samsung 320 GB (HXMU032DA):

http://www.samsung.com/br/consumer/detail/spec.do?group=itproducts&type=hdd&subtype=externalhdd&model_cd=HXMU032DA/M22

Estou comprando esse HD porque na verdade tenho 3 computadores:

1 em minha casa

1 em meu escritório

1 Laptop

O meu problema é o seguinte:

O meu laptop não tem configuração suficiente para suportar os programas de modelagem 3D que uso, portanto somente o uso para reuniões externas.

Então o que acontece comigo:

Eu tenho que ficar sempre levando e trazendo arquivos de um computador para o outro, assim como atualizar as versões dos arquivos em todos os pcs, bancos de dados, planinhas, programas, em resumo, é um trabalho de manutenção triplo.

A possível solução que pensei em adotar:

Comprar um HD portátil, para que eu instale neste HD portátil o sistema operacional, assim como todos os meus programas, dados e arquivos, para que esse HD seja meu único "computador", ou seja:

Eu configuraria todos os computadores para que o boot deles se dessem atraves do HD externo e assim não precisaria me preocupar com programas, atualização de dados, manutenção de arquivos e etc.

Pensei que fazer isso seria melhor do que comprar um notebook que suportasse melhor os programas 3d que tenho...pelo que eu vi um notebook com um boa configuração para o que uso sairia por volta de R$6.000,00 e um HD externo por volta de R$500,00.

Essa solução daria certo?

Grato pela atenção dispensada!

Quem puder ajudar agradeço!

Bem, para começar, tem como dar boot sim pelo hd externo... mas não se anima muito não..hehehe.

Tem um tutorial explicando isso:

http://forum.clubedohardware.com.br/como-instalar-windows/373382?p=2402593

Contudo, notei que quer utilizar o mesmo windows em 3 máquinas diferentes... impossível... o windows reconhece seu hardware e faz o windows reiniciar. Também estava com este pensamento...

não sei se daria certo mas, se criar 3 partições e em cada uma instalar o windows no determinado micro que vai usar pode ser que de certo...

Espero que tenha ajudado. Qualquer coisa posta ae que tentamos melhorar.

25 de julho de 2009

Seguindo o tutorial do Vcrod deu certinho no meu notebook mas não consegui fazer o windows ficar portátil pois ao inicializar no meu Desktop ele deu tela azul e reiniciou...
Alguem teve este problema em algum momento?

Também tive o mesmo problema com esta tela azul.... andei lendo em alguns tópicos que tem a ver com um tal de HAL.DLL....

Outra coisa, referente a que tem que ligar o hd interno para finalizar a instalação, nimguêm consegui pular esta parte? Não queria guardar esses arquivos de inicialização no hd interno... se não ele tem que estar ligado todas as vezes que vou iniciar o windows no hd externo....

mas até agora, muito bom tópico... parabéns aos criadores...

Entrar

Tiago Shimizu

Posts

Cadastrado em

Tipo de conteúdo

Artigos

Selos

Fabricantes

Livros

Cursos

Análises

Fórum

posts postados por Tiago Shimizu

usb pic 18f2550 oscilando c18

usb pic 18f2550 oscilando c18

usb pic 18f2550 oscilando c18

Ds1307 +c18+18f2550

Ds1307 +c18+18f2550

Ds1307 +c18+18f2550

Ds1307 +c18+18f2550

Enc28j60 + pic18f2550 + c18

Enc28j60 + pic18f2550 + c18

PSP - Tópico oficial

Boot através de HD externo

Como Instalar Windows XP no meu HD externo?

Sobre o Clube do Hardware

Direitos autorais

Mais

Fórum

Atividades

Artigos

Análises

Livros

Cursos