repo: controlAviao

aviao:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo

#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex

#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes

typedef struct _MSG_AEROPORTO {
    TCHAR szMessagem[MSGTEXT_SZ];
    int pidMessagemControl; //aviao
    int pidMessagemAviao; //areoporto
    int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;

typedef struct _ControlData { //tipo de estrutura de dados de controlo
    HANDLE hSemBouncer; //semáforo
    //para o mutex
    HANDLE hMapFile, hRWMutex;
    Shared_MSG* shared; // ponteiro para memoria partilhada
    HANDLE newmsg; //ponteiro para o evento
    int continuar; // vairvel para terminar as threads
} CData;

//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
    Shared_MSG msg; //estrutura local


    while (pcd->continuar)
    {
        msg.pidMessagemAviao = GetCurrentProcessId();

        if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0 || (pcd->shared->pidMessagemAviao == GetCurrentProcessId() && pcd->shared->comando == 2))
        {
            _tprintf(TEXT("\ndone.."));
            break;
        }
        _tprintf(TEXT("\n[aviao: %d]Escreve mensagem (fim para sair)"), msg.pidMessagemAviao);
        wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
        //_tprintf(TEXT("%s\n"), msg.szMessagem);

        msg.comando = 1;
        WaitForSingleObject(pcd->hRWMutex, INFINITE);
        CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        //assinlar que há nova mensagem
        SetEvent(pcd->newmsg);
        //esperar que mensagem seja lida por outros processos
        Sleep(MSG_DELAY);
        //desativar evento
        ResetEvent(pcd->newmsg);
    }
    pcd->continuar = 0;
    _tprintf(TEXT("\nPrograma vai terminar"));
    //para desbloquear a outra thread e sair de imediato
    SetEvent(pcd->newmsg);
}

DWORD WINAPI recebe_msg(LPVOID p)
{
    CData* pcd = (CData*)p;
    Shared_MSG msg;

    while (1)
    {
        WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
        if (!pcd->continuar)
        {
            break;
        }
        WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
        CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        if (msg.pidMessagemAviao == GetCurrentProcessId()) {
            _tprintf(TEXT("\nProblemas com o nome do aeroporto"));
            msg.comando = 1;
        }
        else
        {
            _tprintf(TEXT("\n.."));
            //_tprintf(TEXT("\nRecebi: %s do %d"), msg.szMessagem, msg.pidMessagemControl);
        }

        Sleep(MSG_DELAY * 2);
    }
    //no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
    ResetEvent(pcd->newmsg);
    return 0;
}

BOOL comunicaAeroporto(BOOL valor)
{
    HANDLE sem; // Handle do semáforo
    CData cdata; //estrutura de dados de controlo
    DWORD tid; //estrutura de dados de controlo

#ifdef UNICODE 
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    cdata.hSemBouncer = CreateSemaphore(
        NULL, //atributo de segurança
        MAXUSERS, //começa o programa logo com o max users
        MAXUSERS, //limite de users
        SEM_BOUNCER_NAME //nome do semaforo
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nerro a criar semaforo"));
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("Semáforo criado\n"));
    }

    cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
        SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
        FALSE,
        SEM_BOUNCER_NAME
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("Semáforo aberto.\n"));
    }

    _tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
    WaitForSingleObject(cdata.hSemBouncer, INFINITE);

    //criar a zona de memória 
    cdata.hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        sizeof(Shared_MSG),
        SHM_NAME
    );

    if (cdata.hMapFile == NULL)
    {
        _tprintf(TEXT("Problema em criar zona de memoria (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada zona de memoria."));
    }

    //criar a zona de memória - a vista
    cdata.shared = (Shared_MSG*)MapViewOfFile(
        cdata.hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0, //vista sobre a memoria inteira
        sizeof(Shared_MSG)
    );

    if (cdata.shared == NULL)
    {
        _tprintf(TEXT("Problema em criar a vista (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada a vista."));
    }

    //criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
    cdata.hRWMutex = CreateMutex(
        NULL,
        FALSE,
        MUTEX_NAME
    );

    if (cdata.hRWMutex == NULL)
    {
        _tprintf(TEXT("Problema em criar o mutex (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nmutex criado."));
    }

    cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
    cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));

    if (cdata.newmsg == NULL)
    {
        _tprintf(TEXT("Erro ao criar evento %s (%d).\n"), TEXT("Evento"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nEvento lançado com sucesso"));
    }

    _tprintf(TEXT("Lançar a thread para ouvir o que se passa\n"));
    cdata.continuar = 1;
    sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
    le_envia(&cdata);

    _tprintf(TEXT("Este cliente vai fechar\n"));
    WaitForSingleObject(sem, INFINITE);
    _tprintf(TEXT("Thread ouvinte encerrada\n"));

    ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);

    UnmapViewOfFile(cdata.shared); //memoria partilhada
    CloseHandle(cdata.hMapFile);
    CloseHandle(cdata.newmsg);
    CloseHandle(cdata.hSemBouncer);

    valor = TRUE;
    return valor;
}


int _tmain(int argc, TCHAR* argv[]) {
    BOOL entra = FALSE;



    while (entra == FALSE)
    {
        entra = comunicaAeroporto(FALSE);
    }
    _tprintf(TEXT("\ntou feliz... cara#######"));
    return 0;
}

control:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo

#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex

#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes

typedef struct _MSG_AEROPORTO {
    TCHAR szMessagem[MSGTEXT_SZ];
    int pidMessagemControl; //aviao
    int pidMessagemAviao; //areoporto
    int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;

typedef struct _ControlData { //tipo de estrutura de dados de controlo
    HANDLE hSemBouncer; //semáforo
    //para o mutex
    HANDLE hMapFile, hRWMutex;
    Shared_MSG* shared; // ponteiro para memoria partilhada
    HANDLE newmsg; //ponteiro para o evento
    int continuar; // vairvel para terminar as threads
} CData;

//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
    Shared_MSG msg; //estrutura local

    while (pcd->continuar)
    {
        msg.pidMessagemControl = GetCurrentProcessId();
        _tprintf(TEXT("\n[control: %d] Escreve mensagem (fim para sair)"), msg.pidMessagemControl);
        wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
        //_tprintf(TEXT("%s\n"), msg.szMessagem);


        if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0)
        {
            break;
        }

        WaitForSingleObject(pcd->hRWMutex, INFINITE);
        CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        //assinlar que há nova mensagem
        SetEvent(pcd->newmsg);
        //esperar que mensagem seja lida por outros processos
        Sleep(MSG_DELAY);
        //desativar evento
        ResetEvent(pcd->newmsg);
    }
    pcd->continuar = 0;
    _tprintf(TEXT("\nPrograma vai terminar"));
    //para desbloquear a outra thread e sair de imediato
    SetEvent(pcd->newmsg);
}

DWORD WINAPI recebe_msg(LPVOID p)
{
    CData* pcd = (CData*)p;
    Shared_MSG msg;
    TCHAR nome[MSGTEXT_SZ];
    _tcscpy_s(nome, _countof(nome), _T("coimbra"));

    while (1)
    {
        WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
        if (!pcd->continuar)
        {
            break;
        }
        WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
        CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        if (msg.comando == 1) {
            _tprintf(TEXT("\nRecebi: %s do %d\n"), msg.szMessagem, msg.pidMessagemAviao);
            if (wcscmp(msg.szMessagem, _T("coimbra")) == 0)
            {
                _tprintf(TEXT("\nSenhor aviao existe esse aeroporto.. volte sempre %d!"), msg.pidMessagemAviao);
                pcd->shared->pidMessagemAviao = msg.pidMessagemAviao;
                pcd->shared->comando = 2;
                //Sleep(MSG_DELAY);
            }
            else
            {
                pcd->shared->comando = -1;
            }
        }
        else
        {
            _tprintf(TEXT("\nAguardo por um pedido formal"));
            pcd->shared->comando = -1;
        }
        Sleep(MSG_DELAY * 2);
        pcd->shared->comando = -1;
    }
    //no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
    ResetEvent(pcd->newmsg);
    return 0;
}
BOOL comunicaAeroporto(BOOL valor)
{
    HANDLE sem; // Handle do semáforo
    CData cdata; //estrutura de dados de controlo
    DWORD tid; //estrutura de dados de controlo

#ifdef UNICODE 
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    cdata.hSemBouncer = CreateSemaphore(
        NULL, //atributo de segurança
        MAXUSERS, //começa o programa logo com o max users
        MAXUSERS, //limite de users
        SEM_BOUNCER_NAME //nome do semaforo
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nerro a criar semaforo"));
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nSemáforo criado"));
    }

    cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
        SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
        FALSE,
        SEM_BOUNCER_NAME
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nSemáforo aberto."));
    }

    _tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
    WaitForSingleObject(cdata.hSemBouncer, INFINITE);

    //criar a zona de memória 
    cdata.hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        sizeof(Shared_MSG),
        SHM_NAME
    );

    if (cdata.hMapFile == NULL)
    {
        _tprintf(TEXT("\nProblema em criar zona de memoria (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada zona de memoria."));
    }

    //criar a zona de memória - a vista
    cdata.shared = (Shared_MSG*)MapViewOfFile(
        cdata.hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0, //vista sobre a memoria inteira
        sizeof(Shared_MSG)
    );

    if (cdata.shared == NULL)
    {
        _tprintf(TEXT("\nProblema em criar a vista (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada a vista."));
    }

    //criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
    cdata.hRWMutex = CreateMutex(
        NULL,
        FALSE,
        MUTEX_NAME
    );

    if (cdata.hRWMutex == NULL)
    {
        _tprintf(TEXT("\nProblema em criar o mutex (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nmutex criado."));
    }

    cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
    cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));

    if (cdata.newmsg == NULL)
    {
        _tprintf(TEXT("\nErro ao criar evento %s (%d)."), TEXT("Evento"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nEvento lançado com sucesso"));
    }

    _tprintf(TEXT("\nLançar a thread para ouvir o que se passa"));
    cdata.continuar = 1;
    sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
    le_envia(&cdata);

    _tprintf(TEXT("\nEste cliente vai fechar"));
    WaitForSingleObject(sem, INFINITE);
    _tprintf(TEXT("\nThread ouvinte encerrada"));

    ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);

    UnmapViewOfFile(cdata.shared); //memoria partilhada
    CloseHandle(cdata.hMapFile);
    CloseHandle(cdata.newmsg);
    CloseHandle(cdata.hSemBouncer);

    valor = TRUE;
    return valor;
}


int _tmain(int argc, TCHAR* argv[]) {
    BOOL entra = FALSE;

    while (entra == FALSE)
    {
        entra = comunicaAeroporto(FALSE);
    }
}
Tags : ,

0 thoughts on “repo: controlAviao”

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.