aide sur la programmation USB pour le PIC 18F4550

[kh.Mejdi]

bonjour tout le monde)
j suis un élève ingénieur en classe terminale spécialité génie électrique et maintenant j'ai à réaliser mon projet de fin d'études intitulé Système de détection des pannes d'une table de contrôle technique.Ce projet consiste à faire la conception d'une carte électronique qui contient un PIC 18F4550 lié avec un PCF8583(real time clock);les entrées sont trois boutons poussoirs (machine en panne,début d'intervention et fin d'intervention).En outre lorsque la machine tombe en panne, l'ouvrier doit appuyer sur "machine en panne" afin de faire appel au technicien avec un signal d'alarme et le technicien intervient pour la réparation.mon cahier de charge impose l'utilisation du port USB comme port de communication entre le PC et ma carte afin d'envoyer(lorsque le technicien appuie sur les boutons début et fin d'intervention le temps et la date exactement à mon interface graphique.
j'ai trouvé bcp de problèmes au niveau de ce projet dont j vais les citer ci-dessous et que j'espère bien avoir de l'aide:
1- La programmation du PIC et du PCF8583:j n'arrive pas à les programmer alors que j'ai lu pas mal de forums et des articles et en plus j ne suis habitué à la programmation pic(sur le PIC C COMPILER) donc j ne sait pas exactement quoi faire(j programme la partie USB et la partie PCF séparément et après comment les charger dans mon PIC et notons bien que j'ai trouvé des codes HID ou CDC comme des exemples ainsi que pour le PCF mais j'ai pas pu savoir comment les modifier.)
2- j'ai perdu beaucoup de temps à lire des tutoriels sur la programmation JAVA afin de réaliser l'interface mais après un mois j'ai découvert que le JAVA USB API n'est pas fiable sur l'OS windows donc maintenant j dois voir un autre langage de programmation pour voir si c'est possible la liaison avec l'USB.y t'il klk qui a travaillé sur le langage JAVA avec l'USB et qui pense que mon projet est réalisable avec le JAVA????
3- comment faire la connexion de ma carte avec le PC afin d'avoir le temps et la date dés que le technicien appuie sur les boutons ??
SVP c'est la galaire pour moi et j sais bien que je demande trop de choses mais je n'ai publié dans ce forum que lorsque j me suis bloqué pour de bon et c'est trop tard pour mon avancement dans le projet donc SVP SVP essayez de me répondre le plus tôt possible
MERCI d'avance)
-----

[zhal]

Bonjour, JE vais faire ce que je peux pour t'aider.

1- Pour la premiere question : Pour utiliser le PCF8583 il faut bien connaitre le bus I²C. Peux tu nous passer ton schéma structurel de ta carte ? Au moins pour voir comment tu as câblé tout sa.

2- Pour toi le plus simple sera de faire de la communication Série a travers l'USB Post interessant à ce sujet :
http://forums.futura-sciences.com/el...b-pic-18f.html

3 - La il faut reflechir un peu ... Sans t'occuper de l'aspect technique tu peux reflechir a comment tu peux ou tu veux proceder

Reviens vers nous quand tu auras des questions.

[RISC]

Salut,

Quelques idées pour simplifier ton système :
1/ utilise un PIC qui intègre l'horloge temps-réel (préferre le PIC18F45J50 plutôt que le vieux PIC18F4550. la version "J" intègre une RTCC ;=).
Attention les versions "J" fonctionnent en 3.3V.

2/ si tu as du temps tu peux utiliser l'USB intégré mais la mise au point sera probablement longue et difficile si c'est ton premier design USB. Une solution plus simple (mais moins intégrée) est d'utiliser un bridge USB <==> UART extérieur comme le MCP2200. Il te suffit d'écrire dans l'UART et les trames sortent en USB.
Si tu choisis cette solution je te recommande la config suivante : PIC18F45K22 + MCP2200. 5je te recommande cette configuration qui te permettra de mener ton projet à terme SANS te soucier de l'USB...pour l'instant

Les librairies USB se trouvent ici : http://www.microchip.com/MAL
Dans les librairies USB tu trouveras plein de projets pour le PIC18F4550 ;=)

Tu trouveras des exemples de code pour la RTCC intégrée et les PIC18 ici : http://www.microchip.com/codeexamples

Il est possible d'utiliser n'importe quel langage coté host si tu as des librairies USB. Je te recommande TRES FORTEMENT la classe HID car tu n'auras pas à développer de driver ;=)
Il exist un projet HID "custom" pur le PIC18F4550 je crois dans les librairies pour gérer un bouton poussoir. Tu peux l'enrichir

