Programmeringsgruppe 1 / Mbed OS Alarmsystem_rev_innlevering

Fork of Alarmsystem_log_funksjon_funker_ikke by Programmeringsgruppe 1

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00002 /////////////////////////////////////////////////////////////////////////////////////////BIBLIOTEK//////////////////////////////////////////////////////////////////
00003 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00004 
00005 
00006 #include "mbed.h"         //Standard bibliotek for mbed
00007 #include "rtos.h"         //OS-5 embed bibliotek for og få benyttet thread - funksjonen.
00008 #include <string>         //Bibliotek for og kunne benytte strenger.
00009 #include <stdio.h>        //Bibliotek for og kunne logge til tekstfil i c++.
00010 
00011 
00012 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00013 /////////////////////////////////////////////////////////////////////////////////////////DEFINISJONER///////////////////////////////////////////////////////////////
00014 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00015 
00016 
00017 #define Inn 4                      //Hensikt: Hvis vi skriver "Inn" skriver vi egentlig tallet 4.
00018 Serial pc(USBTX, USBRX);           //Hensikt: Lage en krets med datamaskinen igjennom USB porten, så vi kan utføre forskjellige ting igjennom f.eks tera-term.
00019 LocalFileSystem local("local");    //Hensikt: Kunne skrive lokalt i en tekst fil i lagringssystemet til mbed.
00020 
00021 
00022 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00023 /////////////////////////////////////////////////////////////////////////////////////////INNGANGER//////////////////////////////////////////////////////////////////
00024 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00025 
00026 
00027 DigitalIn Servicebryter(p20);  //Hensikt: Deklarere en bryter, som skal virke som en "innelåst bryter".
00028 AnalogIn _Sone1(p15);          
00029 AnalogIn _Sone2(p16);          //Hensikt: Deklarasjon av soner, som fungerer ved at det er 2 dører som er koblet i parallell med motstander,
00030 AnalogIn _Sone3(p17);          //              og får dermed inn en voltverdi i inngangen som videre sier noe om hvilken tilstand dørene er i. (åpen / lukket)
00031 AnalogIn _Sone4(p19);
00032 
00033 
00034 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00035 /////////////////////////////////////////////////////////////////////////////////////////UTGANGER///////////////////////////////////////////////////////////////////
00036 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00037 
00038 
00039 DigitalOut Driftslys(LED1);            //Hensikt: Deklarere utgangen Driftslys som skal bli brukt som både alarm (10Hz blinking) og lyse konstant under normaldrift.
00040 DigitalOut Utganger[8] = {p21, p22, p23, p24, p25,p26,p27,p28}; //Hensikt: Deklarere alle lys i en tabell, lysene skal lyse etter hvilket punkt det er alarm på.
00041 
00042 
00043 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00044 /////////////////////////////////////////////////////////////////////////////////////////VARIABLER//////////////////////////////////////////////////////////////////
00045 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00046 
00047 
00048 float Soner[Inn];                  //Hensikt: Deklarere en tabell som vi senere skal legge alle verdiene til de forskjellige sonene inn i.                  
00049 int tilstand[8]= {};               //Hensikt: Sette inn de forskjellige tilstandene til dørene inn i en tabell.
00050 int minne[8] = {};                 //Hensikt: Lagre tilstandene i en annen tabell etter en test, for og sjekke om det er en ny endring i tabellen.
00051 volatile bool running = true;      //Hensikt: Sette funksjonen alarmf i else setning; dvs få lyset (LED1) til og lyse konstant.
00052 volatile bool admin = false;       //Hensikt: Sjekker om vi har skrevet inn passord for og starte anlegget.
00053 volatile bool start = false;       //Hensikt: Sjekker om vi har skrevet inn "Start" på tasturet, for og starte alarmanlegget.
00054 volatile bool stopp = true;        //Hensikt: Sjekker om vi har skrevet inn "Stopp" på tasturet, for og stoppe alarmanlegget.
00055 string passord = ("admin");        //Hensikt: Legge inn "admin" inn i en streng som er passordet til anlegget
00056 string start_kommando = ("start"); //Hensikt: Legge inn "start" inn i en streng som er strengen for starte anlegget.
00057 string stopp_kommando = ("stopp"); //Hensikt: Legge inn "stopp" inn i en streng som er strengen for og stoppe anlegget.
00058 Timer t;                           //Hensikt: Deklarere en timer, som skal skal sjekke tiden som har gått etter oppstart.
00059 int v = 0;                         //Hensikt: Printe til datamaskinen en gang, når man blir sendt inn i funksjonen password_check. ("Skriv Passord: ")
00060 
00061 
00062 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00063 ///////////////////////////////////////////////////////////////////////////////FUNKSJON DEKLARASJONER///////////////////////////////////////////////////////////////
00064 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00065            
00066                                  
00067 void Alarmf();                   // Hensikten til funksjonene er beskrevet nærmere ovenfor funksjonen, deklarasjoner skal bare vise compileren at funksjonene kommer
00068 Thread Alarm;                    //      senere i programmet vårt.
00069 Thread Read;
00070 void admin_access_granted();
00071 void sone_monitor();
00072 int log_to_file(int, int);
00073 void password_check();
00074 void compare_commands();
00075 void start_sys();
00076 void stopp_sys();
00077 int logg_start();
00078 int logg_stopp();
00079 int request_status_sys();
00080 int request_status_alarm(int);
00081 int TilstandSjekk();
00082 extern "C" void mbed_reset();    //Hensikt: Kunne resete alarmsystemet 100% igjennom tastaturet. Dette er en standard funksjon i mbed.
00083 
00084 
00085 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00086 //////////////////////////////////////////////////////////////////////////////////////MAIN//////////////////////////////////////////////////////////////////////////
00087 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00088 
00089 
00090 //Hensikt: Starte funksjoner kontinuerlig i en while løkke utifra de globale variablene våre. Vi sjekker også om servicebryteren er aktivert, og vi vil da sette
00091 //              programmet inn i "innelåst - modus" og resete alarmene. Man har da 10 sekunder på og komme seg ut, før alarmene reaktiverer seg.
00092 
00093 int main()
00094 {
00095     Read.start(password_check);
00096     t.start();
00097     while(1) {
00098         if(Servicebryter == 1) {  // "Innelåst - Modus"
00099             TilstandSjekk();
00100             running = false;
00101             pc.printf("NB! Alle alarmer er i innelast modus i 15 sek!! \n");
00102             wait(15);
00103         }
00104         while((admin) && (Servicebryter == 0)&&(start == true) && (stopp == false)) { // Sjekker globale variabler, for deretter og starte alarmsystemet.
00105             Alarm.start(Alarmf);//Denne funksjonen starter Alarmf i en tråd, dvs at denne går kontinuerlig og ikke stopper opp programmet.
00106             sone_monitor();
00107             wait(0.1);          //Vi benytter en wait funksjon for og få programmet til og fungere, hvis denne ikke er tilstede vil ikke programmet fungere korrekt.
00108             TilstandSjekk();
00109         }
00110     }
00111 }
00112 
00113 
00114 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00115 //////////////////////////////////////////////////////////////////////FUNKSJONER////////////////////////////////////////////////////////////////////////////////////
00116 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00117 
00118 
00119 //Hensikt: Få et lys til og lyse når alarmanlegget er i normaldrift.
00120 //         Hvis alarmanlegget er i alarm-modus skal lyset blinke med en frekvens på 10 Hz.
00121 //         Denne funksjonen blir kalt opp av en thread, som betyr at den kjører kontinuerlig seperat av andre funksjoner.
00122 
00123 void Alarmf(void)
00124 {
00125     while(1) {
00126         if(running == true) {  // Beskrivelse: Running er en global variabel som blir satt til false ved tilstand Normaldrift eller ved servicebryter lagt inn.
00127             Driftslys = !Driftslys;
00128             Thread::wait(20);  //Som vanlig wait funksjon, bare litt annen skrivemåte i thread biblioteket i OS5.
00129         } else {               // Hensikt: Hvis vi er i normaldrift driftlyset lyse kontinuerlig.
00130             Driftslys = 1;
00131         }
00132     }
00133 }
00134 
00135 //Hensikt: Legge måleresultater over motstandene inn i en tabell som videre setter korrekte tilstander inn i en annen tabell.
00136 
00137 void sone_monitor()
00138 {
00139     //Legger først de forskjellige sonene inn i en tabell.
00140     Soner[0] = _Sone1;
00141     Soner[1] = _Sone2;
00142     Soner[2] = _Sone3;
00143     Soner[3] = _Sone4;
00144     for(int i = 0, x = 0; i < 4; i++,x+=2) {              //Hensikt: Sjekker en og en sone.
00145         if( (Soner[i] > 0.35 ) && ( Soner[i] < 0.45) ) {  //Normaldrift: Begge dører lukket. utregnedt verdi: 0.4.
00146             tilstand[x] = 0;            
00147             tilstand[x+1] = 0;
00148         }
00149         if( (Soner[i] > 0.6 ) && ( Soner[i] < 0.7) ) {    //Tilstand1: Dør 1 åpen. Utregnet verdi: 0.65
00150             tilstand[x] = 1;
00151             tilstand[x+1] = 0;
00152             running = true;
00153         }
00154         if( (Soner[i] > 0.46 ) && ( Soner[i] < 0.55) ) {  //Tilstand2: Dør 2 åpen. Utregnet verdi: 0.5
00155             tilstand[x] = 0;
00156             tilstand[x+1] = 1;
00157             running = true;
00158         }
00159         if( (Soner[i] > 0.9) ) {                          //Tilstand 3: Begge dører er åpene. Utregnet verdi: 1. 
00160             tilstand[x] = 1;
00161             tilstand[x+1] = 1;
00162         }
00163     }
00164 }
00165 
00166 //Hensikt: Sette utgangsalarmlysene på ettersom tabellen tilstand[i] endrer seg. Sjekker om tilstandene er ulike som minne, hvis det er tilfelle setter vi de ulike
00167 //               verdiene direkte til alarmutgangs tabellen. Etter dette starter vi log funksjonen for og logge endringen. Hvis den globale variabelen running
00168 //               ikke er true nullstiller vi alarmutgangene. 
00169 
00170 int TilstandSjekk() 
00171 {
00172     if( running == true) {
00173         for (int i = 0; i < 8; i++) {
00174             if(minne[i] != tilstand[i]) {
00175                 Utganger[i] = 1;    
00176                 minne[i] = tilstand[i];
00177                 log_to_file(i,Utganger[i]);
00178             }
00179         }
00180     } else {
00181         for (int i = 0; i < 8; i++) {
00182             Utganger[i] = 0;
00183         }
00184     }
00185     return 0;
00186 }
00187 
00188 ////////////////////////////////////////////////////////////
00189 /////////////////Mulige logg innforinger////////////////////
00190 // Tid: t sekunder                                        //
00191 // Alarm 1 har blitt utloost // Dette betyr Sone 1 door 1 //
00192 // Alarm 2 har blitt utloost // Dette betyr Sone 1 door 2 //
00193 // Alarm 3 har blitt utloost // Dette betyr Sone 2 door 1 //
00194 // Alarm 4 har blitt utloost // Dette betyr Sone 2 door 2 //
00195 // Alarm 5 har blitt utloost // Dette betyr Sone 3 door 1 //
00196 // Alarm 6 har blitt utloost // Dette betyr Sone 3 door 2 //
00197 // Alarm 7 har blitt utloost // Dette betyr Sone 4 door 1 //
00198 // Alarm 8 har blitt utloost // Dette betyr Sone 4 door 2 //
00199 ////////////////////////////////////////////////////////////
00200 
00201 //Hensikt: Skriver til en tekstfil når en alarm blir utløst. Samtidig som den skriver ned tiden siden anlegget startet.
00202 
00203 int log_to_file(int c, int b)   // c er sone, b er tilsand.
00204 {
00205     FILE *fp ;
00206     fp = fopen( "/local/log.txt", "a" ) ;
00207     if(fp != NULL) {
00208         float tid = t.read();
00209         fprintf(fp, "Tid: %.2f i sekunder siden systemet blir spenningsatt \nAlarm %d: er utloost \n", tid, c+1);
00210     }
00211     fclose(fp);
00212     return 0;
00213 }
00214 
00215 // Hensikt: Sette globale variabler, som har til hensikt å starte alarmanlegget. 
00216 //          Minne tabellen som blir sammenlignet med utganger blir også nullstilt i denne funksjonen, for og vite
00217 //                 om det har vært en alarm før funksjonen startet.
00218 //          Itillegg skriver den ut en rekke forskjellige kommandoer som kan bli benyttet
00219 //          til å kjøre forskjellige funksjoner i tera terma / annet program som skriver til pc. 
00220 
00221 void admin_access_granted()
00222 {
00223     admin = true;
00224     running = false;
00225     for (int i=0; i<8; i++) {  //Hensikt: Setter alle elementene i tabellen minne til 0, for og nullstille.
00226         minne[i] = 0;
00227     } 
00228     pc.printf("\nAdministrator tilgang innvilget\n");                                //Hensikt: Gi info
00229     pc.printf("Folgende kommandoer kan brukes: \n");                                 //Hensikt: Skrive ut en liste over alle funksjoner som er tilgjenglig.
00230     pc.printf("Starte overvaaking av systemet. Kommando: 'start' + 'Enter'\n");      //Hensikt: Starter alarmanlegget.
00231     pc.printf("Stoppe overvaaking av systemet. Kommando: 'stopp' + 'Enter'\n");      //Hensikt: Stopper alarmanlegget.
00232     pc.printf("Status alarm for hver sone. Kommando: 'staa1' + 'Enter' \n");                     //Hensikt: Sjekke om det er en alarm ved et spesifikk punkt.
00233     pc.printf("Status alle soner og dorer. Kommando: 'status' + 'Enter' \n");                  //Hensikt: Sjekke statusen til alle dører i alle sonere.
00234     pc.printf("Reset hele systemet. Kommando: 'reset' + 'Enter' \n");                          //Hensikt: Resete hele systemet.
00235     compare_commands();
00236 }
00237 
00238 //Hensikt: Passordbeskytter alarmsystemet ved hjelp av en string, funksjonen kjører i en thread, som vil si
00239 //                at denne går kontinuerlig sammen med resten av programmet.
00240 //         Når passord er riktig tastet inn, vil den alltid sørge for at compare_commands() kommandoen kjører.
00241 
00242 void password_check()
00243 {
00244     if(v == 0) {
00245         pc.printf("Skriv passord: ");
00246         v = 1;
00247     }
00248     if(admin == false) {
00249         char tastepassord[20];
00250         pc.scanf("%s",&tastepassord);
00251         int k = strcmp(tastepassord, "passord\0");
00252         if(!k) {
00253             admin_access_granted();
00254         }
00255     }
00256     while(admin == true) {
00257         compare_commands();
00258     }
00259 }
00260 
00261 
00262 //Hensikt: Sjekke inntastet verdi på tastatur oppimot våre funksjoner, for deretter og starte opp funksjoner som utfører 
00263 //                riktige ting utifra inntastet verdi. Etter hver sjekk vil tabellen bli cleared.
00264 
00265 void compare_commands()
00266 {
00267     char read[20];
00268     pc.scanf("%s",&read);
00269     if(!strcmp(read, "start\0"))start_sys();
00270     if(!strcmp(read, "stopp\0")) stopp_sys();
00271     if(!strcmp(read, "reset\0")) mbed_reset();
00272     if(!strcmp(read, "reqa1\0")) request_status_alarm(1);
00273     if(!strcmp(read, "reqa2\0")) request_status_alarm(2);
00274     if(!strcmp(read, "reqa3\0")) request_status_alarm(3);
00275     if(!strcmp(read, "reqa4\0")) request_status_alarm(4);
00276     if(!strcmp(read, "reqa5\0")) request_status_alarm(5); 
00277     if(!strcmp(read, "reqa6\0")) request_status_alarm(6);
00278     if(!strcmp(read, "reqa7\0")) request_status_alarm(7);
00279     if(!strcmp(read, "reqa8\0")) request_status_alarm(8);
00280     if(!strcmp(read, "status\0")) request_status_sys();
00281     for (int i=0; i<19; i++) {
00282         read[i] = 0;
00283     }
00284 }
00285 
00286 //Hensikt: Starte alarmanlegget og kalle opp logg funksjonen for og logge start.
00287 
00288 void start_sys() 
00289 {
00290     start = true;
00291     stopp = false;
00292     pc.printf("Systemet ble startet\n");
00293     logg_start();
00294 }
00295 
00296 //Hensikt: Stopper alarmanlegget ved hjelp av globale variabler og kaller opp logg funksjonen for og logge stopp.
00297 
00298 void stopp_sys()
00299 {
00300     start = false;
00301     stopp = true;
00302     pc.printf("Systemet ble stoppet\n");
00303     logg_stopp();
00304 }
00305 
00306 //Hensikt: Skrive til en fil på pc, når alarmanlegget ble startet i tid fra spenningssetting.
00307 
00308 int logg_start()
00309 {
00310     FILE *fp ;
00311     fp = fopen( "/local/log.txt", "a" ) ;
00312     if(fp != NULL) {
00313         float tid = t.read();
00314         fprintf(fp, "Tid: %.2f i sekunder siden systemet blir spenningsatt \n Overvaakingen ble startet \n", tid);//t er tid
00315 
00316         fclose(fp);
00317         return 0;
00318     } else {
00319         return 1;
00320     }
00321 }
00322 
00323 //Hensikt: Skrive til en fil på pc, når alarmanlegget ble stoppet i tid fra spenningssetting.
00324 
00325 int logg_stopp()
00326 {
00327     FILE *fp ;
00328     fp = fopen( "/local/log.txt", "a" ) ;
00329     if(fp != NULL) {
00330         float tid = t.read();
00331         fprintf(fp, "Tid: %.2f i sekunder siden systemet blir spenningsatt \n Overvaakingen ble stoppet \n", tid);//t er tid
00332         fclose(fp);
00333         return 0;
00334     } else {
00335         return 1;
00336     }
00337 }
00338 
00339 //Hensikt: Skrive til status til alle dører til pc / tera term.
00340 
00341 int request_status_alarm(int v)
00342 {
00343     switch(v) {
00344         case 1:
00345             if(Utganger[v] == 1) {
00346                 pc.printf("Door 1 i sone 1 er utloost\n");
00347             } else {
00348                 pc.printf("Door 1 i sone 1 er ikke utloost\n");
00349             }
00350             break;
00351         case 2:
00352             if(Utganger[v] == 1) {
00353                 pc.printf("Door 2 i sone 1 er utloost\n");
00354             } else {
00355                 pc.printf("Door 2 i sone 1 er ikke utloost\n");
00356             }
00357             break;
00358         case 3:
00359             if(Utganger[v] == 1) {
00360                 pc.printf("Door 1 i sone 2 er utloost\n");
00361             } else {
00362                 pc.printf("Door 1 i sone 2 er ikke utloost\n");
00363             }
00364             break;
00365         case 4:
00366             if(Utganger[v] == 1) {
00367                 pc.printf("Door 2 i sone 2 er utloost\n");
00368             } else {
00369                 pc.printf("Door 2 i sone 2 er ikke utloost\n");
00370             }
00371             break;
00372         case 5:
00373             if(Utganger[v] == 1) {
00374                 pc.printf("Door 1 i sone 3 er utloost\n");
00375             } else {
00376                 pc.printf("Door 1 i sone 3 er ikke utloost\n");
00377             }
00378             break;
00379         case 6:
00380             if(Utganger[v] == 1) {
00381                 pc.printf("Door 2 i sone 3 er utloost\n");
00382             } else {
00383                 pc.printf("Door 2 i sone 3 er ikke utloost\n");
00384             }
00385             break;
00386         case 7:
00387             if(Utganger[v] == 1) {
00388                 pc.printf("Door 1 i sone 4 er utloost\n");
00389             } else {
00390                 pc.printf("Door 1 i sone 4 er ikke utloost\n");
00391             }
00392             break;
00393         case 8:
00394             if(Utganger[v] == 1) {
00395                 pc.printf("Door 2 i sone 4 er utloost\n");
00396             } else {
00397                 pc.printf("Door 2 i sone 4 er ikke utloost\n");
00398             }
00399             break;
00400     }
00401     return 0;
00402 }
00403 
00404 //Hensikt: Skrive status til alarmpunkt utifra inntastet valg på tastatur.
00405 
00406 int request_status_sys()
00407 {
00408     for(int u = 0; u <8; u++) {
00409         if(Utganger[u] == 1) {
00410             pc.printf("Alarm %d er utloost\n", u+1);
00411         } else {
00412             pc.printf("Alarm %d er ikke utloost\n", u+1);
00413         }
00414     }
00415     return 0;
00416 }