comparison core/RTAudio.cpp @ 108:3068421c0737 ultra-staging

Merged default into ultra-staging

 
 // Xenomai-specific includes
 #include <sys/mman.h>
 #include <native/task.h>
 #include <native/timer.h>
+#include <native/intr.h>
 #include <rtdk.h>
 
-#include "../include/RTAudio.h"
+#include "../include/BeagleRT.h"
 #include "../include/PRU.h"
 #include "../include/I2c_Codec.h"
-#include "../include/render.h"
 #include "../include/GPIOcontrol.h"
-#include "../include/client.h"
+
+// ARM interrupt number for PRU event EVTOUT7
+#define PRU_RTAUDIO_IRQ		21
 
 using namespace std;
 
 // Data structure to keep track of auxiliary tasks we
 // can schedule

 	char *name;
 	int priority;
 } InternalAuxiliaryTask;
 
 const char gRTAudioThreadName[] = "beaglert-audio";
+const char gRTAudioInterruptName[] = "beaglert-pru-irq";
 
 // Real-time tasks and objects
 RT_TASK gRTAudioThread;
+#ifdef BEAGLERT_USE_XENOMAI_INTERRUPTS
+RT_INTR gRTAudioInterrupt;
+#endif
 PRU *gPRU = 0;
 I2c_Codec *gAudioCodec = 0;
 
 vector<InternalAuxiliaryTask*> gAuxTasks;
 
 // Flag which tells the audio task to stop
 bool gShouldStop = false;
 
 // general settings
-char *gPRUFilename;//[256]	 = "pru_rtaudio.bin"; 	// path to PRU binary file
+char gPRUFilename[MAX_PRU_FILENAME_LENGTH];		// Path to PRU binary file (internal code if empty)_
 int gRTAudioVerbose = 0;   						// Verbosity level for debugging
 int gAmplifierMutePin = -1;
 int gAmplifierShouldBeginMuted = 0;
 
-// Number of audio and analog channels, globally accessible
-// At least gNumAnalogChannels and gNumDigitalChannels need to be global to be used
-// by the AnalogRead() and AnalogWrite() and the digital macros without creating
-// extra confusion in their use cases by passing this argument
-int gNumAudioChannels = 0;
-int gNumAnalogChannels = 0;
-int gNumDigitalChannels = 0;
-
-
-void printIntervals(){
-	rt_printf("\n");
-	gPRU->renderTimer.print();
-	gPRU->sleepTimer.print();
-}
+// Context which holds all the audio/sensor data passed to the render routines
+BeagleRTContext gContext;
+
+// User data passed in from main()
+void *gUserData;
 
 // initAudio() prepares the infrastructure for running PRU-based real-time
 // audio, but does not actually start the calculations.
 // periodSize indicates the number of _sensor_ frames per period: the audio period size
 // is twice this value. In total, the audio latency in frames will be 4*periodSize,
 // plus any latency inherent in the ADCs and DACs themselves.
 // useAnalog indicates whether to enable the ADC and DAC or just use the audio codec.
 // numAnalogChannels indicates how many ADC and DAC channels to use.
-// userData is an opaque pointer which will be passed through to the initialise_render()
+// userData is an opaque pointer which will be passed through to the setup()
 // function for application-specific use
 //
 // Returns 0 on success.
 