a+

PS : le PIC18F45K50 est annoncé dans le catalogue mais il ne semble pas dispo. Il fonctionnera apparemment SANS QUARTZ externe pour l'USB: http://ww1.microchip.com/downloads/e...Doc/39630h.pdf

[kh.Mejdi]

Merci bien pour vos réponses et j'ai admiré votre esprit de soutien
@zhal:j'ai étudié qlq documents sur le bus I2C mais comme j l'ai mentionné auparavant j ne suis familier avec la programmation donc SVP essayez de m'expliquer un peu le phénomène et si c'est possible un code source comme exemple de plus le forum que tu m'as fourni présente bcp de mots techniques que j'essayes de comprendre comme le firmware et le USB stack
Essayes de me faciliter les choses sur ces termes soigneusement
:Voici mon schéma ISIS
@RISC:Merci bcp pour tes solutions mais pour le bridge USB<==>UART lorsque j'ai fait une petite recherche sur ISIS j'ai pas trouvé le composant MCP2200 malgré que j'ai la version 7.7 SP2 de ISIS
et de plus quand tu dis j'ai pas à me soucier de l'USB comment ça??(un peu d'explication)
Et pour les PIC que se soit le 18F45J50 ou le 18F45K22 sont-ils chers ou non??leur disponibilité au niveau du marché ??
Quand tu me parles du classe HID j'ai bcp de codes sur la classe HID mais le problème reste toujours comment les modifier selon mes besoins car malheureusement j'ai pas des compétences dans la programmation PIC donc si ca vous dérange pas essayes de me donner un tutoriel détaillé ou bien les étapes à faire pour programmer mon PIC
PS:j travaille sur le PIC C compiler imposé par mon cahier de charges et vraiment j pense que je vais demander une question bête mais lorsque on se bloque totalement on se sent trop bête
Tous les codes que je trouve sur le site de microchip sont développés sur MPLAB C18;ça change rien au niveau des instructions par rapport au PIC C compiler ou ils sont tous compatibles puisque ces locigiels utilisent tous le langage C???
j m'excuse pour ce gros nombre de questions mais sérieusement j'ai pas trouvé de l'aide à aucun autre endroit sauf ce forum!!!!
Merci d'avance
PS:voiçi un exemple de code de la classe HID donnez moi vos avis sur les instructions à modifier et à ajouter pour qu'il soit compatible avec mon projet!!

[A voir en vidéo sur Futura]

[kh.Mejdi]

#define __USB_PIC_PERIF__ 1

#include <18F4550.h>
#device ADC=8
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)

#use rs232(stream=PC, baud=115200, xmit=PIN_C6, rcv=PIN_C7, ERRORS)

// CCS Library dynamic defines
#DEFINE USB_HID_DEVICE  TRUE //Tells the CCS PIC USB firmware to include HID handling code.
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT   //turn on EP1 for IN bulk/interrupt transfers
#define USB_EP1_TX_SIZE    64  //allocate 64 bytes in the hardware for transmission
#define USB_EP1_RX_ENABLE  USB_ENABLE_INTERRUPT   //turn on EP1 for OUT bulk/interrupt transfers
#define USB_EP1_RX_SIZE    64  //allocate 64 bytes in the hardware for reception

// CCS USB Libraries
#include <pic18_usb.h>   //Microchip 18Fxx5x hardware layer for usb.c
#include <usb_desc_hid 8-byte.h>   //USB Configuration and Device descriptors for this UBS device
#include <usb.c>        //handles usb setup tokens and get descriptor reports

void usb_debug_task(void) {
   static int8 last_connected;
   static int8 last_enumerated;
   int8 new_connected;
   int8 new_enumerated;

   new_connected=usb_attached();
   new_enumerated=usb_enumerated();

   if (new_connected && !last_connected) {
      printf("\r\n\nUSB connected, waiting for enumaration...");}
   if (!new_connected && last_connected) {
      printf("\r\n\nUSB disconnected, waiting for connection...");}
   if (new_enumerated && !last_enumerated) {
      printf("\r\n\nUSB enumerated by PC/HOST");}
   if (!new_enumerated && last_enumerated) {
      printf("\r\n\nUSB unenumerated by PC/HOST, waiting for enumeration...");}

   last_connected=new_connected;
   last_enumerated=new_enumerated;
}

