IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 Delphi Discussion :

I2c sur port LPT


Sujet :

Delphi

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Janvier 2008
    Messages : 28
    Points : 12
    Points
    12
    Par défaut I2c sur port LPT
    Bonsoir à tous,

    J'ai monté un adaptateur LPT -> I2c dans le but de développer une petite application pour gérer quelques PCF8574. Le problème est qu'il existe bon nombre d'adaptateurs et forcément autant d'exemples de codes. N'étant de loin pas une bête en delphi je me débrouille pour piloter mes pcf à partir d'exemples mais avec un adaptateur plus solide je n'ai qu'un exemple de code en vb (je peux éventuellement le joindre à mon post).

    Ma question est, est-ce qu'en fonction du câblage de l'adaptateur sur le port lpt il y a une logique à savoir pour pouvoir développer une application et piloter un composant I2c?

    Je vous remercie par avance pour vos lumières.

  2. #2
    Membre chevronné Avatar de philnext
    Profil pro
    Inscrit en
    Octobre 2002
    Messages
    1 552
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2002
    Messages : 1 552
    Points : 1 780
    Points
    1 780
    Par défaut
    Tu peux préciser le pb sur lequel tu butes ?

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Janvier 2008
    Messages : 28
    Points : 12
    Points
    12
    Par défaut
    En fait j'ai ce code écrit par celui qui a fait le schéma de l'interface lpt -> i2c mais comme c'est du vb et que je suis encore plus mauvais qu'en delphi je ne comprends pas comment le retranscrire pour delphi.

    Code vb : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    Attribute VB_Name = "I2C_InpOut32"
    '***********************************************************************************
    '* This module contains all I2C functions required to communicate via the I2CLPT   *
    '* interface with the I2C bus. The I2CLPT interface is published in the Elektor /  *
    '* Elektuur of October 2000.                                                       *
    '*                                                                                 *
    '* The InpOut32.DLL is used to address the the Parallel port under Windows 2000/XP *
    '*                                                                                 *
    '* I2C lines are defined as follows:                                               *
    '* D0 -> SCL out.   To make SCL Low, D0 is set to High ; D0=H SCL=L / D0=L SCL=H   *
    '* D1 -> SDA out.   To make SDA Low, D1 is set to High ; D1=H SDA=L / D1=L SDA=H   *
    '* Error -> SCL in. Error read High -> SCL is Low.                                 *
    '* Ack -> SDA in.   Ack read High -> SDA is Low.                                   *
    '*                                                                                 *
    '*                                                                                 *
    '* Creator    :   Ronald Rakké                                                     *
    '* Date       :   5 January 2006                                                   *
    '* Version    :   0.1                                                              *
    '*                                                                                 *
    '* Copyright 2006, X-Lent Electronics                                              *
    '*                                                                                 *
    '***********************************************************************************
     
    'Declaration of the InpOut32.DLL functions
    Public Declare Function Inp Lib "inpout32.dll" Alias "Inp32" (ByVal PortAddress As Integer) As Integer
    Public Declare Sub Out Lib "inpout32.dll" Alias "Out32" (ByVal PortAddress As Integer, ByVal Value As Integer)
     
    'Public variable BusFreq. Has to be initialized in the main Form of the application
    'Sets the delay time of the Function Delay.
    'Is required to set the I2C bus clock (SCL) to the appropiate clock frequency.
    'I2C clock is depending on the CPU frequency and Parallel port speed.
    'BusFreq is defined in Khz. ->BusFreq=100 -> I2C bus clock is 100Khz.
    Public BusFreq As Integer
     
    'The QueryPerformanceCounter / High resolution Timer API calls
    Private Declare Function QueryPerformanceFrequency Lib "kernel32" (lpFrequency As Currency) As Long
    Private Declare Function QueryPerformanceCounter Lib "kernel32" (lpPerformanceCount As Currency) As Long
     
     
    Public BA As Integer
     
     
    '*************************************************************************
    '* Sub to set the START condition on the I2C bus
    '* Returns : Nothing
    '*************************************************************************
     
    Public Sub I2C_Start()
     
        Out BA, &H0      'SCL=High ; SDA=High
        Delay (BusFreq)           'Wait 10uS
        Out BA, &H2      'SCL=High ; SDA=Low
        Delay (BusFreq)           'Wait 10uS
        Out BA, &H3      'SCL=Low ; SDA=Low
        Delay (BusFreq)
     
    End Sub
     
     
    '*************************************************************************
    '* Sub to set the STOP condition on the I2C bus
    '* Returns : Nothing
    '*************************************************************************
     
    Public Sub I2C_Stop()
     
        Out BA, &H3       'SCL=Low ; SDA=Low
        Delay (BusFreq)            'Wait 10uS
        Out BA, &H2       'SCL=High ; SDA=Low
        Delay (BusFreq)
        Out BA, &H0       'SCL=High ; SDA=High
        Delay (BusFreq)
     
     
    End Sub
     
    '*************************************************************************
    '* Function to Read a byte from the I2C bus
    '* Returns : The byte read
    '*************************************************************************
     
    Public Function I2C_Read()
     
        Dim x As Integer
        Dim Shift As Byte
        Dim ReadByte As Integer
     
       'Read Byte. Start with MSB
        For x = 0 To 7
              Shift = &H80 / 2 ^ x
              Out BA, &H1                           'SCL=Low ; SDA=High
              Delay (BusFreq)
              Out BA, &H0                           'SCL=High ; SDA=High
              Delay (BusFreq)
              If (Inp(BA + &H1) And &H40) > 0 Then  'Received bit is 1
                ReadByte = ReadByte + Shift
              End If
        Next
     
        I2C_Read = ReadByte
     
    End Function
     
     
    '*************************************************************************
    '* Sub to Write a byte to the I2C bus
    '* Returns : Nothing
    '*************************************************************************
     
    Public Sub I2C_Write(ByVal Value As Byte)
     
        Dim x As Integer
        Dim Shift As Byte
     
     
        'Shift value bit for bit
        'Start with the MSB
        For x = 0 To 7
            Shift = &H80 / 2 ^ x
            If (Value And Shift) > 0 Then   'Bit is 1
                Out BA, &H1                 'SCL=Low ; SDA=High
                Delay (BusFreq)
                Out BA, &H0                 'SCL=High ; SDA=High
                Delay (BusFreq)
            Else                            'Bit is 0
                Out BA, &H3                 'SCL=Low ; SDA=Low
                Delay (BusFreq)
                Out BA, &H2                 'SCL=High ; SDA=Low
                Delay (BusFreq)
            End If
        Next
     
     
     
    End Sub
     
    '*********************************************************************************
    '* Function to detect a Ackknowledge on I2C bus generated by the Slave receiver
    '* Returns : False when Ack has not been detected
    '* Returns : True when Ack has been detected
    '*********************************************************************************
     
    Public Function I2C_Ack() As Boolean
     
        Dim ack As Byte
     
        Out BA, &H1       'Master Set SDA to High (release SDA) and set SCL to low
        Delay (BusFreq)            'Wait 10uS
        Out BA, &H0       'Set SCL to High
     
        ack = Inp(BA + &H1) And &H40    'Check if SDA is pulled Low by Slave
     
        'Check Acknowledge condition -> Ack bit of the LPT=High -> SDA=Low
        If ack > 0 Then
            I2C_Ack = True
        Else
            I2C_Ack = False
        End If
     
    End Function
     
    '*********************************************************************************
    '* Function to detect a NOT Ackknowledge on I2C bus generated by the Master
    '* Returns : False when Nack has not been detected
    '* Returns : True when Nack has been detected
    '*********************************************************************************
     
    Public Function I2C_Nack() As Boolean
     
        Dim Nack As Byte
     
        Out BA, &H1     'SCL=Low ; SDA=High
        Delay (BusFreq)
        Out BA, &H0     'SLC=High ; SDA=High
     
        Nack = Inp(BA + &H1) And &H40    'Check if SDA is pulled Low by Slave
     
        'Check Nacknowledge condition -> Ack bit of the LPT=High -> SDA=Low
        If Nack > 0 Then
            I2C_Nack = False
        Else
            I2C_Nack = True
        End If
     
        Out BA, &H1     'SCL=Low ; SDA=High
     
    End Function
     
    '*************************************************************************
    '* Function which makes sure that the I2C clock is maximum 100KHz.
    '* Clock is determined from the processors real timer
    '* Returns : I2C Clock frequency in KHz
    '*************************************************************************
     
    Public Function Delay(ByVal Freq As Single) As Single
     
        Dim mcurFreq As Currency    'Frequency of the high resolution timer
        Dim mcurStart As Currency   'Tick count of the timer Start
        Dim mcurEnd As Currency     'Tick count of the timer End
     
        If Freq = 0 Then
            Exit Function
        Else
            Freq = 0.00095 / Freq
        End If
     
        QueryPerformanceFrequency mcurFreq      'Get timer frequency
        QueryPerformanceCounter mcurStart       'Get the start point
        QueryPerformanceCounter mcurEnd         'Get the end point
     
        'Calculate the duration in uS
        'Loop until 10uS has passed
        Do While (mcurEnd - mcurStart) / mcurFreq < Freq
         QueryPerformanceCounter mcurEnd
        Loop
     
        'Return Frequency in KHz
        Delay = 0.001 * 1 / ((mcurEnd - mcurStart) / mcurFreq)
     
     
    End Function
     
    '*************************************************************************
    '* Sub to initialize / reset the I2C bus by sending a repeated start
    '* Returns : Nothing
    '*************************************************************************
     
    Public Sub Init()
     
     
        I2C_Start
        I2C_Start
        I2C_Stop
     
    End Sub
     
    '*************************************************************************
    '* Function to detect the I2C devices present on the I2C bus
    '* Returns : True when device detected
    '* Returns: False when device not detected
    '*************************************************************************
     
    Public Function I2C_Detect_Device(ByVal Address As Integer) As Boolean
     
        I2C_Start
        I2C_Write (Address)
        I2C_Detect_Device = I2C_Ack
        I2C_Nack
        I2C_Stop
     
    End Function
     
    '*********************************************************************************
    '* Sub to generate from the Master a Ackknowledge on I2C bus to indicate to
    '* Slave that the data has been received.
    '* Returns : Nothing
    '*********************************************************************************
     
    Public Sub I2C_Master_Ack()
     
        Out BA, &H3     'SCL=Low ; SDA=Low
        Delay (BusFreq)
        Out BA, &H1     'SCL=High ; SDA=Low
        Delay (BusFreq)
        Out BA, &H3     'SCL=Low ; SDA=Low
     
    End Sub

  4. #4
    Membre éclairé

    Homme Profil pro
    Rédacteur technique (retraité)
    Inscrit en
    Octobre 2009
    Messages
    168
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 81
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Rédacteur technique (retraité)

    Informations forums :
    Inscription : Octobre 2009
    Messages : 168
    Points : 807
    Points
    807
    Par défaut Petit guide pour transcrire le module Visual Basic en Delphi
    Dans le cas du fichier Vb proposé, la transcription en Delphi me parraît assez simple:

    • La première ligne ATTRIBUTE ne fait qu'indiquer que le module VB se nomme I2C_InpOut32.
      Elle peut être supprimée. Si l'on veut, on peut utiliser ce nom pour nommer l'unité Delphi.

    • En Vb l'appostrophe simple (') débute un commentaire, lequel se termine avec la fin de ligne.
      Equivalent Delphi : // (deux slash consécutifs).

    • En Vb les chaînes de caractères sont encadrées par des " (double appostrophe).
      Equivalent Delphi ' (simple appostrophe).
      Attention au doublement/dédoublement de ces caractères s'ils sont inclus dans la chaîne.

    • Les deux caractère &H indiquent une constante litérale hexadécimale. Equivalent Delphi $ (dollard).

    • En Vb le signe = (égal) est utilisé aussi bien pour l'affectation que comme opérateur de comparaison.
      En Delphi, il doit être remplace par := (deux-points-égal) mais uniquement dans les affectations (pas dans les expressions).


    • En Vb les retours ligne sont des séparateurs d'instruction. En Delphi, seul le signe ; (point-virgule) joue ce rôle.
      Il faut donc ajouter un ; à la fin de la plupart des instructions et déclarations.


    • En Vb le mot clé AS introduit le type de donnée.
      Equivalent Delphi : (deux-points).


    • La plupart des types Vb cités sont utilisables tels-quels en Delphi sauf LONG dont l'équivalent Delphi est LongInt.


    • Le mot clé PUBLIC indique une déclaration visible dans les autres modules Vb.
      Equivalent Delphi, faire figurer la déclaration dans la section Interface de l'unité.


    • Le mot clé PRIVATE indique une déclaration locale au module Vb.
      Equivalent Delphi, faire figurer la déclaration seulement dans la section Implementation de l'unité.




    • Dans une expression VB, le symbole ^ (accent circonflexe) est l'opérateur d'élévation à la puissance.
      En Delphi ce symbole indique un déréférencement de pointeur et il n'existe pas d'opérateur équivalent. Seule la fonction Power effectue l'élévation à la puissance mais uniquement sur des opérandes Réels.
      Il faudra donc ré-écrire les fragments de code correspondants.


    • Déclaration des Procedures et fonctions:

      En Vb :
      SUB est l'équivalent Delphi de Procedure.
      DECLARE déclare une fontion ou une procédure externe.
      LIB déclare le nom du fichier DLL.
      ALIAS indique le nom interne dans la DLL.
      Les paramètres sont séparés par des , (virgule).
      Le mot clé BYVAL indique un paramètre passé par valeur. Son absence indique un paramètre passé par référence.
      La convention d'appel est en principe la convention Microsoft.
      Dans le corps de la procédure:
      Les variables locales (DIM) peuvent être déclarées n'importe où.
      Le résultat d'une fonction est retournée par assignation d'une valeur au nom de la fonction (<NomFonction> = valeur).
      La fin du corps est indiquée par les mots clés END SUB ou END FUNCTION.

      En Delphi :
      DECLARE et LIB sont remplacés par la directive External.
      ALIAS est remplacé par la directive Name.
      Les paramètres sont séparés par des ; (point-virgule)et non des virgules.
      Les paramètres sont passés par valeur par défaut et par référence si la directive Var est indiquée.
      Il faut donc supprimer ByVal s'il est présent ou ajouter Var si ByVal est absent.
      La convention d'appel StdCall (Microsoft) doit être utilisée.
      Dans le corps de la procédure:
      Les variables locales doivent être toutes regroupées au début et séparées des instructions par le mot clé Begin.
      Le résultat de la fonction est retournée par affectation d'une valeur à la variable Result.
      "<NomFonction> = valeur" doit être remplacé par "Result := valeur;"
      A la fin, les mots SUB ou FUNCTION, après END doivent être remplacés par un simple ; (point-virgule).

      Exemple :
      Code Vb : Sélectionner tout - Visualiser dans une fenêtre à part
      Public Declare Sub Out Lib "inpout32.dll" Alias "Out32" (ByVal PortAddress As Integer, ByVal Value As Integer)
      Devient en Delphi (dans la section Interface):
      Code Delphi : Sélectionner tout - Visualiser dans une fenêtre à part
      Procedure Out(PortAddress: Integer; Value: Integer); StdCall; External 'inpout32.dll' Name 'Out32';


    • Appel des procedures SUB:

      En Vb lors de l'appel d'une procedure les paramètres ne sont PAS placés entre parenthèses.
      Il faut les ajouter en Delphi.


    Structures de contrôle (IF, FOR, WHILE):

    • IF:
      En Delphi les branches THEN et ELSE n'admettent qu'une seule instruction.
      Si le source Vb en comprend plusieurs (ce qui est souvent le cas) elles doivent être regroupées dans un boc Begin ... End unique.
      Remplacer END IF par un simple ; (point-virgule).


    • WHILE:
      En Vb la structure est de la forme "DO WHILE expression instructions... LOOP"
      Pour transcrire en Delphi, deplacer DO après 'expression' et avant la première instruction.
      Si 'instructions...' comporte plusieurs instructions, les regrouper dans un bloc Begin ... End.
      Remplacer LOOP par un simple ; (point-virgule).


    • FOR:
      En Vb la structure est de la forme "FOR initial TO final instructions... NEXT".
      Pour transcrire, ajouter DO après l'expression final.
      Initial est une affectation à la variable de contrôle, remplacer = par :=
      Si 'instructions...' comporte plusieurs instructions, les regrouper dans un bloc Begin ... End.
      Remplacer NEXT par un simple ; (point-virgule).


    Autres points à vérifier :

    A l'entrée d'une procédure, Vb initialise les variables locales à 0.
    Ce n'est pas le cas en Delphi où elle peuvent contenir n'importe quoi.
    Porter une attention particulière aux message d'avertissement de Delphi indiquant qu'une variable n'a peut-être pas été initialisée.
    Idem pour les valeurs de retour de fonction.

  5. #5
    Membre à l'essai
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Janvier 2008
    Messages : 28
    Points : 12
    Points
    12
    Par défaut
    Bonsoir DomDA91,

    Je te remercie vivement pour ton explication. Avec celle-ci je suis enfin arrivé à aller de l'avant positivement avec mon application.

    Très bon week-end.

  6. #6
    Membre éprouvé
    Avatar de Montor
    Homme Profil pro
    Autre
    Inscrit en
    Avril 2008
    Messages
    879
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Autre

    Informations forums :
    Inscription : Avril 2008
    Messages : 879
    Points : 963
    Points
    963
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    unit UI2C;
          //I2C By Montor
    interface
     
    type
      TStateI2C = 0..1;
      TBaseI2C =class
      protected
         procedure WaitUs(AUs: integer);
         procedure BusWrite(ASCL,ASDA:TStateI2C);virtual;abstract;
         function SDA_Read():TStateI2C;virtual;abstract;
      public
         function Open(ADevice: Byte; AWrite: boolean =False): boolean;
         procedure Write(Value: Byte);
         function Read(): Byte;
         procedure Start();
         procedure Stop();
         procedure Init();
         function Ack(): boolean;
         function NAck(): boolean;
         procedure Master_Ack();
         function IsPresent(ADevice:Byte):boolean;
     end;
      TLTPI2C =class(TBaseI2C)
      protected
         procedure BusWrite(ASCL,ASDA:TStateI2C);override;
         function SDA_Read():TStateI2C;override;
      end;
     
    implementation
    uses windows;
     
    function Inp32(PortAddress:integer):Integer;stdcall;external 'inpout32.dll';
    procedure Out32(PortAddress,Value : Integer);stdcall;external 'inpout32.dll';
     
    procedure TBaseI2C.WaitUs(AUs:integer);
    var
      mFreq,mStart,mEnd:int64;
    begin
        QueryPerformanceFrequency(mFreq);
        QueryPerformanceCounter(mStart);
        repeat
            QueryPerformanceCounter(mEnd);
        until ((mEnd - mStart)*1000000 div mFreq )> AUs;
    end;
     
    procedure TBaseI2C.Write(Value:Byte);
    var
     I :integer;
     D :TStateI2C;
    begin
        for I := 0 to 7 do
        begin
            D:=(Value and $80)shr 7;
            BusWrite(0,D);
            BusWrite(1,D);
            Value := Value shl 1;
        end;
    end;
     
    function TBaseI2C.Read():Byte;
    var
     I:integer;
    begin
        Result := 0;
        for I := 7 downto 0 do
        begin
            BusWrite(0,1);
            BusWrite(1,1);
            Result:= Result or ( Byte(SDA_Read()) shl I);
        end;
    end;
     
    procedure TBaseI2C.Start();
    begin
        BusWrite(1,1);
        BusWrite(1,0);
        BusWrite(0,0);
    end;
     
    procedure TBaseI2C.Stop();
    begin
        BusWrite(0,0);
        BusWrite(1,0);
        BusWrite(1,1);
    end;
     
    function TBaseI2C.Ack():boolean;
    begin
        BusWrite(0,1);
        BusWrite(1,1);
        Result := SDA_Read() = 0;
    end;
     
    function TBaseI2C.NAck():boolean;
    begin
        BusWrite(0,1);
        BusWrite(1,1);
        Result := SDA_Read() = 1;
        BusWrite(0,1);
    end;
     
    procedure TBaseI2C.Init();
    begin
        Start();
        Start();
        Stop();
    end;
     
    procedure TBaseI2C.Master_Ack();
    begin
        BusWrite(0,0);
        BusWrite(1,0);
        BusWrite(0,0);
    end;
     
    function TBaseI2C.Open(ADevice:Byte;AWrite:boolean):boolean;
    begin
        Start();
        if AWrite then
           Write(ADevice and $FE)
        else
           Write(ADevice or $01);
        Result := Ack;
    end;
     
    function TBaseI2C.IsPresent(ADevice:Byte):boolean;
    begin
        Init();
        Start();
        Write(ADevice);
        Result:=Ack();
        Nack();
        Stop();
    end;
     
    { TLTPI2C }
     
    function TLTPI2C.SDA_Read: TStateI2C;
    begin           //  /ACK  Pin 10
        WaitUs(10);
        Result := not(Inp32($378+1)shr 6)and 1;
    end;
     
    procedure TLTPI2C.BusWrite(ASCL, ASDA: TStateI2C);
    begin
        // D0 ->SCL D2 -> SDA
        Out32($378,not(ASCL or ASDA shl 2) and 5);
        WaitUs(400);
    end;
    end.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
              o  D0 (Pin 2)
              |           
              /           
              \ R1 22k      
              /       +-----o  SCL Out
              \       |     
              |     |/      
              +-----+ 
                 Q1 |\  
                      | 
    GND o-------------+
     
              o  D2 (Pin 4)
              |           
              /           
              \ R1 22k      
              /       +---+-o SDA Out
              \       |   |  
              |     |/    |  
              +-----+     |
                 Q1 |\    |
                      |   |
    GND o-------------+   |
                          |
              +-----------+
              |          
              /           
              \ R1 22k      
              /       +-----o  ACK(Pin 10) 
              \       |     
              |     |/      
              +-----+ 
                 Q1 |\  
                      | 
    GND o-------------+
    J'ai fais un petit test une le chip 24c32

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    procedure TForm1.Button1Click(Sender: TObject);
    const ADDR_24Cxx = $A0;{1010 0000}
    var
     h:TLTPI2C;
    begin
       h:=TLTPI2C.Create;
       h.Init;
       if h.Open(ADDR_24Cxx,True) then begin
            h.Write(0);
            h.Ack;
            h.Write(1);
       end;
       if h.Open(ADDR_24Cxx) then
          Showmessage(inttostr(h.Read));
       h.Free;
    end;

Discussions similaires

  1. Port LPT PCI-E sur Seven
    Par electroremy dans le forum Périphériques
    Réponses: 4
    Dernier message: 14/07/2013, 13h30
  2. Réponses: 2
    Dernier message: 31/03/2008, 14h30
  3. Communiquer sur le port LPT
    Par barthelv dans le forum Windows
    Réponses: 1
    Dernier message: 17/02/2006, 13h56
  4. [TP]Impression sur port USB
    Par haypo dans le forum Turbo Pascal
    Réponses: 3
    Dernier message: 18/07/2003, 11h09
  5. [UDP][Socket] perte de paquets et arret d'ecoute sur port
    Par Guismo1979 dans le forum Développement
    Réponses: 6
    Dernier message: 02/01/2003, 12h13

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo