pwm2test.cpp

a program that generates a pulse-width modulated (PWM)signal.

// Pulse Width Modulation (PWM) Generator --
// This version generates independent PWM signals by
// instantiating additional tasks from the same classes.
// Sample program
// File: pwm2test.cpp
// Created  12/25/95, DM Auslander (from other examples)
// This sample has no operator interface

#define MAIN_CPP

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#include "tasks.hpp" // Task and environment info

static StopControlNow = 0;
char *StopMessage = NULL;
void StopControl(char *aMessage)
    {
    StopControlNow = 1;
    StopMessage = new char[strlen(aMessage) + 1];
    strcpy(StopMessage, aMessage);
    }

double EndTime = 0.4;  // make this value visible to other function
          // in this file (use big number to run forever)

void main(void)
    {
    // These variables are used to keep track of when the
    // scheduler must exit.
    double TheTime;

    // Declaration of TList pointers are in tasks.hpp
    LowPriority = new TList("Low Priority");
    Intermittent = new TList("Intermittent"); // No min-latency
         // list for this project so this list will remain empty
    #ifdef ISR_SCHEDULING
    Preemptable = new TList("Preemptable"); // When using timer
      // interrupt no preemptable tasks are used, only 'interrupt'
    Interrupt = new TList("Interrupt");
    #endif // ISR_SCHEDULING

    // Create all of the task objects used in the project
   // Two instantiations (that is, two tasks) will be created
   // from the PWMTask class.  PWMSup will send independent
   // command signals to both of the PWM tasks
    PWM1 = new PWMTask("PWM1");
    PWM2 = new PWMTask("PWM2");
    PWMSup = new PWMSupTask("PWMSup",0.4,0.2);
         // 2nd argument is the
         // period of the duty cycle command signal for the
         // 1st PWM and the third argument is for the other PWM
    // Define another task object for running the simulation.
    // This task is scheduled just as any other tasks, and is
    // only added to the task list if a simulation is desired.
    // The actual simulation code in contained in the Run()
    // member function of SimulationTask.
   // (There is no simulation in this example)
    #ifdef SIMULATION
    SimTask = new SimulationTask("Simulation");
    #endif //SIMULATION

    // All tasks must be added to the task list here.
    #ifdef ISR_SCHEDULING
    //Preemptable->Append();
    Interrupt->Append(PWM1);
    Interrupt->Append(PWM2);
    #else // ISR_SCHEDULING
    //Intermittent->Append(PWM);
    LowPriority->Append(PWM1);
    LowPriority->Append(PWM2);
    #endif // ISR_SCHEDULING

    LowPriority->Append(PWMSup);
    #ifdef SIMULATION
    LowPriority->Append(SimTask);
    #endif //SIMULATION

    // Set up a data output object
   // Arguments for DataOutput:
   // int nvars,double STime,double LTime,double DTime
   // 'nvars' is the number of dependent variables -- time
   // will be placed in the first column automatically
    DataOutput *DataOut1 = new DataOutput(4,0.0,EndTime,0.001);
   // DataOutput has 4 dependent variables for the 2 PWMs

    // You must call this function to initialize the Audit
    // trail array before you write to it.
    InitAuditTrail();

   // There is no operator interface, so it the next two statements
   // aren't neede
    //cout << "Maximize window if necessary. ENTER to continue...\n";
    //getch();

    #ifdef ISR_SCHEDULING
    SetupTimerInterrupt();
    #else // ISR_SCHEDULING
    // Set the proper mode for the timer
    SetupClock(-1.0);
    #endif // ISR_SCHEDULING

    // Scheduler loop.  Inside this loop, you MUST NOT call
    // any terminal I/O functions such as printf, cout,
    // getchar, scanf, etc.  This includes inside the run
    // functions of the tasks.  These things are OK in
    // SIMULATION ONLY.  Use #ifdef SIMULATION (or something
    // similar) if you have sections of code in which you
    // want to print to the screen (for debugging).
    while (((TheTime = GetTimeNow()) <= EndTime)
                 && (TheTime >= 0.0) && (!StopControlNow))
      {
      if(DataOut1->IsTimeForOutput())
            {
            double val1,dc1,val2,dc2;
         val1 = PWM1->GetPWMOutput();
         val2 = PWM2->GetPWMOutput();
         dc1 = PWMSup->GetDutyCycle(1);
         dc2 = PWMSup->GetDutyCycle(2);
            DataOut1->AddData(dc1,val1,dc2,val2, END_OF_ARGS);
            IncrementTime();    // Account for time spend in output recording
            }
        // Run LowPriority and Intermittent list
        if (TaskDispatcher(LowPriority,Intermittent))
            StopControl("\n***Problem with background tasks***\n");
        }
    #ifdef ISR_SCHEDULING
    RestoreTimerInterrupt();
    #endif // ISR_SCHEDULING

    //clrscr ();    // Clear the operator interface

   if (StopMessage == NULL)
      cout << "\n\n***Normal Program Termination***\n\n";
   else
      cout << StopMessage;

    // There are two versions of the audit trail, one with task
    //  names and one with task numbers instead (for matlab)
    WriteAuditTrail("trail.txt");
    WriteAuditTrailNum("trl_num.txt");
    // open a file to save the output data
    cout << "\nThe time at termination is " << TheTime << "\n";
    // Print the scan statistics to the screen
    WriteScanStat("scans.txt", TheTime);
    // Save the output data to a file
    DataOut1->WriteOutputFile("pwm_out.txt");
    delete DataOut1;  // Done with this object
    PWM1->WritePWMRecord("pwm_rec1.txt");  // PWM event log
    PWM2->WritePWMRecord("pwm_rec2.txt");
    // De-allocate space give to tasks
    delete (LowPriority);
    delete (Intermittent);
    #ifdef ISR_SCHEDULING
    delete (Preemptable);
    delete (Interrupt);
    #endif // ISR_SCHEDULING
    cout << "Hit any key to exit.\n";
    while(!kbhit()) ;  // Wait to exit
   }