-
-int BeagleRT_initAudio(RTAudioSettings *settings, void *userData)
+int BeagleRT_initAudio(BeagleRTInitSettings *settings, void *userData)
 {
 	rt_print_auto_init(1);
-	setVerboseLevel(settings->verbose);
-	gPRUFilename=settings->pruFilename;
-	if(gRTAudioVerbose == 1)
-		rt_printf("Running with Xenomai\n");
+
+	BeagleRT_setVerboseLevel(settings->verbose);
+	strncpy(gPRUFilename, settings->pruFilename, MAX_PRU_FILENAME_LENGTH);
+	gUserData = userData;
+
+	// Initialise context data structure
+	memset(&gContext, 0, sizeof(BeagleRTContext));
 
 	if(gRTAudioVerbose) {
 		cout << "Starting with period size " << settings->periodSize << "; ";
 		if(settings->useAnalog)
 			cout << "analog enabled\n";

 	if(settings->numAnalogChannels <= 2 && settings->periodSize < 4) {
 		cout << "Error: " << settings->numAnalogChannels << " channels and period size of " << settings->periodSize << " not supported.\n";
 		return 1;
 	}
 
+	// Initialise the rendering environment: sample rates, frame counts, numbers of channels
+	gContext.audioSampleRate = 44100.0;
+	gContext.audioChannels = 2;
+
+	if(settings->useAnalog) {
+		gContext.audioFrames = settings->periodSize * settings->numAnalogChannels / 4;
+
+		gContext.analogFrames = settings->periodSize;
+		gContext.analogChannels = settings->numAnalogChannels;
+		gContext.analogSampleRate = gContext.audioSampleRate * 4.0 / (float)settings->numAnalogChannels;
+	}
+	else {
+		gContext.audioFrames = settings->periodSize * 2;
+
+		gContext.analogFrames = 0;
+		gContext.analogChannels = 0;
+		gContext.analogSampleRate = 0;
+	}
+
+	// For now, digital frame rate is equal to audio frame rate
+	if(settings->useDigital) {
+		gContext.digitalFrames = gContext.audioFrames;
+		gContext.digitalSampleRate = gContext.audioSampleRate;
+		gContext.digitalChannels = settings->numDigitalChannels;
+	}
+	else {
+		gContext.digitalFrames = 0;
+		gContext.digitalSampleRate = 0;
+		gContext.digitalChannels = 0;
+	}
+
+	// Set flags based on init settings
+	if(settings->interleave)
+		gContext.flags |= BEAGLERT_FLAG_INTERLEAVED;
+	if(settings->analogOutputsPersist)
+		gContext.flags |= BEAGLERT_FLAG_ANALOG_OUTPUTS_PERSIST;
+
 	// Use PRU for audio
-	gPRU = new PRU();
+	gPRU = new PRU(&gContext);
 	gAudioCodec = new I2c_Codec();
 
-	gNumDigitalChannels = settings->useDigital ? settings->numDigitalChannels : 0; //this is called here to make sure prepareGPIO initializes the appropriate GPIO pins
-	if(gPRU->prepareGPIO(settings->useAnalog, settings->useDigital, 1, 1)) {
+	// Initialise the GPIO pins, including possibly the digital pins in the render routines
+	if(gPRU->prepareGPIO(1, 1)) {
 		cout << "Error: unable to prepare GPIO for PRU audio\n";
 		return 1;
 	}
+
+	// Get the PRU memory buffers ready to go
 	if(gPRU->initialise(0, settings->periodSize, settings->numAnalogChannels, true)) {
 		cout << "Error: unable to initialise PRU\n";
 		return 1;
 	}
+
+	// Prepare the audio codec, which clocks the whole system
 	if(gAudioCodec->initI2C_RW(2, settings->codecI2CAddress, -1)) {
 		cout << "Unable to open codec I2C\n";
 		return 1;
 	}
 	if(gAudioCodec->initCodec()) {

 	// Set default volume levels
 	BeagleRT_setDACLevel(settings->dacLevel);
 	BeagleRT_setADCLevel(settings->adcLevel);
 	BeagleRT_setHeadphoneLevel(settings->headphoneLevel);
 
-	// Initialise the rendering environment: pass the number of audio and analog
-	// channels, the period size for analog and audio, and the sample rates
-
-	int audioPeriodSize = settings->periodSize * 2;
-	float audioSampleRate = 44100.0;
-	float analogSampleRate = 22050.0;
-	if(settings->useAnalog) {
-		audioPeriodSize = settings->periodSize * settings->numAnalogChannels / 4;
-		analogSampleRate = audioSampleRate * 4.0 / (float)settings->numAnalogChannels;
-	}
-
-	gNumAudioChannels = 2;
-	gNumAnalogChannels = settings->useAnalog ? settings->numAnalogChannels : 0;
-	if(!initialise_render(gNumAnalogChannels, gNumDigitalChannels, gNumAudioChannels,
-				          settings->useAnalog ? settings->periodSize : 0, /* analog period size */
-				          audioPeriodSize,
-				          analogSampleRate, audioSampleRate,
-				          userData, settings)) {
+	// Call the user-defined initialisation function
+	if(!setup(&gContext, userData)) {
 		cout << "Couldn't initialise audio rendering\n";
 		return 1;
 	}
-	gPRU->printIntervalsTask=createAuxiliaryTaskLoop(*printIntervals, 10, "transmit-receive-data");
+
 	return 0;
 }
 
 // audioLoop() is the main function which starts the PRU audio code
 // and then transfers control to the PRU object. The PRU object in

 		rt_printf("Error: unable to start I2C audio codec\n");
 		gShouldStop = 1;
 	}
 	else {
 		if(gPRU->start(gPRUFilename)) {
-			rt_printf("Error: unable to start PRU %s\n", gPRUFilename);
+			rt_printf("Error: unable to start PRU from file %s\n", gPRUFilename);
 			gShouldStop = 1;
 		}
 		else {
 			// All systems go. Run the loop; it will end when gShouldStop is set to 1
 

 					if(gRTAudioVerbose)
 						rt_printf("Warning: couldn't set value (high) on amplifier mute pin\n");
 				}
 			}
 
-			gPRU->loop();
-
+#ifdef BEAGLERT_USE_XENOMAI_INTERRUPTS
+			gPRU->loop(&gRTAudioInterrupt, gUserData);
+#else
+			gPRU->loop(0, gUserData);
+#endif
 			// Now clean up
 			// gPRU->waitForFinish();
 			gPRU->disable();
 			gAudioCodec->stopAudio();
 			gPRU->cleanupGPIO();

 	if(gRTAudioVerbose == 1)
 		rt_printf("audio thread ended\n");
 }
 
 // Create a calculation loop which can run independently of the audio, at a different
-// (equal or lower) priority. Audio priority is 99; priority should be generally be less than this.
+// (equal or lower) priority. Audio priority is defined in BEAGLERT_AUDIO_PRIORITY;
+// priority should be generally be less than this.
 // Returns an (opaque) pointer to the created task on success; 0 on failure
-AuxiliaryTask createAuxiliaryTaskLoop(void (*functionToCall)(void), int priority, const char *name)
+AuxiliaryTask BeagleRT_createAuxiliaryTask(void (*functionToCall)(void), int priority, const char *name)
 {
 	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
 
 	// Attempt to create the task
 	if(rt_task_create(&(newTask->task), name, 0, priority, T_JOINABLE | T_FPU)) {

 	return (AuxiliaryTask)newTask;
 }
 
 // Schedule a previously created auxiliary task. It will run when the priority rules next
 // allow it to be scheduled.
-void scheduleAuxiliaryTask(AuxiliaryTask task)
+void BeagleRT_scheduleAuxiliaryTask(AuxiliaryTask task)
 {
 	InternalAuxiliaryTask *taskToSchedule = (InternalAuxiliaryTask *)task;
 
 	rt_task_resume(&taskToSchedule->task);
 }

 // It launches the real-time Xenomai task which runs the audio loop. Returns 0
 // on success.
 
 int BeagleRT_startAudio()
 {
-	// Create audio thread with the highest priority
-	if(rt_task_create(&gRTAudioThread, gRTAudioThreadName, 0, 99, T_JOINABLE | T_FPU)) {
+	// Create audio thread with high Xenomai priority
+	if(rt_task_create(&gRTAudioThread, gRTAudioThreadName, 0, BEAGLERT_AUDIO_PRIORITY, T_JOINABLE | T_FPU)) {
 		  cout << "Error: unable to create Xenomai audio thread" << endl;
 		  return -1;
 	}
+
+#ifdef BEAGLERT_USE_XENOMAI_INTERRUPTS
+	// Create an interrupt which the audio thread receives from the PRU
+	int result = 0;
+	if((result = rt_intr_create(&gRTAudioInterrupt, gRTAudioInterruptName, PRU_RTAUDIO_IRQ, I_NOAUTOENA)) != 0) {
+		cout << "Error: unable to create Xenomai interrupt for PRU (error " << result << ")" << endl;
+		return -1;
+	}
+#endif
 
 	// Start all RT threads
 	if(rt_task_start(&gRTAudioThread, &audioLoop, 0)) {
 		  cout << "Error: unable to start Xenomai audio thread" << endl;
 		  return -1;

 }
 
 // Free any resources associated with PRU real-time audio
 void BeagleRT_cleanupAudio()
 {
-	cleanup_render();
+	cleanup(&gContext, gUserData);
 
 	// Clean up the auxiliary tasks
 	vector<InternalAuxiliaryTask*>::iterator it;
 	for(it = gAuxTasks.begin(); it != gAuxTasks.end(); it++) {
 		InternalAuxiliaryTask *taskStruct = *it;
 
+		// Delete the task
+		rt_task_delete(&taskStruct->task);
+
 		// Free the name string and the struct itself
 		free(taskStruct->name);
 		free(taskStruct);
 	}
 	gAuxTasks.clear();
+
+	// Delete the audio task and its interrupt
+#ifdef BEAGLERT_USE_XENOMAI_INTERRUPTS
+	rt_intr_delete(&gRTAudioInterrupt);
+#endif
+	rt_task_delete(&gRTAudioThread);
 
 	if(gPRU != 0)
 		delete gPRU;
 	if(gAudioCodec != 0)
 		delete gAudioCodec;

 
 	return gpio_set_value(gAmplifierMutePin, pinValue);
 }
 
 // Set the verbosity level
-void setVerboseLevel(int level)
+void BeagleRT_setVerboseLevel(int level)
 {
 	gRTAudioVerbose = level;
 }