uGFX
/
ugfx
2
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

GAUDIN implemented with GADC driver

ugfx_release_2.6
Andrew Hannam 2013-03-01 09:04:52 +10:00
parent 9bec5967b2
commit 6ee8b005ae
18 changed files with 1449 additions and 496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
demos/modules/gaudin/gfxconf.h 100644
View File

@ -0,0 +1,105 @@
/**
* This file has a different license to the rest of the GFX system.
* You can copy, modify and distribute this file as you see fit.
* You do not need to publish your source modifications to this file.
* The only thing you are not permitted to do is to relicense it
* under a different license.
*/
/**
* Copy this file into your project directory and rename it as gfxconf.h
* Edit your copy to turn on the GFX features you want to use.
*/
#ifndef _GFXCONF_H
#define _GFXCONF_H
/* GFX sub-systems to turn on */
#define GFX_USE_GDISP TRUE
#define GFX_USE_TDISP FALSE
#define GFX_USE_GWIN TRUE
#define GFX_USE_GEVENT FALSE
#define GFX_USE_GTIMER TRUE
#define GFX_USE_GINPUT FALSE
#define GFX_USE_GADC TRUE
#define GFX_USE_GAUDIN TRUE
#define GFX_USE_GAUDOUT FALSE
#define GFX_USE_GMISC FALSE
/* Features for the GDISP sub-system. */
#define GDISP_NEED_VALIDATION TRUE
#define GDISP_NEED_CLIP TRUE
#define GDISP_NEED_TEXT FALSE
#define GDISP_NEED_CIRCLE FALSE
#define GDISP_NEED_ELLIPSE FALSE
#define GDISP_NEED_ARC FALSE
#define GDISP_NEED_SCROLL FALSE
#define GDISP_NEED_PIXELREAD FALSE
#define GDISP_NEED_CONTROL FALSE
#define GDISP_NEED_MULTITHREAD TRUE
#define GDISP_NEED_ASYNC FALSE
#define GDISP_NEED_MSGAPI FALSE
/* GDISP - builtin fonts */
#define GDISP_OLD_FONT_DEFINITIONS FALSE
#define GDISP_INCLUDE_FONT_SMALL FALSE
#define GDISP_INCLUDE_FONT_LARGER FALSE
#define GDISP_INCLUDE_FONT_UI1 FALSE
#define GDISP_INCLUDE_FONT_UI2 FALSE
#define GDISP_INCLUDE_FONT_LARGENUMBERS FALSE
/* Features for the TDISP subsystem. */
#define TDISP_NEED_MULTITHREAD FALSE
/* Features for the GWIN sub-system. */
#define GWIN_NEED_BUTTON FALSE
#define GWIN_NEED_CONSOLE FALSE
#define GWIN_NEED_GRAPH FALSE
/* Features for the GEVENT sub-system. */
#define GEVENT_ASSERT_NO_RESOURCE FALSE
/* Features for the GTIMER sub-system. */
/* NONE */
/* Features for the GINPUT sub-system. */
#define GINPUT_NEED_MOUSE FALSE
#define GINPUT_NEED_KEYBOARD FALSE
#define GINPUT_NEED_TOGGLE FALSE
#define GINPUT_NEED_DIAL FALSE
/* Features for the GADC sub-system. */
/* NONE */
/* Features for the GAUDIN sub-system. */
/* NONE */
/* Features for the GAUDOUT sub-system. */
/* NONE */
/* Features for the GMISC sub-system. */
#define GMISC_NEED_ARRAYOPS FALSE
/* Optional Parameters for various sub-systems */
/*
#define GDISP_MAX_FONT_HEIGHT 16
#define GEVENT_MAXIMUM_SIZE 32
#define GEVENT_MAX_SOURCE_LISTENERS 32
#define GTIMER_THREAD_WORKAREA_SIZE 512
#define GADC_MAX_LOWSPEED_DEVICES 4
*/
/* Optional Low Level Driver Definitions */
/*
#define GDISP_USE_CUSTOM_BOARD FALSE
#define GDISP_SCREEN_WIDTH 320
#define GDISP_SCREEN_HEIGHT 240
#define GDISP_USE_FSMC
#define GDISP_USE_GPIO
#define GDISP_VMT_NAME1(x) x##YourDriver1
#define GDISP_VMT_NAME2(x) x##YourDriver2
#define TDISP_COLUMNS 16
#define TDISP_ROWS 2
*/
#endif /* _GFXCONF_H */

190
demos/modules/gaudin/gwinosc.c 100644
View File

@ -0,0 +1,190 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* --------------------------- Our Custom GWIN Oscilloscope ---------------
*
* This GWIN superset implements a simple audio oscilloscope using the GAUDIN module.
*
* It makes many assumptions, the most fundamental of which is that the audio device
* produces unsigned integer samples.
*
* The GMISC module with GMISC_NEED_ARRAYOPS could be used to process the samples more
* correctly if we were really building something generic.
*/
#include "ch.h"
#include "hal.h"
#include "gfx.h"
#include "gwinosc.h"
/* Include internal GWIN routines so we can build our own superset class */
#include "gwin/internal.h"
/* Our GWIN identifier */
#define GW_SCOPE (GW_FIRST_USER_WINDOW+0)
/* The size of our dynamically allocated audio buffer */
#define AUDIOBUFSZ 64*2
/* How many flat-line sample before we trigger */
#define FLATLINE_SAMPLES 8
GHandle gwinCreateScope(GScopeObject *gs, coord_t x, coord_t y, coord_t cx, coord_t cy, uint16_t channel, uint32_t frequency) {
/* Initialise the base class GWIN */
if (!(gs = (GScopeObject *)_gwinInit((GWindowObject *)gs, x, y, cx, cy, sizeof(GScopeObject))))
return 0;
/* Initialise the scope object members and allocate memory for buffers */
gs->gwin.type = GW_SCOPE;
chBSemInit(&gs->bsem, TRUE);
gs->nextx = 0;
if (!(gs->lastscopetrace = (coord_t *)chHeapAlloc(NULL, gs->gwin.width * sizeof(coord_t))))
return 0;
if (!(gs->audiobuf = (adcsample_t *)chHeapAlloc(NULL, AUDIOBUFSZ * sizeof(adcsample_t))))
return 0;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
gs->lasty = gs->gwin.height/2;
#elif TRIGGER_METHOD == TRIGGER_MINVALUE
gs->lasty = gs->gwin.height/2;
gs->scopemin = 0;
#endif
/* Start the GADC high speed converter */
gaudinInit(channel, frequency, gs->audiobuf, AUDIOBUFSZ, AUDIOBUFSZ/2);
gaudinSetBSem(&gs->bsem, &gs->myEvent);
gaudinStart();
return (GHandle)gs;
}
void gwinWaitForScopeTrace(GHandle gh) {
#define gs ((GScopeObject *)(gh))
int i;
coord_t x, y;
coord_t yoffset;
audin_sample_t *pa;
coord_t *pc;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
bool_t rdytrigger;
int flsamples;
#elif TRIGGER_METHOD == TRIGGER_MINVALUE
bool_t rdytrigger;
int flsamples;
coord_t scopemin;
#endif
/* Wait for a set of audio conversions */
chBSemWait(&gs->bsem);
/* Ensure we are drawing in the right area */
#if GDISP_NEED_CLIP
gdispSetClip(gh->x, gh->y, gh->width, gh->height);
#endif
yoffset = gh->height/2 + (1<<SCOPE_Y_BITS)/2;
x = gs->nextx;
pc = gs->lastscopetrace+x;
pa = gs->myEvent.buffer;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
rdytrigger = FALSE;
flsamples = 0;
#elif TRIGGER_METHOD == TRIGGER_MINVALUE
rdytrigger = FALSE;
flsamples = 0;
scopemin = 0;
#endif
for(i = gs->myEvent.count; i; i--) {
/* Calculate the new scope value - re-scale using simple shifts for efficiency, re-center and y-invert */
#if GAUDIN_BITS_PER_SAMPLE > SCOPE_Y_BITS
y = yoffset - (*pa++ >> (GAUDIN_BITS_PER_SAMPLE - SCOPE_Y_BITS));
#else
y = yoffset - (*pa++ << (SCOPE_Y_BITS - GAUDIN_BITS_PER_SAMPLE));
#endif
#if TRIGGER_METHOD == TRIGGER_MINVALUE
/* Calculate the scopemin ready for the next trace */
if (y > scopemin)
scopemin = y;
#endif
/* Have we reached the end of a scope trace? */
if (x >= gh->width) {
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP || TRIGGER_METHOD == TRIGGER_MINVALUE
/* Handle triggering - we trigger on the next sample minimum (y value maximum) or a flat-line */
#if TRIGGER_METHOD == TRIGGER_MINVALUE
/* Arm when we reach the sample minimum (y value maximum) of the previous trace */
if (!rdytrigger && y >= gs->scopemin)
rdytrigger = TRUE;
#endif
if (y == gs->lasty) {
/* Trigger if we get too many flat-line samples regardless of the armed state */
if (++flsamples < FLATLINE_SAMPLES)
continue;
flsamples = 0;
} else if (y > gs->lasty) {
gs->lasty = y;
flsamples = 0;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
/* Arm the trigger when samples fall (y increases) ie. negative slope */
rdytrigger = TRUE;
#endif
continue;
} else {
/* If the trigger is armed, Trigger when samples increases (y decreases) ie. positive slope */
gs->lasty = y;
flsamples = 0;
if (!rdytrigger)
continue;
}
/* Ready for a the next trigger cycle */
rdytrigger = FALSE;
#endif
/* Prepare for a scope trace */
x = 0;
pc = gs->lastscopetrace;
}
/* Clear the old scope pixel and then draw the new scope value */
gdispDrawPixel(gh->x+x, gh->y+pc[0], gh->bgcolor);
gdispDrawPixel(gh->x+x, gh->y+y, gh->color);
/* Save the value */
*pc++ = y;
x++;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP || TRIGGER_METHOD == TRIGGER_MINVALUE
gs->lasty = y;
#endif
}
gs->nextx = x;
#if TRIGGER_METHOD == TRIGGER_MINVALUE
gs->scopemin = scopemin;
#endif
#undef gs
}

95
demos/modules/gaudin/gwinosc.h 100644
View File

@ -0,0 +1,95 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _GWINOSC_H
#define _GWINOSC_H
/**
* --------------------------- Our Custom GWIN Oscilloscope ---------------
*
* This GWIN superset implements a simple audio oscilloscope using the GADC high speed device.
*
* It makes many assumptions, the most fundamental of which is that the audio device
* produces unsigned integer samples.
*
* The GMISC module with GMISC_NEED_ARRAYOPS could be used to process the samples more
* correctly if we were really building something generic.
*/
/* The extent of scaling for our audio data - fixed scale at the moment */
#ifndef SCOPE_Y_BITS
#define SCOPE_Y_BITS 8 // 8 bits = 0..255
#endif
/* Trigger methods */
#define TRIGGER_NONE 0 /* No triggering */
#define TRIGGER_POSITIVERAMP 1 /* Trigger on a positive going signal */
#define TRIGGER_MINVALUE 2 /* Trigger on reaching the minimum value from the last scope */
/**
* Which trigger we want to use.
* Experiments suggests that TRIGGER_MINVALUE gives the best result
*/
#ifndef TRIGGER_METHOD
#define TRIGGER_METHOD TRIGGER_MINVALUE
#endif
/* A scope window object. Treat it as a black box */
typedef struct GScopeObject_t {
GWindowObject gwin; // Base Class
coord_t *lastscopetrace; // To store last scope trace
BinarySemaphore bsem; // We get signalled on this
audin_sample_t *audiobuf; // To store audio samples
GEventAudioIn myEvent; // Information on received samples
coord_t nextx; // Where we are up to
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
coord_t lasty; // The last y value - used for trigger slope detection
#elif TRIGGER_METHOD == TRIGGER_MINVALUE
coord_t lasty; // The last y value - used for trigger slope detection
coord_t scopemin; // The last scopes minimum value
#endif
} GScopeObject;
#ifdef __cplusplus
extern "C" {
#endif
/**
* Create a scope window.
*/
GHandle gwinCreateScope(GScopeObject *gs, coord_t x, coord_t y, coord_t cx, coord_t cy, uint16_t channel, uint32_t frequency);
/**
* Wait for a scope trace to be ready and then draw it.
*/
void gwinWaitForScopeTrace(GHandle gh);
/**
* We should also have a special destroy routine here as we have dynamically
* allocated some memory. There is no point implementing this however as, for
* this demo, we never destroy the window.
*/
#ifdef __cplusplus
}
#endif
#endif /* _GWINOSC_H */

67
demos/modules/gaudin/main.c 100644
View File

@ -0,0 +1,67 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* This demo demonstrates the use of the GAUDIN module to read audio channel 0.
* The audio channel gets read to display a very simple oscilloscope.
*
* It also demonstrates how to write your own custom GWIN window type.
*/
#include "ch.h"
#include "hal.h"
#include "gfx.h"
/* Include our custom gwin audio oscilloscope */
#include "gwinosc.h"
/* Specify our timing parameters */
#define MY_AUDIO_FREQUENCY 4000 /* 4khz */
#define MY_AUDIO_CHANNEL 0 /* Use channel 0 */
/* Data */
static GScopeObject gScopeWindow;
/*
* Application entry point.
*/
int main(void) {
GHandle ghScope;
coord_t swidth, sheight;
halInit();
chSysInit();
gdispInit();
gdispClear(Black);
/* Get the screen dimensions */
swidth = gdispGetWidth();
sheight = gdispGetHeight();
/* Set up the scope window to fill the screen */
ghScope = gwinCreateScope(&gScopeWindow, 0, 0, swidth, sheight, MY_AUDIO_CHANNEL, MY_AUDIO_FREQUENCY);
gwinSetBgColor(ghScope, White);
gwinSetColor(ghScope, Red);
gwinClear(ghScope);
/* Just keep displaying the scope traces */
while (TRUE) {
gwinWaitForScopeTrace(ghScope);
}
}

BIN
demos/modules/gaudin/results_264x264.jpg 100644
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

7
drivers/gadc/AT91SAM7/gadc_lld_config.h
View File

@ -60,6 +60,11 @@
*/ */
#define GADC_BITS_PER_SAMPLE AT91_ADC1_RESOLUTION #define GADC_BITS_PER_SAMPLE AT91_ADC1_RESOLUTION
/**
* @brief The sample format
*/
#define GADC_SAMPLE_FORMAT ARRAY_DATA_10BITUNSIGNED
/* Pull in board specific defines */ /* Pull in board specific defines */
#if defined(GADC_USE_CUSTOM_BOARD) && GADC_USE_CUSTOM_BOARD #if defined(GADC_USE_CUSTOM_BOARD) && GADC_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */ /* Include the user supplied board definitions */
@ -73,6 +78,6 @@
#endif /* GFX_USE_GADC */ #endif /* GFX_USE_GADC */
#endif /* _GDISP_LLD_CONFIG_H */ #endif /* GADC_LLD_CONFIG_H */
/** @} */ /** @} */

76
drivers/gaudin/gadc/gaudin_lld.c 100644
View File

@ -0,0 +1,76 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file drivers/gaudin/gadc/gaudin.c
* @brief GAUDIN - Driver file for using the cpu ADC (via GADC).
*
* @addtogroup GAUDIN
*
* @{
*/
#include "ch.h"
#include "hal.h"
/**
* We are now implementing the driver - pull in our channel table
* from the board definitions.
*/
#define GAUDIN_LLD_IMPLEMENTATION
#include "gfx.h"
#if GFX_USE_GAUDIN
/* Double check the GADC system is turned on */
#if !GFX_USE_GADC
#error "GAUDIN - The GADC driver for GAUDIN requires GFX_USE_GADC to be TRUE"
#endif
/* Include the driver defines */
#include "gaudin/lld/gaudin_lld.h"
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
void gaudin_lld_init(const gaudin_params *paud) {
/* Setup the high speed GADC */
gadcHighSpeedInit(gaudin_lld_physdevs[paud->channel], paud->frequency, paud->buffer, paud->bufcount, paud->samplesPerEvent);
/* Register ourselves for ISR callbacks */
gadcHighSpeedSetISRCallback(GAUDIN_ISR_CompleteI);
/**
* The gadc driver handles any errors for us by restarting the transaction so there is
* no need for us to setup anything for GAUDIN_ISR_ErrorI()
*/
}
void gadc_lld_start(void) {
gadcHighSpeedStart();
}
void gadc_lld_stop(void) {
gadcHighSpeedStop();
}
#endif /* GFX_USE_GAUDIN */
/** @} */

5
drivers/gaudin/gadc/gaudin_lld.mk 100644
View File

@ -0,0 +1,5 @@
# List the required driver.
GFXSRC += $(GFXLIB)/drivers/gaudin/gadc/gaudin_lld.c
# Required include directories
GFXINC += $(GFXLIB)/drivers/gaudin/gadc

60
drivers/gaudin/gadc/gaudin_lld_board_olimexsam7ex256.h 100644
View File

@ -0,0 +1,60 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file drivers/gaudin/gadc/gaudin_lld_board_olimexsam7ex256.h
* @brief GAUDIN Driver board config file for the Olimex SAM7EX256 board
*
* @addtogroup GAUDIN
* @{
*/
#ifndef _GAUDIN_LLD_BOARD_OLIMEXSAM7EX256_H
#define _GAUDIN_LLD_BOARD_OLIMEXSAM7EX256_H
/*===========================================================================*/
/* Audio inputs on this board */
/*===========================================================================*/
/**
* @brief The number of audio channels supported by this driver
*/
#define GAUDIN_NUM_CHANNELS 1
/**
* @brief The list of audio channels and their uses
* @{
*/
#define GAUDIN_MICROPHONE 0
/** @} */
/**
* @brief The following defines are for the low level driver use only
* @{
*/
#ifdef GAUDIN_LLD_IMPLEMENTATION
static uint32_t gaudin_lld_physdevs[GAUDIN_NUM_CHANNELS] = {
GADC_PHYSDEV_MICROPHONE,
};
#endif
/** @} */
#endif /* _GAUDIN_LLD_BOARD_OLIMEXSAM7EX256_H */
/** @} */

79
drivers/gaudin/gadc/gaudin_lld_config.h 100644
View File

@ -0,0 +1,79 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file drivers/gaudin/gadc/gaudin_lld_config.h
* @brief GAUDIN Driver config file.
*
* @addtogroup GAUDIN
* @{
*/
#ifndef GAUDIN_LLD_CONFIG_H
#define GAUDIN_LLD_CONFIG_H
#if GFX_USE_GAUDIN
/*===========================================================================*/
/* Driver hardware support. */
/*===========================================================================*/
/**
* @brief The audio input sample type
* @details For this driver it matches the cpu sample type
*/
typedef adcsample_t audin_sample_t;
/**
* @brief The maximum sample frequency supported by this audio device
* @details For this driver it matches the GADC maximum high speed sample rate
*/
#define GAUDIN_MAX_SAMPLE_FREQUENCY GADC_MAX_HIGH_SPEED_SAMPLERATE
/**
* @brief The number of bits in a sample
* @details For this driver it matches the cpu sample bits
*/
#define GAUDIN_BITS_PER_SAMPLE GADC_BITS_PER_SAMPLE
/**
* @brief The format of an audio sample
* @details For this driver it matches the cpu sample format
*/
#define GAUDIN_SAMPLE_FORMAT GADC_SAMPLE_FORMAT
/**
* For the GAUDIN driver that uses GADC - all the remaining config definitions are specific
* to the board.
*/
#if defined(GADC_USE_CUSTOM_BOARD) && GADC_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */
#include "gaudin_lld_board.h"
#elif defined(BOARD_OLIMEX_SAM7_EX256)
#include "gaudin_lld_board_olimexsam7ex256.h"
#else
/* Include the user supplied board definitions */
#include "gaudin_lld_board.h"
#endif
#endif /* GFX_USE_GAUDIN */
#endif /* GAUDIN_LLD_CONFIG_H */
/** @} */

34
include/gadc/gadc.h
View File

@ -96,10 +96,15 @@ typedef struct GEventADC_t {
} GEventADC; } GEventADC;
/** /**
* @brief A callback function (executed in a thread context) * @brief A callback function (executed in a thread context) for a low speed conversion
*/ */
typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param); typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param);
/**
* @brief A callback function (executed in an ISR context) for a high speed conversion
*/
typedef void (*GADCISRCallbackFunction)(adcsample_t *buffer, size_t size);
/*===========================================================================*/ /*===========================================================================*/
/* External declarations. */ /* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
@ -121,9 +126,9 @@ extern "C" {
* @note If the high speed ADC is running it will be stopped. The Event subsystem is * @note If the high speed ADC is running it will be stopped. The Event subsystem is
* disconnected from the high speed ADC and any binary semaphore event is forgotten. * disconnected from the high speed ADC and any binary semaphore event is forgotten.
* @note bufcount must be greater than countPerEvent (usually 2 or more times) otherwise * @note bufcount must be greater than countPerEvent (usually 2 or more times) otherwise
* the buffer will be overwitten with new data while the application is still trying * the buffer will be overwritten with new data while the application is still trying
* to process the old data. * to process the old data.
* @note Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not * @note Due to a bug/feature in Chibi-OS countPerEvent must be even. If bufcount is not
* evenly divisable by countPerEvent, the remainder must also be even. * evenly divisable by countPerEvent, the remainder must also be even.
* @note The physdev parameter may be used to turn on more than one ADC channel. * @note The physdev parameter may be used to turn on more than one ADC channel.
* Each channel is then interleaved into the provided buffer. Note 'bufcount' * Each channel is then interleaved into the provided buffer. Note 'bufcount'
@ -143,8 +148,7 @@ extern "C" {
* @note While the high speed ADC is running, low speed conversions can only occur at * @note While the high speed ADC is running, low speed conversions can only occur at
* the frequency of the high speed events. Thus if high speed events are * the frequency of the high speed events. Thus if high speed events are
* being created at 50Hz (eg countPerEvent = 100, frequency = 5kHz) then the maximum * being created at 50Hz (eg countPerEvent = 100, frequency = 5kHz) then the maximum
* frequency for low speed conversions is likely to be 50Hz (although it might be * frequency for low speed conversions will be 50Hz.
* 100Hz on some hardware).
* *
* @api * @api
*/ */
@ -159,14 +163,28 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
* called first. This saves processing time if the application does * called first. This saves processing time if the application does
* not want to use the GEVENT sub-system for the high speed ADC. * not want to use the GEVENT sub-system for the high speed ADC.
* Once turned on it can only be turned off by calling @p gadcHighSpeedInit() again. * Once turned on it can only be turned off by calling @p gadcHighSpeedInit() again.
* @note The high speed ADC is capable of signalling via this method and a binary semaphore * @note The high speed ADC is capable of signalling via this method, an ISR callback and a
* at the same time. * binary semaphore at the same time.
* *
* @api * @api
*/ */
GSourceHandle gadcHighSpeedGetSource(void); GSourceHandle gadcHighSpeedGetSource(void);
#endif #endif
/**
* @brief Allow retrieving of results from the high speed ADC using an ISR callback.
*
* @param[in] isrfn The callback function (called in an ISR context).
*
* @note Passing a NULL for isrfn will turn off signalling via this method as will calling
* @p gadcHighSpeedInit().
* @note The high speed ADC is capable of signalling via this method, a binary semaphore and the GEVENT
* sub-system at the same time.
*
* @api
*/
void gadcHighSpeedSetISRCallback(GADCISRCallbackFunction isrfn);
/** /**
* @brief Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer. * @brief Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer.
* *
@ -175,7 +193,7 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
* *
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling * @note Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling
* @p gadcHighSpeedInit(). * @p gadcHighSpeedInit().
* @note The high speed ADC is capable of signalling via this method and the GEVENT * @note The high speed ADC is capable of signalling via this method, an ISR callback and the GEVENT
* sub-system at the same time. * sub-system at the same time.
* *
* @api * @api

350
include/gaudin/gaudin.h
View File

@ -1,170 +1,180 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX. This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful, ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file include/gaudin/gaudin.h * @file include/gaudin/gaudin.h
* @brief GAUDIN - Audio Input subsystem header file. * @brief GAUDIN - Audio Input subsystem header file.
* *
* @addtogroup GAUDIN * @addtogroup GAUDIN
* *
* @{ * @{
*/ */
#ifndef _GAUDIN_H #ifndef _GAUDIN_H
#define _GAUDIN_H #define _GAUDIN_H
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GAUDIN || defined(__DOXYGEN__) #if GFX_USE_GAUDIN || defined(__DOXYGEN__)
/* Include the driver defines */ /* Include the driver defines */
#include "gaudin_lld_config.h" #include "gaudin_lld_config.h"
//audio_in_sample_t
//GAUDIN_SAMPLE_FORMAT ARRAY_DATA_10BITUNSIGNED /*===========================================================================*/
//GAUDIN_STEREO_DEVICE FALSE /* Type definitions */
/*===========================================================================*/
/*===========================================================================*/
/* Type definitions */ // Event types for GAUDIN
/*===========================================================================*/ #define GEVENT_AUDIO_IN (GEVENT_GAUDIN_FIRST+0)
// Event types for GAUDIN /**
#define GEVENT_AUDIO_IN (GEVENT_GAUDIN_FIRST+0) * @brief The Audio Input event structure.
* @{
/** */
* @brief The Audio Input event structure. typedef struct GEventAudioIn_t {
* @{ #if GFX_USE_GEVENT || defined(__DOXYGEN__)
*/ /**
typedef struct GEventAudioIn_t { * @brief The type of this event (GEVENT_AUDIO_IN)
/** */
* @brief The type of this event (GEVENT_AUDIO_IN) GEventType type;
*/ #endif
GEventType type; /**
/** * @brief The current channel
* @brief The event flags */
*/ uint16_t channel;
uint16_t flags; /**
/** * @brief The event flags
* @brief The event flag values. */
* @{ uint16_t flags;
*/ /**
#define GADC_AUDIO_IN_LOSTEVENT 0x0001 /**< @brief The last GEVENT_AUDIO_IN event was lost */ * @brief The event flag values.
/** @} */ * @{
/** */
* @brief The number of audio samples in the buffer #define GADC_AUDIO_IN_LOSTEVENT 0x0001 /**< @brief The last GEVENT_AUDIO_IN event was lost */
*/ /** @} */
size_t count; /**
/** * @brief The number of audio samples in the buffer
* @brief The buffer containing the audio samples */
*/ size_t count;
audio_in_sample_t *buffer; /**
} GEventAudioIn; * @brief The buffer containing the audio samples
*/
/*===========================================================================*/ audin_sample_t *buffer;
/* External declarations. */ } GEventAudioIn;
/*===========================================================================*/
/*===========================================================================*/
#ifdef __cplusplus /* External declarations. */
extern "C" { /*===========================================================================*/
#endif
#ifdef __cplusplus
/** extern "C" {
* @brief Initialise the Audio Input Subsystem. #endif
* @details Initialises but does not start the audio in.
* /**
* @param[in] frequency The sample frequency * @brief Initialise (but not start) the Audio Input Subsystem.
* @param[in] buffer The static buffer to put the samples into. * @details Returns FALSE for an invalid channel or other invalid parameter.
* @param[in] bufcount The total number of conversions that will fit in the buffer. *
* @param[in] countPerEvent The number of conversions to do before returning an event. * @param[in] channel The channel to convert. Can be set from 0 to GAUDIN_NUM_CHANNELS - 1.
* * @param[in] frequency The sample frequency
* @note If the audio input is running it will be stopped. * @param[in] buffer The static buffer to put the samples into.
* @note Due to a bug in Chibi-OS countPerEvent must be even for the GADC audio driver. * @param[in] bufcount The total number of conversions that will fit in the buffer.
* If bufcount is not evenly divisable by countPerEvent, the remainder must also be even. * @param[in] countPerEvent The number of conversions to do before returning an event.
* This requirement may not apply to other GAUDIN drivers. *
* @note The number of samples for stereo devices will be double the number of conversions. * @note Only one channel is active at a time. If an audio input is running it will be stopped.
* Make sure you allocate your buffers large enough. Each channel is then interleaved * The Event subsystem is disconnected from the audio subsystem and any binary semaphore
* into the provided buffer. Note 'bufcount' and 'countPerEvent' parameters describe the * event is forgotten.
* number of conversions not the number of samples. * @note Some channels may be stereo channels which return twice as much sample data with
* @note The buffer is circular. When the end of the buffer is reached it will start * the left and right channel data interleaved. Other channels may be mono channels.
* putting data into the beginning of the buffer again. * Where stereo channels exist it would be common for the low level driver to also
* @note The event listener must process the event (and the data in it) before the * offer the left and right channels separately.
* next event occurs. If not, the following event will be lost. * @note Due to a bug in Chibi-OS countPerEvent must be even if using the GADC low level audio driver.
* @note If bufcount is evenly divisable by countPerEvent, then every event will return * If bufcount is not evenly divisable by countPerEvent, the remainder must also be even.
* countPerEvent conversions. If bufcount is not evenly divisable, it will return * This requirement may not apply to other GAUDIN drivers.
* a block of samples containing less than countPerEvent samples when it reaches the * @note The number of samples for stereo devices will be double the number of conversions.
* end of the buffer. * Make sure you allocate your buffers large enough. Each channel is then interleaved
* * into the provided buffer. Note 'bufcount' and 'countPerEvent' parameters describe the
* @api * number of conversions not the number of samples.
*/ * @note The buffer is circular. When the end of the buffer is reached it will start
void gaudinInit(uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent); * putting data into the beginning of the buffer again.
* @note The event listener must process the event (and the data in it) before the
#if GFX_USE_GEVENT || defined(__DOXYGEN__) * next event occurs. If not, the following event will be lost.
/** * @note If bufcount is evenly divisable by countPerEvent, then every event will return
* @brief Turn on sending results to the GEVENT sub-system. * countPerEvent conversions. If bufcount is not evenly divisable, it will return
* @details Returns a GSourceHandle to listen for GEVENT_AUDIO_IN events. * a block of samples containing less than countPerEvent samples when it reaches the
* * end of the buffer.
* @note The audio input will not use the GEVENT system unless this is *
* called first. This saves processing time if the application does * @api
* not want to use the GEVENT sub-system for audio input. */
* Once turned on it cannot be turned off. bool_t gaudinInit(uint16_t channel, uint32_t frequency, audin_sample_t *buffer, size_t bufcount, size_t samplesPerEvent);
* @note The audio input is capable of signalling via this method and a binary semaphore
* at the same time. #if GFX_USE_GEVENT || defined(__DOXYGEN__)
* /**
* @api * @brief Turn on sending results to the GEVENT sub-system.
*/ * @details Returns a GSourceHandle to listen for GEVENT_AUDIO_IN events.
GSourceHandle gaudinGetSource(void); *
#endif * @note The audio input will not use the GEVENT system unless this is
* called first. This saves processing time if the application does
/** * not want to use the GEVENT sub-system for audio input.
* @brief Allow retrieving of results from the audio input using a Binary Semaphore and a static event buffer. * Once turned on it can only be turned off by calling @p gadcHighSpeedInit() again.
* * @note The audio input is capable of signalling via this method and a binary semaphore
* @param[in] pbsem The binary semaphore is signaled when data is available. * at the same time.
* @param[in] pEvent The static event buffer to place the result information. *
* * @api
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method. */
* @note The audio input is capable of signalling via this method and the GEVENT GSourceHandle gaudinGetSource(void);
* sub-system at the same time. #endif
*
* @api /**
*/ * @brief Allow retrieving of results from the audio input using a Binary Semaphore and a static event buffer.
void gaudinSetBSem(BinarySemaphore *pbsem, GEventAudioIn *pEvent); *
* @param[in] pbsem The binary semaphore is signaled when data is available.
/** * @param[in] pEvent The static event buffer to place the result information.
* @brief Start the audio input conversions. *
* @pre It must have been initialised first with @p gaudinInit() * @note Passing a NULL for pbsem or pEvent will turn off signalling via this method.
* * @note The audio input is capable of signalling via this method and the GEVENT
* @api * sub-system at the same time.
*/ *
GSourceHandle gaudinStart(void); * @api
*/
/** void gaudinSetBSem(BinarySemaphore *pbsem, GEventAudioIn *pEvent);
* @brief Stop the audio input conversions.
* /**
* @api * @brief Start the audio input conversions.
*/ * @pre It must have been initialised first with @p gaudinInit()
void gaudinStop(void); *
* @api
#ifdef __cplusplus */
} void gaudinStart(void);
#endif
/**
#endif /* GFX_USE_GAUDIN */ * @brief Stop the audio input conversions.
*
#endif /* _GAUDIN_H */ * @api
/** @} */ */
void gaudinStop(void);
#ifdef __cplusplus
}
#endif
#endif /* GFX_USE_GAUDIN */
#endif /* _GAUDIN_H */
/** @} */

105
include/gaudin/lld/gaudin_lld.h 100644
View File

@ -0,0 +1,105 @@
/*
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file include/gaudin/lld/gaudin_lld.h
* @brief GAUDIN - Audio Input driver header file.
*
* @defgroup Driver Driver
* @ingroup GAUDIN
* @{
*/
#ifndef _GAUDIN_LLD_H
#define _GAUDIN_LLD_H
#include "gfx.h"
#if GFX_USE_GADC || defined(__DOXYGEN__)
/*===========================================================================*/
/* Type definitions */
/*===========================================================================*/
/**
* @brief The structure passed to start a audio conversion
* @note We use the structure instead of parameters purely to save
* interrupt stack space which is very limited in some platforms.
* @{
*/
typedef struct gaudin_params_t {
uint16_t channel;
uint32_t frequency;
audin_sample_t *buffer;
size_t bufcount;
size_t samplesPerEvent;
} gaudin_params;
/* @} */
/**
* @brief These routines are the callbacks that the driver uses.
* @details Defined in the high level GAUDIN code.
*
* @icode
* @notapi
* @{
*/
extern void GAUDIN_ISR_CompleteI(audin_sample_t *buffer, size_t n);
extern void GAUDIN_ISR_ErrorI(void);
/**
* @}
*/
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialise the driver
*
* @api
*/
void gaudin_lld_init(const gaudin_params *paud);
/**
* @brief Start the audio input sampling
*
* @api
*/
void gadc_lld_start(void);
/**
* @brief Stop the audio input sampling
*
* @api
*/
void gadc_lld_stop(void);
#ifdef __cplusplus
}
#endif
#endif /* GFX_USE_GADC */
#endif /* _GADC_LLD_H */
/** @} */

340
include/gfx.h
View File

@ -1,170 +1,170 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX. This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful, ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file include/gfx.h * @file include/gfx.h
* @brief GFX system header file. * @brief GFX system header file.
* *
* @addtogroup GFX * @addtogroup GFX
* @{ * @{
*/ */
#ifndef _GFX_H #ifndef _GFX_H
#define _GFX_H #define _GFX_H
/* gfxconf.h is the user's project configuration for the GFX system. */ /* gfxconf.h is the user's project configuration for the GFX system. */
#include "gfxconf.h" #include "gfxconf.h"
/** /**
* @name GFX sub-systems that can be turned on * @name GFX sub-systems that can be turned on
* @{ * @{
*/ */
/** /**
* @brief GFX Graphics Display Basic API * @brief GFX Graphics Display Basic API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Also add the specific hardware driver to your makefile. * @note Also add the specific hardware driver to your makefile.
* Eg. include $(GFXLIB)/drivers/gdisp/Nokia6610/gdisp_lld.mk * Eg. include $(GFXLIB)/drivers/gdisp/Nokia6610/gdisp_lld.mk
*/ */
#ifndef GFX_USE_GDISP #ifndef GFX_USE_GDISP
#define GFX_USE_GDISP FALSE #define GFX_USE_GDISP FALSE
#endif #endif
/** /**
* @brief GFX Text Display Basic API * @brief GFX Text Display Basic API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Also add the specific hardware driver to your makefile. * @note Also add the specific hardware driver to your makefile.
* Eg. include $(GFXLIB)/drivers/tdisp/HD44780/tdisp_lld.mk * Eg. include $(GFXLIB)/drivers/tdisp/HD44780/tdisp_lld.mk
*/ */
#ifndef GFX_USE_TDISP #ifndef GFX_USE_TDISP
#define GFX_USE_TDISP FALSE #define GFX_USE_TDISP FALSE
#endif #endif
/** /**
* @brief GFX Graphics Windowing API * @brief GFX Graphics Windowing API
* @details Defaults to FALSE * @details Defaults to FALSE
* @details Extends the GDISP API to add the concept of graphic windows. * @details Extends the GDISP API to add the concept of graphic windows.
* @note Also supports high-level "window" objects such as console windows, * @note Also supports high-level "window" objects such as console windows,
* buttons, graphing etc * buttons, graphing etc
*/ */
#ifndef GFX_USE_GWIN #ifndef GFX_USE_GWIN
#define GFX_USE_GWIN FALSE #define GFX_USE_GWIN FALSE
#endif #endif
/** /**
* @brief GFX Event API * @brief GFX Event API
* @details Defaults to FALSE * @details Defaults to FALSE
* @details Defines the concept of a "Source" that can send "Events" to "Listeners". * @details Defines the concept of a "Source" that can send "Events" to "Listeners".
*/ */
#ifndef GFX_USE_GEVENT #ifndef GFX_USE_GEVENT
#define GFX_USE_GEVENT FALSE #define GFX_USE_GEVENT FALSE
#endif #endif
/** /**
* @brief GFX Timer API * @brief GFX Timer API
* @details Defaults to FALSE * @details Defaults to FALSE
* @details Provides thread context timers - both one-shot and periodic. * @details Provides thread context timers - both one-shot and periodic.
*/ */
#ifndef GFX_USE_GTIMER #ifndef GFX_USE_GTIMER
#define GFX_USE_GTIMER FALSE #define GFX_USE_GTIMER FALSE
#endif #endif
/** /**
* @brief GFX Input Device API * @brief GFX Input Device API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Also add the specific hardware drivers to your makefile. * @note Also add the specific hardware drivers to your makefile.
* Eg. * Eg.
* include $(GFXLIB)/drivers/ginput/toggle/Pal/ginput_lld.mk * include $(GFXLIB)/drivers/ginput/toggle/Pal/ginput_lld.mk
* and... * and...
* include $(GFXLIB)/drivers/ginput/touch/MCU/ginput_lld.mk * include $(GFXLIB)/drivers/ginput/touch/MCU/ginput_lld.mk
*/ */
#ifndef GFX_USE_GINPUT #ifndef GFX_USE_GINPUT
#define GFX_USE_GINPUT FALSE #define GFX_USE_GINPUT FALSE
#endif #endif
/** /**
* @brief GFX Generic Periodic ADC API * @brief GFX Generic Periodic ADC API
* @details Defaults to FALSE * @details Defaults to FALSE
*/ */
#ifndef GFX_USE_GADC #ifndef GFX_USE_GADC
#define GFX_USE_GADC FALSE #define GFX_USE_GADC FALSE
#endif #endif
/** /**
* @brief GFX Audio Input Device API * @brief GFX Audio Input Device API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Also add the specific hardware drivers to your makefile. * @note Also add the specific hardware drivers to your makefile.
* Eg. * Eg.
* include $(GFXLIB)/drivers/gaudin/GADC/gaudin_lld.mk * include $(GFXLIB)/drivers/gaudin/GADC/gaudin_lld.mk
*/ */
#ifndef GFX_USE_GAUDIN #ifndef GFX_USE_GAUDIN
#define GFX_USE_GAUDIN FALSE #define GFX_USE_GAUDIN FALSE
#endif #endif
/** /**
* @brief GFX Audio Output Device API * @brief GFX Audio Output Device API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Also add the specific hardware drivers to your makefile. * @note Also add the specific hardware drivers to your makefile.
* Eg. * Eg.
* include $(GFXLIB)/drivers/gaudout/PWM/gaudout_lld.mk * include $(GFXLIB)/drivers/gaudout/PWM/gaudout_lld.mk
*/ */
#ifndef GFX_USE_GAUDOUT #ifndef GFX_USE_GAUDOUT
#define GFX_USE_GAUDOUT FALSE #define GFX_USE_GAUDOUT FALSE
#endif #endif
/** /**
* @brief GFX Miscellaneous Routines API * @brief GFX Miscellaneous Routines API
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Turning this on without turning on any GMISC_NEED_xxx macros will result * @note Turning this on without turning on any GMISC_NEED_xxx macros will result
* in no extra code being compiled in. GMISC is made up from the sum of its * in no extra code being compiled in. GMISC is made up from the sum of its
* parts. * parts.
*/ */
#ifndef GFX_USE_GMISC #ifndef GFX_USE_GMISC
#define GFX_USE_GMISC FALSE #define GFX_USE_GMISC FALSE
#endif #endif
/** @} */ /** @} */
/** /**
* Get all the options for each sub-system. * Get all the options for each sub-system.
* *
*/ */
#include "gmisc/options.h" #include "gmisc/options.h"
#include "gevent/options.h" #include "gevent/options.h"
#include "gtimer/options.h" #include "gtimer/options.h"
#include "gdisp/options.h" #include "gdisp/options.h"
#include "gwin/options.h" #include "gwin/options.h"
#include "ginput/options.h" #include "ginput/options.h"
#include "tdisp/options.h" #include "tdisp/options.h"
#include "gadc/options.h" #include "gadc/options.h"
#include "gaudin/options.h" #include "gaudin/options.h"
#include "gaudout/options.h" #include "gaudout/options.h"
/** /**
* Inter-dependancy safety checks on the sub-systems. * Inter-dependancy safety checks on the sub-systems.
* *
*/ */
#include "gfx_rules.h" #include "gfx_rules.h"
/** /**
* Include the sub-system header files * Include the sub-system header files
*/ */
#include "gevent/gevent.h" #include "gmisc/gmisc.h"
#include "gtimer/gtimer.h" #include "gevent/gevent.h"
#include "gdisp/gdisp.h" #include "gtimer/gtimer.h"
#include "gwin/gwin.h" #include "gdisp/gdisp.h"
#include "ginput/ginput.h" #include "gwin/gwin.h"
#include "tdisp/tdisp.h" #include "ginput/ginput.h"
#include "gadc/gadc.h" #include "tdisp/tdisp.h"
#include "gaudin/gaudin.h" #include "gadc/gadc.h"
#include "gaudout/gaudout.h" #include "gaudin/gaudin.h"
#include "gmisc/gmisc.h" #include "gaudout/gaudout.h"
#endif /* _GFX_H */ #endif /* _GFX_H */
/** @} */ /** @} */

11
include/gfx_rules.h
View File

@ -99,6 +99,14 @@
#if GFX_USE_TDISP #if GFX_USE_TDISP
#endif #endif
#if GFX_USE_GAUDIN
#if GFX_USE_GEVENT && !GFX_USE_GTIMER
#warning "GAUDIN: GFX_USE_GTIMER is required if GFX_USE_GAUDIN and GFX_USE_GEVENT are TRUE. It has been turned on for you."
#undef GFX_USE_GTIMER
#define GFX_USE_GTIMER TRUE
#endif
#endif
#if GFX_USE_GADC #if GFX_USE_GADC
#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES #if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
#error "GADC: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h" #error "GADC: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
@ -123,9 +131,6 @@
#endif #endif
#endif #endif
#if GFX_USE_GAUDIN
#endif
#if GFX_USE_GAUDOUT #if GFX_USE_GAUDOUT
#endif #endif

214
include/gmisc/gmisc.h
View File

@ -1,106 +1,108 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX. This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful, ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file include/gmisc/gmisc.h * @file include/gmisc/gmisc.h
* @brief GMISC - Miscellaneous Routines header file. * @brief GMISC - Miscellaneous Routines header file.
* *
* @addtogroup GAUDIN * @addtogroup GAUDIN
* *
* @{ * @{
*/ */
#ifndef _GMISC_H #ifndef _GMISC_H
#define _GMISC_H #define _GMISC_H
#include "gfx.h" #include "gfx.h"
/*===========================================================================*/ /*===========================================================================*/
/* Type definitions */ /* Type definitions */
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @brief Sample data formats * @brief Sample data formats
*/ * @note These are defined regardless of whether you use the GMISC module
typedef enum ArrayDataFormat_e { * or not as they are used in lots of places.
ARRAY_DATA_4BITUNSIGNED = 4, ARRAY_DATA_4BITSIGNED = 5, */
ARRAY_DATA_8BITUNSIGNED = 8, ARRAY_DATA_8BITSIGNED = 9, typedef enum ArrayDataFormat_e {
ARRAY_DATA_10BITUNSIGNED = 10, ARRAY_DATA_10BITSIGNED = 11, ARRAY_DATA_4BITUNSIGNED = 4, ARRAY_DATA_4BITSIGNED = 5,
ARRAY_DATA_12BITUNSIGNED = 12, ARRAY_DATA_12BITSIGNED = 13, ARRAY_DATA_8BITUNSIGNED = 8, ARRAY_DATA_8BITSIGNED = 9,
ARRAY_DATA_14BITUNSIGNED = 14, ARRAY_DATA_14BITSIGNED = 15, ARRAY_DATA_10BITUNSIGNED = 10, ARRAY_DATA_10BITSIGNED = 11,
ARRAY_DATA_16BITUNSIGNED = 16, ARRAY_DATA_16BITSIGNED = 17, ARRAY_DATA_12BITUNSIGNED = 12, ARRAY_DATA_12BITSIGNED = 13,
} ArrayDataFormat; ARRAY_DATA_14BITUNSIGNED = 14, ARRAY_DATA_14BITSIGNED = 15,
ARRAY_DATA_16BITUNSIGNED = 16, ARRAY_DATA_16BITSIGNED = 17,
/*===========================================================================*/ } ArrayDataFormat;
/* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
/* External declarations. */
#if GFX_USE_GMISC || defined(__DOXYGEN__) /*===========================================================================*/
#ifdef __cplusplus #if GFX_USE_GMISC || defined(__DOXYGEN__)
extern "C" {
#endif #ifdef __cplusplus
extern "C" {
#if GMISC_NEED_ARRAYOPS || defined(__DOXYGEN__) #endif
/**
* @brief Convert from one array format to another array format. #if GMISC_NEED_ARRAYOPS || defined(__DOXYGEN__)
* /**
* @param[in] srcfmt The format of the source array * @brief Convert from one array format to another array format.
* @param[in] src The source array *
* @param[in] dstfmt The format of the destination array * @param[in] srcfmt The format of the source array
* @param[in] dst The dstination array * @param[in] src The source array
* @param[in] cnt The number of array elements to convert * @param[in] dstfmt The format of the destination array
* * @param[in] dst The dstination array
* @note Assumes the destination buffer is large enough for the resultant data. * @param[in] cnt The number of array elements to convert
* @note This routine is optimised to perform as fast as possible. *
* @note No type checking is performed on the source format. It is assumed to * @note Assumes the destination buffer is large enough for the resultant data.
* have only valid values eg. ARRAY_DATA_4BITSIGNED will have values * @note This routine is optimised to perform as fast as possible.
* 0000 -> 0111 for positive numbers and 1111 -> 1000 for negative numbers * @note No type checking is performed on the source format. It is assumed to
* Bits 5 -> 8 in the storage byte are treated in an undefined manner. * have only valid values eg. ARRAY_DATA_4BITSIGNED will have values
* @note If srcfmt or dstfmt is an unknown format, this routine does nothing * 0000 -> 0111 for positive numbers and 1111 -> 1000 for negative numbers
* with no warning that something is wrong * Bits 5 -> 8 in the storage byte are treated in an undefined manner.
* * @note If srcfmt or dstfmt is an unknown format, this routine does nothing
* @api * with no warning that something is wrong
*/ *
void gmiscArrayConvert(ArrayDataFormat srcfmt, void *src, ArrayDataFormat dstfmt, void *dst, size_t cnt); * @api
*/
#if 0 void gmiscArrayConvert(ArrayDataFormat srcfmt, void *src, ArrayDataFormat dstfmt, void *dst, size_t cnt);
void gmiscArrayTranslate(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int trans);
#if 0
void gmiscArrayMultiply(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mult); void gmiscArrayTranslate(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int trans);
void gmiscArrayDivide(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mdiv); void gmiscArrayMultiply(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mult);
void gmiscArrayMultDiv(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mult, int div); void gmiscArrayDivide(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mdiv);
void gmiscArrayAdd(ArrayDataFormat fmt, void *src1, void *src2, void *dst, size_t cnt); void gmiscArrayMultDiv(ArrayDataFormat fmt, void *src, void *dst, size_t cnt, int mult, int div);
void gmiscArrayAddNoOverflow(ArrayDataFormat fmt, void *src1, void *src2, void *dst, size_t cnt); void gmiscArrayAdd(ArrayDataFormat fmt, void *src1, void *src2, void *dst, size_t cnt);
#endif
#endif void gmiscArrayAddNoOverflow(ArrayDataFormat fmt, void *src1, void *src2, void *dst, size_t cnt);
#endif
#ifdef __cplusplus #endif
}
#endif #ifdef __cplusplus
}
#endif /* GFX_USE_MISC */ #endif
#endif /* _GMISC_H */ #endif /* GFX_USE_MISC */
/** @} */
#endif /* _GMISC_H */
/** @} */

11
src/gadc/gadc.c
View File

@ -83,6 +83,7 @@ static struct hsdev {
size_t remaining; size_t remaining;
BinarySemaphore *bsem; BinarySemaphore *bsem;
GEventADC *pEvent; GEventADC *pEvent;
GADCISRCallbackFunction isrfn;
} hs; } hs;
static struct lsdev { static struct lsdev {
@ -181,6 +182,11 @@ void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
hs.pEvent->buffer = hs.lastbuffer; hs.pEvent->buffer = hs.lastbuffer;
hs.pEvent->flags = hs.lastflags; hs.pEvent->flags = hs.lastflags;
} }
/* Our three signalling mechanisms */
if (hs.isrfn)
hs.isrfn(buffer, n);
if (hs.bsem) if (hs.bsem)
chBSemSignalI(hs.bsem); chBSemSignalI(hs.bsem);
@ -344,6 +350,7 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
hs.remaining = bufcount; hs.remaining = bufcount;
hs.bsem = 0; hs.bsem = 0;
hs.pEvent = 0; hs.pEvent = 0;
hs.isrfn = 0;
} }
#if GFX_USE_GEVENT #if GFX_USE_GEVENT
@ -356,6 +363,10 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
} }
#endif #endif
void gadcHighSpeedSetISRCallback(GADCISRCallbackFunction isrfn) {
hs.isrfn = isrfn;
}
void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent) { void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent) {
DoInit(); DoInit();

196
src/gaudin/gaudin.c
View File

@ -1,38 +1,158 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX. This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful, ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file src/gaudin/gaudin.c * @file src/gaudin/gaudin.c
* @brief GAUDIN sub-system code. * @brief GAUDIN sub-system code.
* *
* @addtogroup GAUDIN * @addtogroup GAUDIN
* @{ * @{
*/ */
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GAUDIN || defined(__DOXYGEN__) #if GFX_USE_GAUDIN
#error "GAUDIN: Not implemented yet" /* Include the driver defines */
#include "gaudin/lld/gaudin_lld.h"
#endif /* GFX_USE_GAUDIN */
/** @} */ static gaudin_params aud;
static BinarySemaphore *paudSem;
static GEventAudioIn *paudEvent;
static audin_sample_t *lastbuffer;
static size_t lastcount;
static uint16_t audFlags;
#define AUDFLG_RUNNING 0x0001
#define AUDFLG_USE_EVENTS 0x0002
#if GFX_USE_GEVENT
static GTIMER_DECL(AudGTimer);
static void AudGTimerCallback(void *param) {
(void) param;
GSourceListener *psl;
GEventADC *pe;
psl = 0;
while ((psl = geventGetSourceListener((GSourceHandle)(&aud), psl))) {
if (!(pe = (GEventAudioIn *)geventGetEventBuffer(psl))) {
// This listener is missing - save this.
psl->srcflags |= GADC_AUDIO_IN_LOSTEVENT;
continue;
}
pe->type = GEVENT_AUDIO_IN;
pe->channel = aud.channel;
pe->count = lastcount;
pe->buffer = lastbuffer;
pe->flags = psl->srcflags;
psl->srcflags = 0;
geventSendEvent(psl);
}
}
#endif
void GAUDIN_ISR_CompleteI(audin_sample_t *buffer, size_t n) {
/* Save the details */
lastcount = n;
lastbuffer = buffer;
/* Signal the user with the data */
if (paudEvent) {
#if GFX_USE_GEVENT
paudEvent->type = GEVENT_AUDIO_IN;
#endif
paudEvent->channel = aud.channel;
paudEvent->count = lastcount;
paudEvent->buffer = lastbuffer;
paudEvent->flags = 0;
}
/* Our two signalling mechanisms */
if (paudSem)
chBSemSignalI(paudSem);
#if GFX_USE_GEVENT
if (audFlags & AUDFLG_USE_EVENTS)
gtimerJabI(&AudGTimer);
#endif
}
void GAUDIN_ISR_ErrorI(void) {
/* Ignore any errors for now */
}
bool_t gaudinInit(uint16_t channel, uint32_t frequency, audin_sample_t *buffer, size_t bufcount, size_t samplesPerEvent) {
/* Check the channel is valid */
if (channel >= GAUDIN_NUM_CHANNELS || frequency > GAUDIN_MAX_SAMPLE_FREQUENCY)
return FALSE;
/* Stop any existing transfers */
if ((audFlags & AUDFLG_RUNNING))
gadc_lld_stop();
audFlags = 0;
/* Initialise everything */
aud.channel = channel;
aud.frequency = frequency;
aud.buffer = buffer;
aud.bufcount = bufcount;
aud.samplesPerEvent = samplesPerEvent;
paudSem = 0;
paudEvent = 0;
/* Set up the low level driver */
gaudin_lld_init(&aud);
return TRUE;
}
#if GFX_USE_GEVENT
GSourceHandle gaudinGetSource(void) {
if (!gtimerIsActive(&AudGTimer))
gtimerStart(&AudGTimer, AudGTimerCallback, NULL, TRUE, TIME_INFINITE);
audFlags |= AUDFLG_USE_EVENTS;
return (GSourceHandle)&aud;
}
#endif
void gaudinSetBSem(BinarySemaphore *pbsem, GEventAudioIn *pEvent) {
chSysLock();
paudSem = pbsem;
paudEvent = pEvent;
chSysUnlock();
}
void gaudinStart(void) {
if (!(audFlags & AUDFLG_RUNNING)) {
audFlags |= AUDFLG_RUNNING;
gadc_lld_start();
}
}
void gaudinStop(void) {
if ((audFlags & AUDFLG_RUNNING)) {
gadc_lld_stop();
audFlags &= ~AUDFLG_RUNNING;
}
}
#endif /* GFX_USE_GAUDIN */
/** @} */