DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦c9c7e3114⟧ Ada Source

    Length: 13312 (0x3400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body C_Port_Serie, seg_057c82

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



with C_File;
package body C_Port_Serie is

-------------------------------------------------------------------------------
--                      Initialisation du DUART
-------------------------------------------------------------------------------

    procedure Initialiser (N_Port : General_Defs.Port;
                           Vitesse : General_Defs.Baud_Rate;
                           Parite : General_Defs.Parite;
                           Nb_Bit : General_Defs.Nbre_Bits_Par_Caractere;
                           Nb_Bit_Stop : General_Defs.Stop_Bits) is
    begin
        Serie.Pos_Vitesse (Port_Serie => N_Port, Vitesse => Vitesse);
        Serie.Pos_Parite (Port_Serie => N_Port, Val_Parite => Parite);
        Serie.Pos_Stop_Bits (Port_Serie => N_Port,
                             Val_Stop_Bits => Nb_Bit_Stop);
        Serie.Pos_Nbre_Bits_Caractere (Port_Serie => N_Port,
                                       Val_Nbre_Bits_Par_Caractere => Nb_Bit);
    end Initialiser;

-------------------------------------------------------------------------------
--                      Positionne le DUART suivant le port en emission
--                          ou reception
-------------------------------------------------------------------------------

    procedure Emission_Reception (Config : Sorte_E_R) is
    begin
        case Config is
            when Ea =>
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_A, Mode => Serie.E_R);
                --  Serie.Emission_Reception
                --   (Port_Serie => General_Defs.Port_B, Mode => Serie.R);
            when Eb =>
                --      Serie.Emission_Reception
                --       (Port_Serie => General_Defs.Port_A, Mode => Serie.R);
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_B, Mode => Serie.E_R);
            when R_Seule =>
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_A, Mode => Serie.R);
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_B, Mode => Serie.R);
            when Rien =>
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_A, Mode => Serie.Aucun);
                Serie.Emission_Reception
                   (Port_Serie => General_Defs.Port_B, Mode => Serie.Aucun);
        end case;
    end Emission_Reception;

-------------------------------------------------------------------------------
--                      Valide les IT en reception, emission ou aucune
-------------------------------------------------------------------------------

    procedure Validation_It (Sorte : Sorte_It) is  
    begin
        case Sorte is
            when R_Ab =>
                Serie.Pos_Interruption (Mode => Serie.R);
            when Ea_R =>
                Serie.Pos_Interruption (Mode => Serie.Ea_R);
            when Eb_R =>
                Serie.Pos_Interruption (Mode => Serie.Eb_R);
            when Pas_It =>
                Serie.Pos_Interruption (Mode => Serie.Aucun);
        end case;
    end Validation_It;

-------------------------------------------------------------------------------
--                      Positionne le DUART en emission
--                      et valide une IT d'emission
-------------------------------------------------------------------------------

    procedure Envoi_Donnee_Par_It (Type_Port : General_Defs.Port) is
    begin
        case Type_Port is
            when General_Defs.Port_A =>
                Emission_Reception (Ea);
                Serie.Pos_Interruption (Serie.Ea_R);
            when General_Defs.Port_B =>
                Emission_Reception (Eb);
                Serie.Pos_Interruption (Serie.Eb_R);
        end case;
    end Envoi_Donnee_Par_It;

