Programeer opdrachtenOpdracht : opdr2_marvin.txt

Terug naar de inzendingen
Opdracht 2,Marvin Raaimakers
5-Feb-2005
 Zo die van mij is ook klaar: http://www.linux-box.nl/~marvin/src/hotel/
 Ik had geen tijd om er een licentie in te plakken, maar ik geeft het vrij onder GPL.
 Oh ja, doe gewoon wat het programma vraagt en geef geen ongeldige invoer. Ik weet het, dat is slecht, maar ik had niet veel meer tijd.
 
 
 [B]Marvins hotel[/B]
 
 Dit programma werk met Pascals lptdrv voor het aansturen van de LED's.
 File Beschrijving
 [B]main.c[/B]-
 [B]lights.c[/B] Zorgt voor het uitlezen van de statussen van de lampjes en het wijzigen ervan.
 [B]switches.c[/B] Zorgt voor het uitlezen van de statussen van de schakelaars en voor het uitvoeren van de specefieke functie die bij iedere schakelaar hoort.
 [B]hotel.h[/B] Header file voor het hotel
 
 
 1 
*****hotel.h*****
  
 2#define NUM_ROOMS       (100)
 3
 4#define TRUE    (1)
 5#define FALSE   (0)
 6
 7typedef int Boolean;
 8
 9enum {
 10        SWITCH_LIGHT1,
 11        SWITCH_LIGHT2,
 12        SWITCH_DOOR,
 13        SWITCH_DESK,
 14        NUM_SWITCHES
 15};
 16
 17typedef enum {
 18        LIGHT_ON,
 19        LIGHT_OFF
 20} LIGHT_STATE;
 21
 22typedef struct {
 23        LIGHT_STATE     light1,
 24                        light2;
 25} ROOM_STATE;
 26
 27typedef ROOM_STATE      ROOMS[NUM_ROOMS];
 28typedef int             ROOM;
 29
 30typedef enum {
 31        SWITCH_ON,
 32        SWITCH_OFF
 33} SWITCH_STATE;
 34
 35typedef struct {
 36        SWITCH_STATE state;
 37        void (*function)(ROOM room, ROOMS *rooms);
 38} SWITCH;
 39
 40extern void switch_light1 (ROOM room, ROOMS *rooms);
 41extern void switch_light2 (ROOM room, ROOMS *rooms);
 42extern void switch_door (ROOM room, ROOMS *rooms);
 43extern void switch_desk (ROOM room, ROOMS *rooms);
 44extern void get_switches_state (SWITCH switches[NUM_SWITCHES], ROOM room, ROOMS *rooms);
 45extern void init_switch_functions (SWITCH switches[NUM_SWITCHES]);
 46
 47extern void lights_get_state (ROOM room, ROOMS *rooms, LIGHT_STATE *light1_state, LIGHT_STATE *light2_state);
 48extern void lights_set_state (ROOM room, ROOMS *rooms, LIGHT_STATE light1_state, LIGHT_STATE light2_state);
 49
 1 
*****light.c*****
  
 2#include 
 3#include 
 4#include 
 5#include 
 6
 7void
 8lights_set_state (      ROOM            room,
 9                        ROOMS           *rooms,
 10                        LIGHT_STATE     light1_state,
 11                        LIGHT_STATE     light2_state  )
 12/*
 13Input:
 14        room            - Tells which room in rooms to set the LIGHT_STATE for
 15        light1_state    - The value to set to state of the light1 to
 16        light2_state    - The value to set to state of the light2 to
 17Output:
 18        rooms           - The state of room in rooms has been set to light_state
 19Returns:
 20        -
 21Description:
 22        This function sets the state of the lights for room in rooms to light_state.
 23*/
 24{
 25        static int lptdrv = -1;
 26        char output;
 27        
 28        (*rooms)[room].light1 = light1_state;
 29        (*rooms)[room].light2 = light2_state;
 30        if (lptdrv == -1) /* If lptdrv was not opened yet */
 31        {
 32                lptdrv = open("/dev/lptdrv", O_WRONLY);
 33        }
 34        if(lptdrv == -1) /* If it still isn't */
 35        {
 36                printf ("ERROR: Unable to open /dev/lptdrv\n"
 37                        "The program will continue but the lights will not work.\n");
 38        }
 39        else
 40        {
 41                output = (char) ((light1_state == LIGHT_ON) | (light2_state == LIGHT_ON)*2);
 42                write (lptdrv, &output, sizeof(char));
 43        }
 44}
 45
 46
 47void
 48lights_get_state (      ROOM            room,
 49                        ROOMS           *rooms,
 50                        LIGHT_STATE     *light1_state,
 51                        LIGHT_STATE     *light2_state  )
 52/*
 53Input:
 54        room            - Tells which room in rooms to get the LIGHT_STATEs from
 55        rooms
 56Output:
 57        light1_state    - The state of the light1
 58        light2_state    - The state of the light2
 59Returns:
 60        -
 61Description:
 62        This function gets the state of the lights for room in rooms and returns it as
 63        light1_state and light2_state.
 64*/
 65{
 66        *light1_state = (*rooms)[room].light1;
 67        *light2_state = (*rooms)[room].light2;
 68}
 69
 1 