#INT_RDA
void serial_isr()                         // Serial Interrupt
{
   int8 uReceive;

   disable_interrupts(GLOBAL);            // Disable Global Interrupts

   uReceive = fgetc(PC);

   switch (uReceive) {
      case 0x12: {
            if (fgetc(PC) == 0x34 & fgetc(PC) == 0x56 & fgetc(PC) == 0x78 & fgetc(PC) == 0x90) #asm reset #endasm
         }
         break;
   }

   enable_interrupts(GLOBAL);                // Enable Global Interrupts
}

int calc_crc(int oldcrc, int newbyte) {
   // Please see: http://pdfserv.maxim-ic.com/arpdf/AppNotes/app27.pdf

   int shift_reg, data_bit, sr_lsb, fb_bit, j;
   shift_reg=oldcrc;
   for(j=0; j<8; j++) {   // for each bit
      data_bit = (newbyte >> j) & 0x01;
      sr_lsb = shift_reg & 0x01;
      fb_bit = (data_bit ^ sr_lsb) & 0x01;
      shift_reg = shift_reg >> 1;
      if (fb_bit)
         shift_reg = shift_reg ^ 0x8c;
      }
   return(shift_reg);
}

#define theSampleSize            512

#define usbConfirmAction         0
#define usbCheckStatus           1

#define usbReadADC               4

#define usbReadPort              13
#define usbWritePort             14
#define usbReadPin               15
#define usbWritePin              16
#define usbWritePinB0              20
#define usbWritePinB1              21
#define usbWritePinB2              22
#define usbWritePinB3              23
#define usbWritePinB4              24
#define usbWritePinB5              25
#define usbWritePinB6              26
#define usbWritePinB7              27
#define usbReadADC_A0              30
#define usbReadADC_A1              31
#define usbReadADC_A2              32

#define usbcmdpic              50
#define usbError                 66