-------------------------------------------------------------------------------
--                      Tache en attente d'une IT
--                          soit : emission ou reception port A
--                          soit : emission ou reception port B
-------------------------------------------------------------------------------

    task body Transmettre is

        Car : General_Defs.Byte;
        Sorte_It : Serie.Evenement_Interruption;
        package Buffer_Reception is
           new C_File (Element => General_Defs.Byte,
                       Longueur_Max => General_Defs.Taille_Trame);
        Buffer_Reception_A : Buffer_Reception.Objet;
        Buffer_Reception_B : Buffer_Reception.Objet;
    begin  
        Serie.Pos_Interruption (Serie.Aucun);
        Buffer_Reception.Raz (File_Attente => Buffer_Reception_A);
        Buffer_Reception.Raz (File_Attente => Buffer_Reception_B);
        loop
            accept Lit_Ecrit_Caractere do
                Sorte_It := Serie.Donner_Evenement_Interruption;
                case Sorte_It is
                    when Serie.Emission_Reception_A =>
                        begin
                            Car := Serie.Lire_Donnee (General_Defs.Port_A);
                            Buffer_Reception.Enfiler
                               (File_Attente => Buffer_Reception_A,
                                Elem => Car);
                        end;

                    when Serie.Reception_A =>
                        begin
                            Car := Serie.Lire_Donnee (General_Defs.Port_A);
                            Buffer_Reception.Enfiler
                               (File_Attente => Buffer_Reception_A,
                                Elem => Car);
                        end;

                    when Serie.Emission_Reception_B =>
                        begin  
                            Car := Serie.Lire_Donnee (General_Defs.Port_B);
                            Buffer_Reception.Enfiler
                               (File_Attente => Buffer_Reception_B,
                                Elem => Car);
                        end;

                    when Serie.Reception_B =>
                        begin  
                            Car := Serie.Lire_Donnee (General_Defs.Port_B);
                            Buffer_Reception.Enfiler
                               (File_Attente => Buffer_Reception_B,
                                Elem => Car);
                        end;
                    when Serie.Emission_A =>
                        begin
                            Ecriture (Car, General_Defs.Port_A);
                            Serie.Ecrire_Donnee (General_Defs.Port_A, Car);
                            Serie.Emission_Reception
                               (Port_Serie => General_Defs.Port_A,
                                Mode => Serie.R);
                        end;
                    when Serie.Emission_B =>
                        begin
                            Ecriture (Car, General_Defs.Port_B);
                            Serie.Ecrire_Donnee (General_Defs.Port_B, Car);
                            Serie.Emission_Reception
                               (Port_Serie => General_Defs.Port_B,
                                Mode => Serie.R);
                        end;
                    when Serie.Inconnu =>
                        raise Erreur_Interruption;
                end case;
            end Lit_Ecrit_Caractere;

            while (Buffer_Reception.Est_Vide
                      (File_Attente => Buffer_Reception_A) = False) loop
                declare
                    Car : General_Defs.Byte;
                begin
                    Car := Buffer_Reception.Element_Tete
                              (File_Attente => Buffer_Reception_A);
                    Buffer_Reception.Defiler
                       (File_Attente => Buffer_Reception_A);
                    Lecture (Car, General_Defs.Port_A);
                end;
            end loop;

            while (Buffer_Reception.Est_Vide
                      (File_Attente => Buffer_Reception_B) = False) loop
                declare
                    Car : General_Defs.Byte;
                begin
                    Car := Buffer_Reception.Element_Tete
                              (File_Attente => Buffer_Reception_B);
                    Buffer_Reception.Defiler
                       (File_Attente => Buffer_Reception_B);
                    Lecture (Car, General_Defs.Port_B);
                end;
            end loop;
        end loop;
    end Transmettre;
end C_Port_Serie;



E3 Meta Data

    nblk1=c
    nid=7
    hdr6=14
        [0x00] rec0=14 rec1=00 rec2=01 rec3=08c
        [0x01] rec0=16 rec1=00 rec2=08 rec3=030
        [0x02] rec0=16 rec1=00 rec2=02 rec3=04a
        [0x03] rec0=19 rec1=00 rec2=05 rec3=048
        [0x04] rec0=15 rec1=00 rec2=0c rec3=066
        [0x05] rec0=0e rec1=00 rec2=03 rec3=026
        [0x06] rec0=15 rec1=00 rec2=04 rec3=080
        [0x07] rec0=15 rec1=00 rec2=06 rec3=018
        [0x08] rec0=18 rec1=00 rec2=0b rec3=004
        [0x09] rec0=04 rec1=00 rec2=0a rec3=000
        [0x0a] rec0=16 rec1=00 rec2=08 rec3=00c
        [0x0b] rec0=06 rec1=00 rec2=07 rec3=000
    tail 0x21765005e87d175bfed70 0x42a00088462060003
Free Block Chain:
  0x7: 0000  00 09 03 fc 00 28 20 20 20 20 65 6e 64 20 45 6d  ┆     (    end Em┆
  0x9: 0000  00 00 00 24 80 04 74 72 65 3b 04 00 11 65 6e 64  ┆   $  tre;   end┆