*****switches.c*****
  
 2#include 
 3#include 
 4#include 
 5
 6void
 7switch_light1 ( ROOM    room,
 8                ROOMS   *rooms   )
 9{
 10        LIGHT_STATE     light1,
 11                        light2;
 12        
 13        lights_get_state (room, rooms, &light1, &light2);
 14        if (light1 == LIGHT_ON)
 15        {
 16                light1 = LIGHT_OFF;
 17        }
 18        else
 19        {
 20                light1 = LIGHT_ON;
 21        }
 22        lights_set_state (room, rooms, light1, light2);
 23}
 24
 25
 26void
 27switch_light2 ( ROOM    room,
 28                ROOMS   *rooms   )
 29{
 30        LIGHT_STATE     light1,
 31                        light2;
 32        
 33        lights_get_state (room, rooms, &light1, &light2);
 34        if (light2 == LIGHT_ON)
 35        {
 36                light2 = LIGHT_OFF;
 37        }
 38        else
 39        {
 40                light2 = LIGHT_ON;
 41        }
 42        lights_set_state (room, rooms, light1, light2);
 43}
 44
 45
 46void
 47switch_door (   ROOM    room,
 48                ROOMS   *rooms  )
 49{
 50        LIGHT_STATE     light1,
 51                        light2;
 52        
 53        lights_get_state (room, rooms, &light1, &light2);
 54        if (light1 == LIGHT_OFF)
 55        {
 56                light1 = LIGHT_ON;
 57        }
 58        else
 59        {
 60                light1 = LIGHT_OFF;
 61        }
 62        /* I know there is a bit more effecient way to do this,
 63         * but this method is better for readability.
 64         */
 65        light2 = light1;
 66        /* Set the new states of the lights. */
 67        lights_set_state (room, rooms, light1, light1);
 68}
 69
 70
 71void
 72switch_desk (   ROOM    room,
 73                ROOMS   *rooms  )
 74{
 75        lights_set_state (room, rooms, LIGHT_OFF, LIGHT_OFF);
 76}
 77
 78
 79void
 80init_switch_functions (SWITCH switches[NUM_SWITCHES])
 81/*
 82Input:
 83        -
 84Output:
 85        switches        - The switch functions had been set to the switches
 86Returns:
 87        -
 88Description:
 89        Initializes the switch functions for switches.
 90*/
 91{
 92        int count;
 93        void (*function[NUM_SWITCHES])(ROOM room, ROOMS *rooms) =       {[0 ... NUM_SWITCHES-1] = NULL,
 94                                                                         [SWITCH_LIGHT1] = switch_light1,
 95                                                                         [SWITCH_LIGHT2] = switch_light2,
 96                                                                         [SWITCH_DOOR]   = switch_door,
 97                                                                         [SWITCH_DESK]   = switch_desk };
 98        
 99        for (count = 0; count < NUM_SWITCHES; count++)
 100        {
 101                switches[count].function = function[count];
 102        }
 103
 104
 105
 106void
 107get_switches_state (    SWITCH  switches[NUM_SWITCHES],
 108                        ROOM    room,
 109                        ROOMS   *rooms  )
 110/*
 111Input:
 112        room            - The room in rooms to read the state of the switches from
 113        rooms           - 
 114Output:
 115        switches        - The state of the switches had been set
 116Returns:
 117        -
 118Description:
 119        The function gets the state of the switches of room in rooms and sets them to
 120        switches.
 121*/
 122{
 123        int choice, count;
 124        
 125        /* Set the state of all switches to SWITCH_OFF */
 126        for (count = 0; count < NUM_SWITCHES; count++)
 127        {
 128                switches[count].state = SWITCH_OFF;
 129        }
 130        printf ("The switches of this room can have the following states:\n"
 131                "0. No switch is pressed.\n"
 132                "1. The switch for light 1 is pressed.\n"
 133                "2. The switch for light 2 is pressed.\n"
 134                "3. Both switches for light 1 and 2 are pressed.\n"
 135                "4. The switch beside the door is pressed.\n"
 136                "8. The switch at the desk is pressed.\n"
 137                "Please enter the current state: ");
 138        while (scanf ("%d", &choice) != 1)
 139        {
 140                printf ("You entered an invalid format. Please reenter: ");
 141        }
 142        switch (choice)         /* Which switch is pressed:                     */
 143        {
 144                case 0:         /* No switch                                    */
 145                        break;
 146                case 1:         /* Only the switch for light 1                  */
 147                        switches[SWITCH_LIGHT1].state = SWITCH_ON;
 148                        break;
 149                case 2:         /* Only the switch for light 2                  */
 150                        switches[SWITCH_LIGHT2].state = SWITCH_ON;
 151                        break;
 152                case 3:         /* Both switches for light 2 and light 1        */
 153                        switches[SWITCH_LIGHT1].state = SWITCH_ON;
 154                        switches[SWITCH_LIGHT2].state = SWITCH_ON;
 155                        break;
 156                case 4:         /* The switch beside the door                   */
 157                        switches[SWITCH_DOOR].state = SWITCH_ON;
 158                        break;
 159                case 8:         /* The switch at the desk                       */
 160                        switches[SWITCH_DESK].state = SWITCH_ON;
 161                        break;
 162                default:
 163                        printf ("You entered an invalid option!\n");
 164                        break;
 165        }
 166}
 167
 1 
*****main.c*****
  
 2#include 
 3#include 
 4#include 
 5
 6
 7static void init_system (ROOMS *rooms);
 8static void process_switches (SWITCH switches[NUM_SWITCHES], ROOM room, ROOMS *rooms);
 9static Boolean sim_leave_room (void);
 10static void sim_enter_room (ROOM room, ROOMS *rooms);
 11static Boolean sim_get_room (ROOM *room);
 12
 13
 14void
 15process_switches (      SWITCH          switches[NUM_SWITCHES],
 16                        ROOM            room,
 17                        ROOMS           *rooms      )
 18{
 19        int count;
 20        
 21        for (count = 0; count < NUM_SWITCHES; count++)
 22        {
 23                if (switches[count].state == SWITCH_ON)
 24                {
 25                        (*switches[count].function) (room, rooms);
 26                }
 27        }
 28}
 29
 30
 31Boolean
 32sim_leave_room (void)
 33/*
 34Input:
 35        -
 36Ouput:
 37        -
 38Returns:
 39        TRUE if the user wants to leave the current room, otherwise FALSE.
 40Description:
 41        This function asks the user to leave the current room or not.
 42*/
 43{
 44        char c;
 45        
 46        printf ("Enter 'l' to leave this room or 's' to stay: ");
 47        while (scanf("%c", &c) != 1 || (c != 'l' && c != 's'))
 48        {
 49                printf ("Your choice is invalid. Please reenter: ");
 50        }
 51        if (c == 'l')
 52        {
 53                return (TRUE);
 54        }
 55        return (FALSE);
 56}
 57
 58
 59void
 60sim_enter_room (        ROOM    room,
 61                        ROOMS   *rooms  )
 62/*
 63Input:
 64        room    - The room to enter in rooms
 65Ouput:
 66        rooms   - The collection of rooms in the hotel, where the light state of room
 67                  can be changed of.
 68Returns:
 69        -
 70Description:
 71        This function "enters" room in rooms. The user can change the light state of the
 72        entered room by pushing the switches.
 73*/
 74{
 75        SWITCH          switches[NUM_SWITCHES];
 76        LIGHT_STATE     light1,
 77                        light2;
 78        
 79        printf ("\nWelcome to room %d!\n", (int)room+1);
 80        init_switch_functions (switches);
 81        lights_get_state (room, rooms, &light1, &light2);
 82        lights_set_state (room, rooms, light1, light2);
 83        do
 84        {
 85                get_switches_state (switches, room, rooms);
 86                process_switches (switches, room, rooms);
 87        } while (!sim_leave_room());
 88        printf ("You left room %d. Good bye!\n\n", (int)room+1);
 89}
 90
 91
 92Boolean
 93sim_get_room (ROOM *room)
 94/*
 95Input:
 96        -
 97Output:
 98        room    - The room the user wants to enter
 99Returns:
 100        FALSE if the user wants to quit, otherwise TRUE.
 101Description:
 102        This function asks the user which room to enter or if he/she wants to quit.
 103*/
 104{
 105        char c;
 106        
 107        printf ("This hotel has %d rooms, numbered from 1 to %d.\n"
 108                "Please give number of the room you want to enter (or type 'q' to quit): ", NUM_ROOMS, NUM_ROOMS);
 109        while ( scanf("%d", (int *)room) != 1 || *room < 1 || *room > NUM_ROOMS )
 110        {
 111                if (scanf("%c", &c) && c == 'q')
 112                {
 113                        return (FALSE);
 114                }
 115                printf ("The number you entered is invalid. Please reenter: ");
 116        }
 117        (*room)--;
 118        return (TRUE);
 119}
 120
 121
 122void
 123init_system (ROOMS *rooms)
 124/*
 125Input:
 126        -
 127Output:
 128        rooms   - All rooms will be initialized
 129Returns:
 130        -
 131Description:
 132        init_system() initializes the system by tuning the lights in every
 133        room of rooms of.
 134*/
 135{
 136        int room;
 137        
 138        for (room = 0; room < NUM_ROOMS; room++)
 139        {
 140                lights_set_state (room, rooms, LIGHT_OFF, LIGHT_OFF);
 141        }
 142}
 143
 144
 145int
 146main (void)
 147{
 148        ROOMS   rooms;
 149        ROOM    room;
 150        
 151        printf (".---------------------------------.\n"
 152                "| Welcome to Guesthouse Paradiso! |\n"
 153                "'---------------------------------'\n");
 154        init_system (&rooms); /* Initialize the lights */
 155        while ( sim_get_room(&room) )
 156        {
 157                sim_enter_room (room, &rooms);
 158        }
 159        exit (0);
 160}
 
 
Mijn commentaar
 
 Marvin, in in woord,
 het is [B]AF[/B] !
 Wederom heb je een mooi stuk werk geleverd.
 Jouw ondersteuning voor de leddriver kan ik erg waarderen,
 Waneer je ook input via de leddriver had laten lopen,
 was je het schakel probleem dat Engelbertus ontdekte tegengekomen.
 Waar ik wat minder door gescharmeerd ben is het gebruik van extern in [I]hotel.h[/I]
 Ikzelf zou de voorkeur hebben gegeven, de funcies van [I]switches.c[/I] en [I]light.c[/I]
 in eigen header files [I]switches.h[/I] en [I]light.h[/I] onder te brengen,
 en deze vervolgens bij [I]main.c[/I] te includen welliswaar levert dit bij complexere programma's een hoop puzzelwerk met includefiles op maar het zorgt voor een duidelijker overzicht, een betere scheiding van objects en daardoor een kleinde kans op fouten.
 Toegegeven, de Linux include files maken ook driftig gebruik van extern,
 er zijn n.l. grenzen aan de voordelen versus de tijd die het kost deze uit te voeren.
 
 Met jouw programeer stijl kun je ook eens overwegen iets meer aan OOP te gaan denken,
 jouw werkwijze sluit daar al behoorlijk op aan
 
 Je programma is al met al mooi en netjes uitgewerkt.
 (Daar staat tegenover dat je uit de gegevens die ik gaf duidelijk valt af te leiden dat je gebruik had kunnen maken van vrij eenvoudige binaire logica die je code een stuk korter had kunnen maken.
 ok meteen af van die walchelijke globale variabelen.
 (Ik heb nog zitten ovewegen na mijn FORTRAN debakel iter ilustratie alsnog een CPP versie te maken, maar daarmee overtreed ik mijn eigen regels)