void main() {
   int1 useCRC;
   int8 in_data[8];
   int8 out_data[8];
   int8 adcData[theSampleSize];
   int8 theCRC,tempADC, tempADC0, tempADC1,tempADC2, currentADCpin;
   int16 n, approxUS, approxMS, period;

   SETUP_ADC_PORTS(AN0_TO_AN4);
   SETUP_ADC(ADC_CLOCK_DIV_64);
   SETUP_TIMER_0(RTCC_INTERNAL|RTCC_DIV_1);
   SETUP_TIMER_1(T1_DISABLED);
   SETUP_TIMER_2(T2_DISABLED, 127, 1);
   SETUP_TIMER_3(T3_INTERNAL | T3_DIV_BY_8);
   SETUP_CCP1(CCP_OFF);
   SETUP_CCP2(CCP_OFF);
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);

   usb_init();
   useCRC = true;
   currentADCpin = 0;
   set_adc_channel(0);
   delay_ms(1);

   while (TRUE) {
      usb_task();
      usb_debug_task();
      if (usb_enumerated()) {
         if (usb_kbhit(1)) {
            usb_get_packet(1, in_data, 8);

            if (useCRC) {
               theCRC = 0;
               theCRC = calc_crc(theCRC,in_data[0]);
               theCRC = calc_crc(theCRC,in_data[1]);
               theCRC = calc_crc(theCRC,in_data[2]);
               theCRC = calc_crc(theCRC,in_data[3]);
               theCRC = calc_crc(theCRC,in_data[4]);
               theCRC = calc_crc(theCRC,in_data[5]);
               theCRC = calc_crc(theCRC,in_data[6]);
            }
            else {
               theCRC = in_data[7];
            }

            if (theCRC = in_data[7]) {
               out_data[0] = 255;
               out_data[1] = 255;
               out_data[2] = 255;
               out_data[3] = 255;
               out_data[4] = 255;
               out_data[5] = 255;
               out_data[6] = 255;

                switch (in_data[0]) {

                  case usbReadADC: {
                        if (in_data[1] != 255 & in_data[1] != currentADCpin) {
                           currentADCpin = in_data[1];
                           set_adc_channel(currentADCpin);
                           delay_ms(1);
                        }
                        tempADC = READ_ADC();
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadADC;
                        out_data[2] = tempADC;
                        out_data[3] = in_data[1];
                     }
                     break;

                  case usbReadPort: {
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadPort;
                        out_data[2] = input_d();
                     }
                     break;
                  case usbWritePort: {
                        output_b(in_data[1]);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePort;
                        out_data[2] = in_data[1];
                     }
                     break;
                  case usbReadPin: {
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadPin;
                        out_data[2] = in_data[1];
                        switch (in_data[1]) {
                           case 0: out_data[3] = input(PIN_D0); break;
                           case 1: out_data[3] = input(PIN_D1); break;
                           case 2: out_data[3] = input(PIN_D2); break;
                           case 3: out_data[3] = input(PIN_D3); break;
                           case 4: out_data[3] = input(PIN_D4); break;
                           case 5: out_data[3] = input(PIN_D5); break;
                           case 6: out_data[3] = input(PIN_D6); break;
                           case 7: out_data[3] = input(PIN_D7); break;
                        }
                     }
                     break;
                  case usbWritePin: {
                        switch (in_data[1]) {
                           case 0: output_bit(PIN_B0, in_data[2] & 1); break;
                           case 1: output_bit(PIN_B1, in_data[2] & 1); break;
                           case 2: output_bit(PIN_B2, in_data[2] & 1); break;
                           case 3: output_bit(PIN_B3, in_data[2] & 1); break;
                           case 4: output_bit(PIN_B4, in_data[2] & 1); break;
                           case 5: output_bit(PIN_B5, in_data[2] & 1); break;
                           case 6: output_bit(PIN_B6, in_data[2] & 1); break;
                           case 7: output_bit(PIN_B7, in_data[2] & 1); break;
                        }
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePin;
                        out_data[2] = in_data[1];
                        out_data[3] = in_data[2];
                     }
                     break;
                     case usbWritePinB0: {
                        output_bit(PIN_B0, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB0;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbWritePinB1: {
                        output_bit(PIN_B1, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB1;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbWritePinB2: {
                        output_bit(PIN_B2, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB2;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbWritePinB3: {
                        output_bit(PIN_B3, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB3;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbWritePinB4: {
                        output_bit(PIN_B4, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB4;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbWritePinB5: {
                        output_bit(PIN_B5, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB5;
                        out_data[2] = in_data[1];
                     }
                     break;
                      case usbWritePinB6: {
                        output_bit(PIN_B6, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB6;
                        out_data[2] = in_data[1];
                     }
                     break;
                      case usbWritePinB7: {
                        output_bit(PIN_B7, in_data[1] & 1);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePinB7;
                        out_data[2] = in_data[1];
                     }
                     break;
                     case usbReadADC_A0: {
                           set_adc_channel(0);
                           delay_ms(1);
                        
                        tempADC0 = READ_ADC();
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadADC_A0;
                        out_data[4] = tempADC0;
                        out_data[3] = in_data[1];
                     }
                     break;
                     case usbReadADC_A1: {
                           set_adc_channel(1);
                           delay_ms(1);
                        
                        tempADC1 = READ_ADC();
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadADC_A1;
                        out_data[5] = tempADC1;
                        out_data[3] = in_data[1];
                     }
                     break;
                     case usbReadADC_A2: {
                           set_adc_channel(2);
                           delay_ms(1);
                        
                        tempADC2 = READ_ADC();
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbReadADC_A2;
                        out_data[6] = tempADC2;
                        out_data[3] = in_data[1];
                     }
                     break;
                     case usbcmdpic: {
                        output_b(in_data[1]);
                        out_data[0] = usbConfirmAction;
                        out_data[1] = usbWritePort;
                        out_data[2] = input_d();
                        
                         set_adc_channel(0);
                           delay_ms(1);
                        
                        tempADC0 = READ_ADC();
                        out_data[4] = tempADC0;
                        out_data[3] = in_data[1];
                        delay_ms(5);
                         set_adc_channel(1);
                           delay_ms(1);
                        
                        tempADC1 = READ_ADC();
                        out_data[5] = tempADC1;
                        delay_ms(5);
                         set_adc_channel(2);
                           delay_ms(1);
                        
                        tempADC2 = READ_ADC();
                        out_data[6] = tempADC2;
                        
                     }
                     break;
                               
               }
               if (useCRC) {
                  theCRC = 0;
                  theCRC = calc_crc(theCRC,out_data[0]);
                  theCRC = calc_crc(theCRC,out_data[1]);
                  theCRC = calc_crc(theCRC,out_data[2]);
                  theCRC = calc_crc(theCRC,out_data[3]);
                  theCRC = calc_crc(theCRC,out_data[4]);
                  theCRC = calc_crc(theCRC,out_data[5]);
                  theCRC = calc_crc(theCRC,out_data[6]);
                  out_data[7] = theCRC;
               }

               usb_put_packet(1, out_data, 8, USB_DTS_TOGGLE);
            }

            delay_ms(1);
         }
      }
   }
}

[RISC]

Salut,

1/ Si tu n'utilises pas le C18, tu ne pourra utiliser aucun des exemples sur le site Microchip. Ton compilateur utilises des fonctions qui ne SONT PAS ANSI-C...
Contrairement à une idée répandue, aucun programme en C ne fonctionne directement sur un autre compilateur. Parfois de petites différences et parfois des journées de boulot...
Tout ce que tu écris avec ce compilateur est inutilisable sur un autre compilateur C...

2/ Tu utilises ISIS et donc tu ne peux utiliser que les composants dans ISIS. Ca ne sert donc malheureusement a rien que je t'explique à quoi servent des composants que tu ne pourras pas utiliser...

PS : tu aurais du commencer par dire que tu utilisais un simulateur et un compilateur non ANSI-C...je ne t'aurais pas fait les même suggestions
NB : la vraie vie c'est pas le simulateur ...

a+

[kh.Mejdi]

j'ai pas de chance
y a pas d'autres alternatives que tu peux me les donner sur PIC C compiler ou bien si tu peux jeter un coup d'oeil sur le code posté ci dessus et essayer de me donner des conseils??
Merci d'avance

[petardfrancois]

Bonsoir.

Je vais tenter de vous aider un peu... car moi-même j'ai galéré 1 semaine durant avant de pouvoir réaliser une communication en mon 18F et mon PC...
J'utilise MikroBasic, VisualBasic et aussi Isis...
J'avais réalisé dernièrement un programme pour me faire les "dents" où le pic était réduit à envoyer perpétuellement une tension analogique vers une box sous VisualBasic.
Pour ce faire, sans faire de pub,j'ai utilisé ceci : USB hidnetclass, un dll à rajouter dans les outils de VisualBasic,un tuto(vidéo) qui explique tout et un port USB fonctionnel qui apparaît, la version sans licence est sans limite de temps et permet de publier l'application crée.

le code sous MikroBasic:

program USB1

'Programme demo d'acquistion A/N et tranfert vers VisualBasic via le port USB
'PIC 18F4550 ou 2550, Osc 20Mhz, 96 PLL prescaller /5,HS-USB HS, 96 PLL/2,
'USB voltage regulator : enabled.

DIM cnt as char
DIM AN0 as Integer

DIM readbuff as char[64] absolute 0x500
DIM writebuff as char[64] absolute 0x540

sub procedure Interrupt() 'Procédure d'interruption pour la fonction USB
USB_Interrupt_Proc()
end sub


main:

ADCON1 = 0x0c ' AN0 à AN2 en entrée analogique

CMCON = CMCON or 7 'Désactivation des comparateurs
HID_Enable(@readbuff,@writebuf f) 'Activation Lecture/Ecriture en mode HID

For cnt = 0 to 63 '
Writebuff[cnt] = 0 ' remise à zéro du buffer
Readbuff[cnt] = 0 '
next cnt

WHILE TRUE ' Boucle

AN0 = Adc_read(0) 'Lecture de la valeur analogique AN0

WriteBuff[1] = AN0 'Ecriture des 8 bit de poids faible [1]
WriteBuff[2] = char(AN0>>8) 'Ecriture des 2 bit de poids fort [2]

WHILE (HID_Write(@writebuff,64) = 0) 'Envois du buffer...vers ? ^^
WEND
WEND
end.

Et une partie du code sous VisualBasic

Private Sub MicrogeniosUsbHID_Port1_microg eniosDeviceUsbHID_ReceberDados (ByVal sender As System.Object, ByVal args As microgeniosUsbHID.DataRecieved EventArgs) Handles MicrogeniosUsbHID_Port1.microg eniosDeviceUsbHID_ReceberDados
If InvokeRequired Then
Try
Invoke(New DataRecievedEventHandler(Addre ssOf MicrogeniosUsbHID_Port1_microg eniosDeviceUsbHID_ReceberDados ), New Object() {sender, args})
Catch ex As Exception
Console.WriteLine(ex.ToString( ))
End Try
Else

an0 = ((args.data(2) * 256) + args.data(1)) 'Lecture du buffer, conversion des 8 et 2 bit de An0 :0... 1024
an0 = an0 * (5 / 1024) 'Conversion en 0....5v
TextBox1.Text = an0.ToString() 'Affichage dans la Textbox.
End If
End Sub

En espérant vous aider..

Cordialement.

[petardfrancois]

Je pense que lorsque vous aurez résolu comment établir la communication USB, le reste de vos problèmes se résoudront très facilement car par exemple sous visualbasic la gestion du temps est facile et il peut renvoyer les valeurs vers un tableau ou un graphe.
Une petite photo de mon exemple sous Isis : http://www.flickr.com/photos/2976665...8592/lightbox/
Il existe un tuto trés sympa sous Delphi : http://www.roboticus.org/articles/12...ole-hid-part-2 une référence !

Bon courage.