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

Merge pull request #33 from inmarket/master

Browse source 
GADC implementation, TDISP fix and GDISP fixes
This commit is contained in:
Tectu 2013-02-17 23:52:34 -08:00
commit 778cfcd928
36 changed files with 10566 additions and 9140 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

105
demos/modules/gadc/gfxconf.h Normal file
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 FALSE
#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 TRUE
#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 TRUE
#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 TRUE
#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 TRUE
#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 */

183
demos/modules/gadc/gwinosc.c Normal file
View file

@ -0,0 +1,183 @@
/*
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 GADC high speed device.
*/
#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, uint32_t physdev, 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 */
gadcHighSpeedInit(physdev, frequency, gs->audiobuf, AUDIOBUFSZ, AUDIOBUFSZ/2);
gadcHighSpeedSetBSem(&gs->bsem, &gs->myEvent);
gadcHighSpeedStart();
return (GHandle)gs;
}
void gwinWaitForScopeTrace(GHandle gh) {
#define gs ((GScopeObject *)(gh))
int i;
coord_t x, y;
coord_t yoffset;
adcsample_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 GADC_BITS_PER_SAMPLE > SCOPE_Y_BITS
y = yoffset - (*pa++ >> (GADC_BITS_PER_SAMPLE - SCOPE_Y_BITS));
#else
y = yoffset - (*pa++ << (SCOPE_Y_BITS - GADC_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
}

89
demos/modules/gadc/gwinosc.h Normal file
View file

@ -0,0 +1,89 @@
/*
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.
*/
/* The extent of scaling for our audio data - fixed scale at the moment */
#ifndef SCOPE_Y_BITS
#define SCOPE_Y_BITS 7 // 7 bits = 0..128
#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
adcsample_t *audiobuf; // To store audio samples
GEventADC 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, uint32_t physdev, 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 */

176
demos/modules/gadc/main.c Normal file
View file

@ -0,0 +1,176 @@
/*
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 GADC module using it read both a microphone,
* an analogue dial wheel and a temperature sensor.
* The microphone gets read at high frequency to display a very simple oscilloscope.
* The dial and temperature gets read at a low frequency to just print when
* it changes value.
*
* It also demonstrates how to write your own custom GWIN window type.
*/
#include "ch.h"
#include "hal.h"
#include "chprintf.h"
#include "gfx.h"
/* Include our custom gwin oscilloscope */
#include "gwinosc.h"
/*
* Match these to your hardware
* If you don't have a DIAL device or a TEMP device - just don't define it.
*/
#define MY_MIC_DEVICE GADC_PHYSDEV_MICROPHONE
#define MY_DIAL_DEVICE GADC_PHYSDEV_DIAL
#define MY_TEMP_DEVICE GADC_PHYSDEV_TEMPERATURE
#define MY_DIAL_JITTER 1
#define MY_TEMP_JITTER 3
/* Specify our timing parameters */
#define MY_MIC_FREQUENCY 4000 /* 4khz */
#define MY_LS_DELAY 200 /* 200ms (5 times per second) for the dial and temperature */
/* The desired size for our scope window */
#define SCOPE_CX 64
#define SCOPE_CY 64
/* Data */
static GScopeObject gScopeWindow;
static GConsoleObject gTextWindow;
static GTimer lsTimer;
#ifdef MY_DIAL_DEVICE
static adcsample_t dialvalue;
static adcsample_t lastdial = -(MY_DIAL_JITTER+1);
/**
* We have got a dial reading - handle it
*/
static void GotDialReading(adcsample_t *buffer, void *param) {
(void) buffer;
/* Buffer should always point to "dialvalue" anyway */
/* Remove jitter from the value */
if ((dialvalue > lastdial && dialvalue - lastdial > MY_DIAL_JITTER)
|| (lastdial > dialvalue && lastdial - dialvalue > MY_DIAL_JITTER)) {
/* Write the value */
chprintf((BaseSequentialStream *)param, "DIAL: %u\n", dialvalue);
/* Save for next time */
lastdial = dialvalue;
}
}
#endif
#ifdef MY_TEMP_DEVICE
static adcsample_t tempvalue;
static adcsample_t lasttemp = -(MY_TEMP_JITTER+1);
/**
* We have got a temperature reading - handle it
*/
static void GotTempReading(adcsample_t *buffer, void *param) {
(void) buffer;
/* Buffer should always point to "tempvalue" anyway */
/* Remove jitter from the value */
if ((tempvalue > lasttemp && tempvalue - lasttemp > MY_TEMP_JITTER)
|| (lasttemp > tempvalue && lasttemp - tempvalue > MY_TEMP_JITTER)) {
/* Write the value */
chprintf((BaseSequentialStream *)param, "TEMP: %u\n", tempvalue);
/* Save for next time */
lasttemp = tempvalue;
}
}
#endif
#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
/**
* Start a read of the dial and temperature
*/
static void LowSpeedTimer(void *param) {
/* We are not checking for an error here - but who cares, this is just a demo */
#ifdef MY_DIAL_DEVICE
gadcLowSpeedStart(MY_DIAL_DEVICE, &dialvalue, GotDialReading, param);
#endif
#ifdef MY_TEMP_DEVICE
gadcLowSpeedStart(MY_TEMP_DEVICE, &tempvalue, GotTempReading, param);
#endif
}
#endif
/*
* Application entry point.
*/
int main(void) {
GHandle ghScope;
coord_t swidth, sheight;
#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
GHandle ghText;
BaseSequentialStream *gsText;
font_t font;
#endif
halInit();
chSysInit();
gdispInit();
gdispClear(Black);
/* Get the screen dimensions */
swidth = gdispGetWidth();
sheight = gdispGetHeight();
#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
/* Set up the console window we use for dial readings */
font = gdispOpenFont("UI2");
ghText = gwinCreateConsole(&gTextWindow, 0, 0, swidth-SCOPE_CX, sheight, font);
gwinSetBgColor(ghText, Black);
gwinSetColor(ghText, Yellow);
gwinClear(ghText);
gsText = gwinGetConsoleStream(ghText);
/* Start our timer for reading the dial */
gtimerInit(&lsTimer);
gtimerStart(&lsTimer, LowSpeedTimer, gsText, TRUE, MY_LS_DELAY);
#endif
/* Set up the scope window in the top right on the screen */
ghScope = gwinCreateScope(&gScopeWindow, swidth-SCOPE_CX, 0, SCOPE_CX, SCOPE_CY, MY_MIC_DEVICE, MY_MIC_FREQUENCY);
gwinSetBgColor(ghScope, White);
gwinSetColor(ghScope, Red);
gwinClear(ghScope);
/* Just keep displaying the scope traces */
while (TRUE) {
/**
* The function below internally performs a wait thus giving the timer thread a
* chance to run.
*/
gwinWaitForScopeTrace(ghScope);
}
}

BIN
demos/modules/gadc/results_264x264.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 21 KiB

102
drivers/gadc/AT91SAM7/gadc_lld.c Normal file
View file

@ -0,0 +1,102 @@
/*
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/gadc/lld/gadc_lld.c
* @brief GADC - Periodic ADC driver source file for the AT91SAM7 cpu.
*
* @defgroup Driver Driver
* @ingroup GADC
* @{
*/
#include "ch.h"
#include "hal.h"
#include "gfx.h"
#if GFX_USE_GADC
#include "gadc/lld/gadc_lld.h"
static ADCConversionGroup acg = {
FALSE, // circular
1, // num_channels
GADC_ISR_CompleteI, // end_cb
GADC_ISR_ErrorI, // error_cb
0, // channelselects
0, // trigger
0, // frequency
};
void gadc_lld_init(void) {
adcStart(&ADCD1, NULL);
}
size_t gadc_lld_samples_per_conversion(uint32_t physdev) {
size_t cnt;
int i;
/* The AT91SAM7 has AD0..7 - physdev is a bitmap of those channels */
for(cnt = 0, i = 0; i < 8; i++, physdev >>= 1)
if (physdev & 0x01)
cnt++;
return cnt;
}
void gadc_lld_start_timer(uint32_t physdev, uint32_t frequency) {
(void) physdev;
/**
* The AT91SAM7 ADC driver supports triggering the ADC using a timer without having to implement
* an interrupt handler for the timer. The driver also initialises the timer correctly for us.
* Because we aren't trapping the interrupt ourselves we can't increment GADC_Timer_Missed if an
* interrupt is missed.
*/
acg.frequency = frequency;
}
void gadc_lld_stop_timer(uint32_t physdev) {
(void) physdev;
if ((acg.trigger & ~ADC_TRIGGER_SOFTWARE) == ADC_TRIGGER_TIMER)
adcStop(&ADCD1);
}
void gadc_lld_adc_timerI(GadcLldTimerData *pgtd) {
/**
* We don't need to calculate num_channels because the AT91SAM7 ADC does this for us.
*/
acg.channelselects = pgtd->physdev;
acg.trigger = pgtd->now ? (ADC_TRIGGER_TIMER|ADC_TRIGGER_SOFTWARE) : ADC_TRIGGER_TIMER;
adcStartConversionI(&ADCD1, &acg, pgtd->buffer, pgtd->count);
/* Next time assume the same (still running) timer */
acg.frequency = 0;
}
void gadc_lld_adc_nontimerI(GadcLldNonTimerData *pgntd) {
/**
* We don't need to calculate num_channels because the AT91SAM7 ADC does this for us.
*/
acg.channelselects = pgntd->physdev;
acg.trigger = ADC_TRIGGER_SOFTWARE;
adcStartConversionI(&ADCD1, &acg, pgntd->buffer, 1);
}
#endif /* GFX_USE_GADC */
/** @} */

5
drivers/gadc/AT91SAM7/gadc_lld.mk Normal file
View file

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

46
drivers/gadc/AT91SAM7/gadc_lld_board_olimexsam7ex256.h Normal file
View file

@ -0,0 +1,46 @@
/*
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/gadc/AT91SAM7/gadc_lld_board_olimexsam7ex256.h
* @brief GADC Driver config file.
*
* @addtogroup GADC
* @{
*/
#ifndef _GADC_LLD_BOARD_OLIMEXSAM7EX256_H
#define _GADC_LLD_BOARD_OLIMEXSAM7EX256_H
#if GFX_USE_GADC
/*===========================================================================*/
/* Analogue devices on this board */
/*===========================================================================*/
#define GADC_PHYSDEV_MICROPHONE 0x00000080
#define GADC_PHYSDEV_DIAL 0x00000040
#define GADC_PHYSDEV_TEMPERATURE 0x00000020
#endif /* GFX_USE_GADC */
#endif /* _GADC_LLD_BOARD_OLIMEXSAM7EX256_H */
/** @} */

78
drivers/gadc/AT91SAM7/gadc_lld_config.h Normal file
View file

@ -0,0 +1,78 @@
/*
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/gadc/AT91SAM7/gadc_lld_config.h
* @brief GADC Driver config file.
*
* @addtogroup GADC
* @{
*/
#ifndef GADC_LLD_CONFIG_H
#define GADC_LLD_CONFIG_H
#if GFX_USE_GADC
/*===========================================================================*/
/* Driver hardware support. */
/*===========================================================================*/
/**
* @brief ChibiOS has a nasty bug in its _adc_isr_full_code() routine (defined in adc.h as a macro).
* Do we have the version of ChibiOS with this bug.
* @detail Set to TRUE if ChibiOS has this bug.
* @note Fixed in ChibiOS 2.4.4stable and 2.5.2unstable (and the repository from 18th Feb 2013)
* @note This bug prevents us re-calling adcStartConversionI() from with the ISR even though
* it is clearly designed to handle it. For some reason (on this micro) the high speed timer
* is not affected only the single sample low speed timer. In that situation we wait until
* we get back to thread land. This is terrible for the accuracy of the high speed timer
* but what can we do (other than fix the bug).
* @note For the AT91SAM7 ADC driver, it post-dates the finding of the bug so we safely
* say that the bug doesn't exist for this driver.
*/
#define ADC_ISR_FULL_CODE_BUG FALSE
/**
* @brief The maximum sample frequency supported by this CPU
*/
#define GADC_MAX_SAMPLE_FREQUENCY 132000
/**
* @brief The number of bits in a sample
*/
#define GADC_BITS_PER_SAMPLE AT91_ADC1_RESOLUTION
/* Pull in board specific defines */
#if defined(GADC_USE_CUSTOM_BOARD) && GADC_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */
#include "gadc_lld_board.h"
#elif defined(BOARD_OLIMEX_SAM7_EX256)
#include "gadc_lld_board_olimexsam7ex256.h"
#else
/* Include the user supplied board definitions */
#include "gadc_lld_board.h"
#endif
#endif /* GFX_USE_GADC */
#endif /* _GDISP_LLD_CONFIG_H */
/** @} */

1140
drivers/gdisp/ILI9320/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

118
drivers/gdisp/ILI9320/gdisp_lld_board_example.h
View file

@ -1,59 +1,59 @@
/* /*
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 drivers/gdisp/ILI9320/gdisp_lld_board_example.h * @file drivers/gdisp/ILI9320/gdisp_lld_board_example.h
* @brief GDISP Graphic Driver subsystem board interface for the ILI9320 display. * @brief GDISP Graphic Driver subsystem board interface for the ILI9320 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef GDISP_LLD_BOARD_H #ifndef GDISP_LLD_BOARD_H
#define GDISP_LLD_BOARD_H #define GDISP_LLD_BOARD_H
static __inline void lld_gdisp_init_board(void) { static __inline void gdisp_lld_init_board(void) {
#error "ILI9320: You must implement the init_board routine for your board" #error "ILI9320: You must implement the init_board routine for your board"
} }
static __inline void lld_gdisp_reset_pin(bool_t state) { static __inline void gdisp_lld_reset_pin(bool_t state) {
#error "ILI9320: You must implement setpin_reset routine for your board" #error "ILI9320: You must implement setpin_reset routine for your board"
} }
static __inline void lld_gdisp_write_index(uint16_t data) { static __inline void gdisp_lld_write_index(uint16_t data) {
#error "ILI9320: You must implement write_index routine for your board" #error "ILI9320: You must implement write_index routine for your board"
} }
static __inline void lld_gdisp_write_data(uint16_t data) { static __inline void gdisp_lld_write_data(uint16_t data) {
#error "ILI9320: You must implement write_data routine for your board" #error "ILI9320: You must implement write_data routine for your board"
} }
static __inline uint16_t lld_gdisp_read_data(void) { static __inline uint16_t gdisp_lld_read_data(void) {
#error "ILI9320: You must implement read_data routine for your board" #error "ILI9320: You must implement read_data routine for your board"
} }
/* if not available, just ignore the argument and return */ /* if not available, just ignore the argument and return */
static __inline uint16_t lld_gdisp_backlight(uint8_t percentage) { static __inline uint16_t gdisp_lld_backlight(uint8_t percentage) {
#error "ILI9320: You must implement set_backlight routine for your board" #error "ILI9320: You must implement set_backlight routine for your board"
} }
#endif /* GDISP_LLD_BOARD_H */ #endif /* GDISP_LLD_BOARD_H */
/** @} */ /** @} */

170
drivers/gdisp/ILI9320/gdisp_lld_board_olimex_stm32_lcd.h
View file

@ -1,85 +1,85 @@
/* /*
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 drivers/gdisp/ILI9320/gdisp_lld_board_olimex_stm32_lcd.h * @file drivers/gdisp/ILI9320/gdisp_lld_board_olimex_stm32_lcd.h
* @brief GDISP Graphic Driver subsystem board interface for the ILI9320 display. * @brief GDISP Graphic Driver subsystem board interface for the ILI9320 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef GDISP_LLD_BOARD_H #ifndef GDISP_LLD_BOARD_H
#define GDISP_LLD_BOARD_H #define GDISP_LLD_BOARD_H
#define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */ #define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#define GDISP_RAM (*((volatile uint16_t *) 0x60100000)) /* RS = 1 */ #define GDISP_RAM (*((volatile uint16_t *) 0x60100000)) /* RS = 1 */
static __inline void lld_gdisp_init_board(void) { static __inline void gdisp_lld_init_board(void) {
/* FSMC setup for F1 */ /* FSMC setup for F1 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0); rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
/* set pin modes */ /* set pin modes */
IOBus busD = {GPIOD, PAL_WHOLE_PORT, 0}; IOBus busD = {GPIOD, PAL_WHOLE_PORT, 0};
IOBus busE = {GPIOE, PAL_WHOLE_PORT, 0}; IOBus busE = {GPIOE, PAL_WHOLE_PORT, 0};
palSetBusMode(&busD, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetBusMode(&busD, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetBusMode(&busE, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetBusMode(&busE, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOE, GPIOE_TFT_RST, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOE, GPIOE_TFT_RST, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOD, GPIOD_TFT_LIGHT, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOD, GPIOD_TFT_LIGHT, PAL_MODE_OUTPUT_PUSHPULL);
const unsigned char FSMC_Bank = 0; const unsigned char FSMC_Bank = 0;
/* FSMC timing */ /* FSMC timing */
FSMC_Bank1->BTCR[FSMC_Bank+1] = (6) | (10 << 8) | (10 << 16); FSMC_Bank1->BTCR[FSMC_Bank+1] = (6) | (10 << 8) | (10 << 16);
/* Bank1 NOR/SRAM control register configuration /* Bank1 NOR/SRAM control register configuration
* This is actually not needed as already set by default after reset */ * This is actually not needed as already set by default after reset */
FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN; FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;
} }
static __inline void lld_gdisp_reset_pin(bool_t state) { static __inline void gdisp_lld_reset_pin(bool_t state) {
if(state) if(state)
palClearPad(GPIOE, GPIOE_TFT_RST); palClearPad(GPIOE, GPIOE_TFT_RST);
else else
palSetPad(GPIOE, GPIOE_TFT_RST); palSetPad(GPIOE, GPIOE_TFT_RST);
} }
static __inline void lld_gdisp_write_index(uint16_t reg) { static __inline void gdisp_lld_write_index(uint16_t reg) {
GDISP_REG = reg; GDISP_REG = reg;
} }
static __inline void lld_gdisp_write_data(uint16_t data) { static __inline void gdisp_lld_write_data(uint16_t data) {
GDISP_RAM = data; GDISP_RAM = data;
} }
static __inline uint16_t lld_gdisp_read_data(void) { static __inline uint16_t gdisp_lld_read_data(void) {
return GDISP_RAM; return GDISP_RAM;
} }
static __inline void lld_gdisp_backlight(uint8_t percent) { static __inline void gdisp_lld_backlight(uint8_t percent) {
if(percent == 100) if(percent == 100)
palClearPad(GPIOD, GPIOD_TFT_LIGHT); palClearPad(GPIOD, GPIOD_TFT_LIGHT);
else else
palSetPad(GPIOD, GPIOD_TFT_LIGHT); palSetPad(GPIOD, GPIOD_TFT_LIGHT);
} }
#endif /* GDISP_LLD_BOARD_H */ #endif /* GDISP_LLD_BOARD_H */
/** @} */ /** @} */

1160
drivers/gdisp/ILI9325/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

118
drivers/gdisp/ILI9325/gdisp_lld_board_example.h
View file

@ -1,59 +1,59 @@
/* /*
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 drivers/gdisp/ILI9325/gdisp_lld_board_example.h * @file drivers/gdisp/ILI9325/gdisp_lld_board_example.h
* @brief GDISP Graphic Driver subsystem board interface for the ILI9325 display. * @brief GDISP Graphic Driver subsystem board interface for the ILI9325 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef GDISP_LLD_BOARD_H #ifndef GDISP_LLD_BOARD_H
#define GDISP_LLD_BOARD_H #define GDISP_LLD_BOARD_H
static __inline void lld_gdisp_init_board(void) { static __inline void gdisp_lld_init_board(void) {
#error "ILI9325: You must implement the init_board routine for your board" #error "ILI9325: You must implement the init_board routine for your board"
} }
static __inline void lld_gdisp_reset_pin(bool_t state) { static __inline void gdisp_lld_reset_pin(bool_t state) {
#error "ILI9325: You must implement setpin_reset routine for your board" #error "ILI9325: You must implement setpin_reset routine for your board"
} }
static __inline void lld_gdisp_write_index(uint16_t data) { static __inline void gdisp_lld_write_index(uint16_t data) {
#error "ILI9325: You must implement write_index routine for your board" #error "ILI9325: You must implement write_index routine for your board"
} }
static __inline void lld_gdisp_write_data(uint16_t data) { static __inline void gdisp_lld_write_data(uint16_t data) {
#error "ILI9325: You must implement write_data routine for your board" #error "ILI9325: You must implement write_data routine for your board"
} }
static __inline uint16_t lld_gdisp_read_data(void) { static __inline uint16_t gdisp_lld_read_data(void) {
#error "ILI9325: You must implement read_data routine for your board" #error "ILI9325: You must implement read_data routine for your board"
} }
/* if not available, just ignore the argument and return */ /* if not available, just ignore the argument and return */
static __inline uint16_t lld_gdisp_backlight(uint8_t percentage) { static __inline uint16_t gdisp_lld_backlight(uint8_t percentage) {
#error "ILI9325: You must implement set_backlight routine for your board" #error "ILI9325: You must implement set_backlight routine for your board"
} }
#endif /* GDISP_LLD_BOARD_H */ #endif /* GDISP_LLD_BOARD_H */
/** @} */ /** @} */

192
drivers/gdisp/ILI9325/gdisp_lld_board_hy_stm32_100p.h
View file

@ -1,96 +1,96 @@
/* /*
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/>.
*/ */
/* /*
driver quickly hacked together from a chinese sourcecode that came driver quickly hacked together from a chinese sourcecode that came
with the board and existing ili9320 code by Chris van Dongen (sjaak) with the board and existing ili9320 code by Chris van Dongen (sjaak)
(sjaak2002 at msn.com) (sjaak2002 at msn.com)
Also added rotation for 180 and 270 degrees and minor tweaks to Also added rotation for 180 and 270 degrees and minor tweaks to
setcursor setcursor
Added code comes without warranty and free bugs. Feel free to use Added code comes without warranty and free bugs. Feel free to use
or misuse the added code :D or misuse the added code :D
*/ */
/** /**
* @file drivers/gdisp/ILI9325/gdisp_lld_board_hy_stm32_100p.h * @file drivers/gdisp/ILI9325/gdisp_lld_board_hy_stm32_100p.h
* @brief GDISP Graphic Driver subsystem board interface for the ILI9325 display. * @brief GDISP Graphic Driver subsystem board interface for the ILI9325 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef GDISP_LLD_BOARD_H #ifndef GDISP_LLD_BOARD_H
#define GDISP_LLD_BOARD_H #define GDISP_LLD_BOARD_H
#define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */ #define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#define GDISP_RAM (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */ #define GDISP_RAM (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */
static __inline void lld_gdisp_init_board(void) { static __inline void gdisp_lld_init_board(void) {
/* FSMC setup for F1 */ /* FSMC setup for F1 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0); rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
/* set pin modes */ /* set pin modes */
/* IOBus busD = {GPIOD, PAL_WHOLE_PORT, 0}; /* IOBus busD = {GPIOD, PAL_WHOLE_PORT, 0};
IOBus busE = {GPIOE, PAL_WHOLE_PORT, 0}; IOBus busE = {GPIOE, PAL_WHOLE_PORT, 0};
palSetBusMode(&busD, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetBusMode(&busD, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetBusMode(&busE, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetBusMode(&busE, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOE, GPIOE_TFT_RST, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOE, GPIOE_TFT_RST, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOD, GPIOD_TFT_LIGHT, PAL_MODE_OUTPUT_PUSHPULL); */ palSetPadMode(GPIOD, GPIOD_TFT_LIGHT, PAL_MODE_OUTPUT_PUSHPULL); */
const unsigned char FSMC_Bank = 0; const unsigned char FSMC_Bank = 0;
/* FSMC timing */ /* FSMC timing */
FSMC_Bank1->BTCR[FSMC_Bank+1] = (6) | (10 << 8) | (10 << 16); FSMC_Bank1->BTCR[FSMC_Bank+1] = (6) | (10 << 8) | (10 << 16);
/* Bank1 NOR/SRAM control register configuration /* Bank1 NOR/SRAM control register configuration
* This is actually not needed as already set by default after reset */ * This is actually not needed as already set by default after reset */
FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN; FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;
} }
static __inline void lld_gdisp_reset_pin(bool_t state) { static __inline void gdisp_lld_reset_pin(bool_t state) {
if(state) if(state)
palClearPad(GPIOE, GPIOE_TFT_RST); palClearPad(GPIOE, GPIOE_TFT_RST);
else else
palSetPad(GPIOE, GPIOE_TFT_RST); palSetPad(GPIOE, GPIOE_TFT_RST);
} }
static __inline void lld_gdisp_write_index(uint16_t reg) { static __inline void gdisp_lld_write_index(uint16_t reg) {
GDISP_REG = reg; GDISP_REG = reg;
} }
static __inline void lld_gdisp_write_data(uint16_t data) { static __inline void gdisp_lld_write_data(uint16_t data) {
GDISP_RAM = data; GDISP_RAM = data;
} }
static __inline uint16_t lld_gdisp_read_data(void) { static __inline uint16_t gdisp_lld_read_data(void) {
return GDISP_RAM; return GDISP_RAM;
} }
static __inline void lld_gdisp_backlight(uint8_t percent) { static __inline void gdisp_lld_backlight(uint8_t percent) {
percent=percent; // avoid a warning percent=percent; // avoid a warning
} }
#endif /* GDISP_LLD_BOARD_H */ #endif /* GDISP_LLD_BOARD_H */
/** @} */ /** @} */

1056
drivers/gdisp/Nokia6610GE12/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

966
drivers/gdisp/Nokia6610GE8/gdisp_lld.c
View file

@ -1,483 +1,483 @@
/* /*
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 drivers/gdisp/Nokia6610GE8/gdisp_lld.c * @file drivers/gdisp/Nokia6610GE8/gdisp_lld.c
* @brief GDISP Graphics Driver subsystem low level driver source for the Nokia6610 GE8 display. * @brief GDISP Graphics Driver subsystem low level driver source for the Nokia6610 GE8 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/ #if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/
/* Include the emulation code for things we don't support */ /* Include the emulation code for things we don't support */
#include "gdisp/lld/emulation.c" #include "gdisp/lld/emulation.c"
/*===========================================================================*/ /*===========================================================================*/
/* Driver local definitions. */ /* Driver local definitions. */
/*===========================================================================*/ /*===========================================================================*/
#include "GE8.h" #include "GE8.h"
/* This controller is only ever used with a 132 x 132 display */ /* This controller is only ever used with a 132 x 132 display */
#if defined(GDISP_SCREEN_HEIGHT) #if defined(GDISP_SCREEN_HEIGHT)
#warning "GDISP: This low level driver does not support setting a screen size. It is being ignored." #warning "GDISP: This low level driver does not support setting a screen size. It is being ignored."
#undef GDISP_SCREEN_HEIGHT #undef GDISP_SCREEN_HEIGHT
#endif #endif
#if defined(GDISP_SCREEN_WIDTH) #if defined(GDISP_SCREEN_WIDTH)
#warning "GDISP: This low level driver does not support setting a screen size. It is being ignored." #warning "GDISP: This low level driver does not support setting a screen size. It is being ignored."
#undef GDISP_SCREEN_WIDTH #undef GDISP_SCREEN_WIDTH
#endif #endif
#define GDISP_SCREEN_HEIGHT 132 #define GDISP_SCREEN_HEIGHT 132
#define GDISP_SCREEN_WIDTH 132 #define GDISP_SCREEN_WIDTH 132
#define GDISP_INITIAL_CONTRAST 38 #define GDISP_INITIAL_CONTRAST 38
#define GDISP_INITIAL_BACKLIGHT 100 #define GDISP_INITIAL_BACKLIGHT 100
/*===========================================================================*/ /*===========================================================================*/
/* Driver exported variables. */ /* Driver exported variables. */
/*===========================================================================*/ /*===========================================================================*/
/*===========================================================================*/ /*===========================================================================*/
/* Driver local variables. */ /* Driver local variables. */
/*===========================================================================*/ /*===========================================================================*/
/*===========================================================================*/ /*===========================================================================*/
/* Driver local functions. */ /* Driver local functions. */
/*===========================================================================*/ /*===========================================================================*/
#if defined(GDISP_USE_CUSTOM_BOARD) && GDISP_USE_CUSTOM_BOARD #if defined(GDISP_USE_CUSTOM_BOARD) && GDISP_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */ /* Include the user supplied board definitions */
#include "gdisp_lld_board.h" #include "gdisp_lld_board.h"
#elif defined(BOARD_OLIMEX_SAM7_EX256) #elif defined(BOARD_OLIMEX_SAM7_EX256)
#include "gdisp_lld_board_olimexsam7ex256.h" #include "gdisp_lld_board_olimexsam7ex256.h"
#else #else
/* Include the user supplied board definitions */ /* Include the user supplied board definitions */
#include "gdisp_lld_board.h" #include "gdisp_lld_board.h"
#endif #endif
// Some macros just to make reading the code easier // Some macros just to make reading the code easier
#define delayms(ms) chThdSleepMilliseconds(ms) #define delayms(ms) chThdSleepMilliseconds(ms)
#define write_data2(d1, d2) { write_data(d1); write_data(d2); } #define write_data2(d1, d2) { write_data(d1); write_data(d2); }
#define write_data3(d1, d2, d3) { write_data(d1); write_data(d2); write_data(d3); } #define write_data3(d1, d2, d3) { write_data(d1); write_data(d2); write_data(d3); }
#define write_cmd1(cmd, d1) { write_cmd(cmd); write_data(d1); } #define write_cmd1(cmd, d1) { write_cmd(cmd); write_data(d1); }
#define write_cmd2(cmd, d1, d2) { write_cmd(cmd); write_data2(d1, d2); } #define write_cmd2(cmd, d1, d2) { write_cmd(cmd); write_data2(d1, d2); }
#define write_cmd3(cmd, d1, d2, d3) { write_cmd(cmd); write_data3(d1, d2, d3); } #define write_cmd3(cmd, d1, d2, d3) { write_cmd(cmd); write_data3(d1, d2, d3); }
// A very common thing to do. // A very common thing to do.
// An inline function has been used here incase the parameters have side effects with the internal calculations. // An inline function has been used here incase the parameters have side effects with the internal calculations.
static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) { static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
write_cmd2(CASET, x, x+cx-1); // Column address set write_cmd2(CASET, x, x+cx-1); // Column address set
write_cmd2(PASET, y, y+cy-1); // Page address set write_cmd2(PASET, y, y+cy-1); // Page address set
} }
/*===========================================================================*/ /*===========================================================================*/
/* Driver interrupt handlers. */ /* Driver interrupt handlers. */
/*===========================================================================*/ /*===========================================================================*/
/*===========================================================================*/ /*===========================================================================*/
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.
All other routines are optional. All other routines are optional.
*/ */
/** /**
* @brief Low level GDISP driver initialization. * @brief Low level GDISP driver initialization.
* *
* @notapi * @notapi
*/ */
bool_t lld_gdisp_init(void) { bool_t gdisp_lld_init(void) {
/* Initialise your display */ /* Initialise your display */
init_board(); init_board();
// Hardware reset // Hardware reset
setpin_reset(TRUE); setpin_reset(TRUE);
delayms(20); delayms(20);
setpin_reset(FALSE); setpin_reset(FALSE);
delayms(20); delayms(20);
// Get the bus for the following initialisation commands // Get the bus for the following initialisation commands
acquire_bus(); acquire_bus();
write_cmd3(DISCTL, 0x00, 0x20, 0x00); // Display control write_cmd3(DISCTL, 0x00, 0x20, 0x00); // Display control
// P1: 0x00 = 2 divisions, switching period=8 (default) // P1: 0x00 = 2 divisions, switching period=8 (default)
// P2: 0x20 = nlines/4 - 1 = 132/4 - 1 = 32) // P2: 0x20 = nlines/4 - 1 = 132/4 - 1 = 32)
// P3: 0x00 = no inversely highlighted lines // P3: 0x00 = no inversely highlighted lines
write_cmd1(COMSCN, 0x01); // COM scan P1: 0x01 = Scan 1->80, 160<-81 write_cmd1(COMSCN, 0x01); // COM scan P1: 0x01 = Scan 1->80, 160<-81
write_cmd(OSCON); // Internal oscilator ON write_cmd(OSCON); // Internal oscilator ON
write_cmd(SLPOUT); // Sleep out write_cmd(SLPOUT); // Sleep out
write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON
write_cmd3(DATCTL, 0x48, 0x00, 0x02); // Data control write_cmd3(DATCTL, 0x48, 0x00, 0x02); // Data control
// P1: 0x01 = page address inverted, column address normal, address scan in column direction // P1: 0x01 = page address inverted, column address normal, address scan in column direction
// P2: 0x00 = RGB sequence (default value) // P2: 0x00 = RGB sequence (default value)
// P3: 0x02 = Grayscale -> 16 (selects 12-bit color, type A) // P3: 0x02 = Grayscale -> 16 (selects 12-bit color, type A)
write_cmd2(VOLCTR, GDISP_INITIAL_CONTRAST, 0x03); // Voltage control (contrast setting) write_cmd2(VOLCTR, GDISP_INITIAL_CONTRAST, 0x03); // Voltage control (contrast setting)
// P1 = Contrast // P1 = Contrast
// P2 = 3 resistance ratio (only value that works) // P2 = 3 resistance ratio (only value that works)
delayms(100); // allow power supply to stabilize delayms(100); // allow power supply to stabilize
write_cmd(DISON); // Turn on the display write_cmd(DISON); // Turn on the display
// Release the bus // Release the bus
release_bus(); release_bus();
/* Turn on the back-light */ /* Turn on the back-light */
set_backlight(GDISP_INITIAL_BACKLIGHT); set_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure to match */ /* Initialise the GDISP structure to match */
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT; GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Orientation = GDISP_ROTATE_0; GDISP.Orientation = GDISP_ROTATE_0;
GDISP.Powermode = powerOn; GDISP.Powermode = powerOn;
GDISP.Backlight = GDISP_INITIAL_BACKLIGHT; GDISP.Backlight = GDISP_INITIAL_BACKLIGHT;
GDISP.Contrast = GDISP_INITIAL_CONTRAST; GDISP.Contrast = GDISP_INITIAL_CONTRAST;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
GDISP.clipx0 = 0; GDISP.clipx0 = 0;
GDISP.clipy0 = 0; GDISP.clipy0 = 0;
GDISP.clipx1 = GDISP.Width; GDISP.clipx1 = GDISP.Width;
GDISP.clipy1 = GDISP.Height; GDISP.clipy1 = GDISP.Height;
#endif #endif
return TRUE; return TRUE;
} }
/** /**
* @brief Draws a pixel on the display. * @brief Draws a pixel on the display.
* *
* @param[in] x X location of the pixel * @param[in] x X location of the pixel
* @param[in] y Y location of the pixel * @param[in] y Y location of the pixel
* @param[in] color The color of the pixel * @param[in] color The color of the pixel
* *
* @notapi * @notapi
*/ */
void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) { void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return; if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif #endif
acquire_bus(); acquire_bus();
setviewport(x, y, 1, 1); setviewport(x, y, 1, 1);
write_cmd3(RAMWR, 0, (color>>8) & 0x0F, color & 0xFF); write_cmd3(RAMWR, 0, (color>>8) & 0x0F, color & 0xFF);
release_bus(); release_bus();
} }
/* ---- Optional Routines ---- */ /* ---- Optional Routines ---- */
#if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__) #if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
/** /**
* @brief Fill an area with a color. * @brief Fill an area with a color.
* *
* @param[in] x, y The start filled area * @param[in] x, y The start filled area
* @param[in] cx, cy The width and height to be filled * @param[in] cx, cy The width and height to be filled
* @param[in] color The color of the fill * @param[in] color The color of the fill
* *
* @notapi * @notapi
*/ */
void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) { void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
unsigned i, tuples; unsigned i, tuples;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; } if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; } if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
if (cx <= 0 || cy <= 0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return; if (cx <= 0 || cy <= 0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
if (x+cx > GDISP.clipx1) cx = GDISP.clipx1 - x; if (x+cx > GDISP.clipx1) cx = GDISP.clipx1 - x;
if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y; if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y;
#endif #endif
tuples = (cx*cy+1)/2; // With an odd sized area we over-print by one pixel. tuples = (cx*cy+1)/2; // With an odd sized area we over-print by one pixel.
// This extra pixel is ignored by the controller. // This extra pixel is ignored by the controller.
acquire_bus(); acquire_bus();
setviewport(x, y, cx, cy); setviewport(x, y, cx, cy);
write_cmd(RAMWR); write_cmd(RAMWR);
for(i=0; i < tuples; i++) for(i=0; i < tuples; i++)
write_data3(((color >> 4) & 0xFF), (((color << 4) & 0xF0)|((color >> 8) & 0x0F)), (color & 0xFF)); write_data3(((color >> 4) & 0xFF), (((color << 4) & 0xF0)|((color >> 8) & 0x0F)), (color & 0xFF));
release_bus(); release_bus();
} }
#endif #endif
#if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__) #if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
/** /**
* @brief Fill an area with a bitmap. * @brief Fill an area with a bitmap.
* *
* @param[in] x, y The start filled area * @param[in] x, y The start filled area
* @param[in] cx, cy The width and height to be filled * @param[in] cx, cy The width and height to be filled
* @param[in] srcx, srcy The bitmap position to start the fill from * @param[in] srcx, srcy The bitmap position to start the fill from
* @param[in] srccx The width of a line in the bitmap. * @param[in] srccx The width of a line in the bitmap.
* @param[in] buffer The pixels to use to fill the area. * @param[in] buffer The pixels to use to fill the area.
* *
* @notapi * @notapi
*/ */
void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) { void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
coord_t endx, endy, lg; coord_t endx, endy, lg;
color_t c1, c2; color_t c1, c2;
#if GDISP_PACKED_PIXELS #if GDISP_PACKED_PIXELS
coord_t pos; coord_t pos;
const uint8_t *p; const uint8_t *p;
#endif #endif
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; srcx += GDISP.clipx0 - x; x = GDISP.clipx0; } if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; srcx += GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; srcy += GDISP.clipy0 - y; y = GDISP.clipy0; } if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; srcy += GDISP.clipy0 - y; y = GDISP.clipy0; }
if (srcx+cx > srccx) cx = srccx - srcx; if (srcx+cx > srccx) cx = srccx - srcx;
if (cx <= 0 || cy <= 0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return; if (cx <= 0 || cy <= 0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
if (x+cx > GDISP.clipx1) cx = GDISP.clipx1 - x; if (x+cx > GDISP.clipx1) cx = GDISP.clipx1 - x;
if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y; if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y;
#endif #endif
/* What are our end points */ /* What are our end points */
endx = srcx + cx; endx = srcx + cx;
endy = y + cy; endy = y + cy;
acquire_bus(); acquire_bus();
setviewport(x, y, cx, cy); setviewport(x, y, cx, cy);
write_cmd(RAMWR); write_cmd(RAMWR);
#if !GDISP_PACKED_PIXELS #if !GDISP_PACKED_PIXELS
// Although this controller uses packed pixels we support unpacked pixel // Although this controller uses packed pixels we support unpacked pixel
// formats in this blit by packing the data as we feed it to the controller. // formats in this blit by packing the data as we feed it to the controller.
lg = srccx - cx; lg = srccx - cx;
buffer += srcy * srccx + srcx; buffer += srcy * srccx + srcx;
x = srcx; x = srcx;
while (1) { while (1) {
/* Get a pixel */ /* Get a pixel */
c1 = *buffer++; c1 = *buffer++;
if (++x >= endx) { if (++x >= endx) {
if (++y >= endy) { if (++y >= endy) {
/* Odd pixel at end */ /* Odd pixel at end */
write_data3(0, ((c1 >> 8) & 0x0F), (c1 & 0xFF)); write_data3(0, ((c1 >> 8) & 0x0F), (c1 & 0xFF));
break; break;
} }
x = srcx; x = srcx;
buffer += lg; buffer += lg;
} }
/* Get the next pixel */ /* Get the next pixel */
c2 = *buffer++; c2 = *buffer++;
write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF)); write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
if (++x >= endx) { if (++x >= endx) {
if (++y >= endy) if (++y >= endy)
break; break;
x = srcx; x = srcx;
buffer += lg; buffer += lg;
} }
} }
#else #else
// Although this controller uses packed pixels, we may have to feed it into // Although this controller uses packed pixels, we may have to feed it into
// the controller with different packing to the source bitmap // the controller with different packing to the source bitmap
#if !GDISP_PACKED_LINES #if !GDISP_PACKED_LINES
srccx = (srccx + 1) & ~1; srccx = (srccx + 1) & ~1;
#endif #endif
pos = srcy*srccx; pos = srcy*srccx;
lg = (srccx - cx)/2*3; lg = (srccx - cx)/2*3;
p = ((const uint8_t *)buffer) + ((pos+srcx)/2 * 3); p = ((const uint8_t *)buffer) + ((pos+srcx)/2 * 3);
x = srcx; x = srcx;
while (1) { while (1) {
/* Get a pixel */ /* Get a pixel */
switch((pos+x)&1) { switch((pos+x)&1) {
case 0: c1 = (((color_t)p[0]) << 4)|(((color_t)p[1])>>4); break; case 0: c1 = (((color_t)p[0]) << 4)|(((color_t)p[1])>>4); break;
case 1: c1 = (((color_t)p[1]&0x0F) << 8)|((color_t)p[1]); break; case 1: c1 = (((color_t)p[1]&0x0F) << 8)|((color_t)p[1]); break;
} }
if (++x >= endx) { if (++x >= endx) {
if (++y >= endy) { if (++y >= endy) {
/* Odd pixel at end */ /* Odd pixel at end */
write_data3(0, ((c1 >> 8) & 0x0F), (c1 & 0xFF)); write_data3(0, ((c1 >> 8) & 0x0F), (c1 & 0xFF));
break; break;
} }
x = srcx; x = srcx;
p += lg; p += lg;
pos += srccx; pos += srccx;
} }
/* Get the next pixel */ /* Get the next pixel */
switch((pos+x)&1) { switch((pos+x)&1) {
case 0: c2 = (((color_t)p[0]) << 4)|(((color_t)p[1])>>4); break; case 0: c2 = (((color_t)p[0]) << 4)|(((color_t)p[1])>>4); break;
case 1: c2 = (((color_t)p[1]&0x0F) << 8)|((color_t)p[1]); break; case 1: c2 = (((color_t)p[1]&0x0F) << 8)|((color_t)p[1]); break;
} }
write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF)); write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
if (++x >= endx) { if (++x >= endx) {
if (++y >= endy) if (++y >= endy)
break; break;
x = srcx; x = srcx;
p += lg; p += lg;
pos += srccx; pos += srccx;
} }
} }
#endif #endif
release_bus(); release_bus();
} }
#endif #endif
#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) #if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD)
/** /**
* @brief Get the color of a particular pixel. * @brief Get the color of a particular pixel.
* @note If x,y is off the screen, the result is undefined. * @note If x,y is off the screen, the result is undefined.
* *
* @param[in] x, y The start of the text * @param[in] x, y The start of the text
* *
* @notapi * @notapi
*/ */
color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) { color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
/* NOT IMPLEMENTED */ /* NOT IMPLEMENTED */
/* Some board hardware might support this in the future. /* Some board hardware might support this in the future.
* The Olimex board doesn't. * The Olimex board doesn't.
*/ */
} }
#endif #endif
#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) #if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL)
/** /**
* @brief Scroll vertically a section of the screen. * @brief Scroll vertically a section of the screen.
* @note If x,y + cx,cy is off the screen, the result is undefined. * @note If x,y + cx,cy is off the screen, the result is undefined.
* @note If lines is >= cy, it is equivelent to a area fill with bgcolor. * @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
* *
* @param[in] x, y The start of the area to be scrolled * @param[in] x, y The start of the area to be scrolled
* @param[in] cx, cy The size of the area to be scrolled * @param[in] cx, cy The size of the area to be scrolled
* @param[in] lines The number of lines to scroll (Can be positive or negative) * @param[in] lines The number of lines to scroll (Can be positive or negative)
* @param[in] bgcolor The color to fill the newly exposed area. * @param[in] bgcolor The color to fill the newly exposed area.
* *
* @notapi * @notapi
*/ */
void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) { void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
/* NOT IMPLEMENTED */ /* NOT IMPLEMENTED */
/* The hardware seems capable of doing this. /* The hardware seems capable of doing this.
* It is just really complex so we leave it out for now. * It is just really complex so we leave it out for now.
*/ */
} }
#endif #endif
#if GDISP_HARDWARE_CONTROL || defined(__DOXYGEN__) #if GDISP_HARDWARE_CONTROL || defined(__DOXYGEN__)
/** /**
* @brief Driver Control * @brief Driver Control
* @details Unsupported control codes are ignored. * @details Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *). * @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver. * @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t * @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t * GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver * GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other * that only supports off/on anything other
* than zero is on. * than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100. * GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at * GDISP_CONTROL_LLD - Low level driver control constants start at
* this value. * this value.
* *
* @param[in] what What to do. * @param[in] what What to do.
* @param[in] value The value to use (always cast to a void *). * @param[in] value The value to use (always cast to a void *).
* *
* @notapi * @notapi
*/ */
void lld_gdisp_control(unsigned what, void *value) { void gdisp_lld_control(unsigned what, void *value) {
/* The hardware is capable of supporting... /* The hardware is capable of supporting...
* GDISP_CONTROL_POWER - not implemented yet * GDISP_CONTROL_POWER - not implemented yet
* GDISP_CONTROL_ORIENTATION - not implemented yet * GDISP_CONTROL_ORIENTATION - not implemented yet
* GDISP_CONTROL_BACKLIGHT - supported (the OlimexSAM7EX256 board.h currently only implements off/on although PWM is supported by the hardware) * GDISP_CONTROL_BACKLIGHT - supported (the OlimexSAM7EX256 board.h currently only implements off/on although PWM is supported by the hardware)
* GDISP_CONTROL_CONTRAST - supported * GDISP_CONTROL_CONTRAST - supported
*/ */
switch(what) { switch(what) {
#if 0 #if 0
// NOT IMPLEMENTED YET // NOT IMPLEMENTED YET
case GDISP_CONTROL_POWER: case GDISP_CONTROL_POWER:
if (GDISP.Powermode == (gdisp_powermode_t)value) if (GDISP.Powermode == (gdisp_powermode_t)value)
return; return;
switch((gdisp_powermode_t)value) { switch((gdisp_powermode_t)value) {
case powerOff: case powerOff:
// Code here // Code here
break; break;
case powerOn: case powerOn:
// Code here // Code here
/* You may need this --- /* You may need this ---
* if (GDISP.Powermode != powerSleep) * if (GDISP.Powermode != powerSleep)
* lld_gdisp_init(); * gdisp_lld_init();
*/ */
break; break;
case powerSleep: case powerSleep:
/* Code here */ /* Code here */
break; break;
default: default:
return; return;
} }
GDISP.Powermode = (gdisp_powermode_t)value; GDISP.Powermode = (gdisp_powermode_t)value;
return; return;
#endif #endif
#if 0 #if 0
// NOT IMPLEMENTED YET // NOT IMPLEMENTED YET
case GDISP_CONTROL_ORIENTATION: case GDISP_CONTROL_ORIENTATION:
if (GDISP.Orientation == (gdisp_orientation_t)value) if (GDISP.Orientation == (gdisp_orientation_t)value)
return; return;
// WriteSpiData(0x48); // no mirror Y (temporary to satisfy Olimex bmptoarray utility) // WriteSpiData(0x48); // no mirror Y (temporary to satisfy Olimex bmptoarray utility)
// WriteSpiData(0xC8); // restore to (mirror x and y, reverse rgb) // WriteSpiData(0xC8); // restore to (mirror x and y, reverse rgb)
switch((gdisp_orientation_t)value) { switch((gdisp_orientation_t)value) {
case GDISP_ROTATE_0: case GDISP_ROTATE_0:
// Code here // Code here
GDISP.Height = GDISP_SCREEN_HEIGHT; GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
break; break;
case GDISP_ROTATE_90: case GDISP_ROTATE_90:
// Code here // Code here
GDISP.Height = GDISP_SCREEN_WIDTH; GDISP.Height = GDISP_SCREEN_WIDTH;
GDISP.Width = GDISP_SCREEN_HEIGHT; GDISP.Width = GDISP_SCREEN_HEIGHT;
break; break;
case GDISP_ROTATE_180: case GDISP_ROTATE_180:
// Code here // Code here
GDISP.Height = GDISP_SCREEN_HEIGHT; GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
break; break;
case GDISP_ROTATE_270: case GDISP_ROTATE_270:
// Code here // Code here
GDISP.Height = GDISP_SCREEN_WIDTH; GDISP.Height = GDISP_SCREEN_WIDTH;
GDISP.Width = GDISP_SCREEN_HEIGHT; GDISP.Width = GDISP_SCREEN_HEIGHT;
break; break;
default: default:
return; return;
} }
#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION #if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
GDISP.clipx0 = 0; GDISP.clipx0 = 0;
GDISP.clipy0 = 0; GDISP.clipy0 = 0;
GDISP.clipx1 = GDISP.Width; GDISP.clipx1 = GDISP.Width;
GDISP.clipy1 = GDISP.Height; GDISP.clipy1 = GDISP.Height;
#endif #endif
GDISP.Orientation = (gdisp_orientation_t)value; GDISP.Orientation = (gdisp_orientation_t)value;
return; return;
#endif #endif
case GDISP_CONTROL_BACKLIGHT: case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)value > 100) value = (void *)100; if ((unsigned)value > 100) value = (void *)100;
set_backlight((unsigned)value); set_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value; GDISP.Backlight = (unsigned)value;
return; return;
case GDISP_CONTROL_CONTRAST: case GDISP_CONTROL_CONTRAST:
if ((unsigned)value > 100) value = (void *)100; if ((unsigned)value > 100) value = (void *)100;
acquire_bus(); acquire_bus();
write_cmd2(VOLCTR, (unsigned)value, 0x03); write_cmd2(VOLCTR, (unsigned)value, 0x03);
release_bus(); release_bus();
GDISP.Contrast = (unsigned)value; GDISP.Contrast = (unsigned)value;
return; return;
} }
} }
#endif #endif
#endif /* GFX_USE_GDISP */ #endif /* GFX_USE_GDISP */
/** @} */ /** @} */

1142
drivers/gdisp/S6D1121/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

1166
drivers/gdisp/SSD1289/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

1226
drivers/gdisp/SSD1963/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

266
drivers/gdisp/TestStub/gdisp_lld.c
View file

@ -1,133 +1,133 @@
/* /*
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 drivers/gdisp/TestStub/gdisp_lld.c * @file drivers/gdisp/TestStub/gdisp_lld.c
* @brief GDISP Graphics Driver subsystem low level driver source (stub). * @brief GDISP Graphics Driver subsystem low level driver source (stub).
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/ #if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/
/* Include the emulation code for things we don't support */ /* Include the emulation code for things we don't support */
#include "gdisp/lld/emulation.c" #include "gdisp/lld/emulation.c"
#ifndef GDISP_SCREEN_HEIGHT #ifndef GDISP_SCREEN_HEIGHT
#define GDISP_SCREEN_HEIGHT 128 #define GDISP_SCREEN_HEIGHT 128
#endif #endif
#ifndef GDISP_SCREEN_WIDTH #ifndef GDISP_SCREEN_WIDTH
#define GDISP_SCREEN_WIDTH 128 #define GDISP_SCREEN_WIDTH 128
#endif #endif
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.
All other routines are optional. All other routines are optional.
*/ */
/** /**
* @brief Low level GDISP driver initialization. * @brief Low level GDISP driver initialization.
* *
* @notapi * @notapi
*/ */
bool_t lld_gdisp_init(void) { bool_t gdisp_lld_init(void) {
/* Initialise the GDISP structure */ /* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT; GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Orientation = GDISP_ROTATE_0; GDISP.Orientation = GDISP_ROTATE_0;
GDISP.Powermode = powerOff; GDISP.Powermode = powerOff;
GDISP.Backlight = 100; GDISP.Backlight = 100;
GDISP.Contrast = 50; GDISP.Contrast = 50;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
GDISP.clipx0 = 0; GDISP.clipx0 = 0;
GDISP.clipy0 = 0; GDISP.clipy0 = 0;
GDISP.clipx1 = GDISP.Width; GDISP.clipx1 = GDISP.Width;
GDISP.clipy1 = GDISP.Height; GDISP.clipy1 = GDISP.Height;
#endif #endif
return TRUE; return TRUE;
} }
/** /**
* @brief Draws a pixel on the display. * @brief Draws a pixel on the display.
* *
* @param[in] x X location of the pixel * @param[in] x X location of the pixel
* @param[in] y Y location of the pixel * @param[in] y Y location of the pixel
* @param[in] color The color of the pixel * @param[in] color The color of the pixel
* *
* @notapi * @notapi
*/ */
void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) { void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
(void)x; (void)x;
(void)y; (void)y;
(void)color; (void)color;
} }
/* ---- Optional Routines ---- */ /* ---- Optional Routines ---- */
#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
/** /**
* @brief Get the color of a particular pixel. * @brief Get the color of a particular pixel.
* @note Optional. * @note Optional.
* @note If x,y is off the screen, the result is undefined. * @note If x,y is off the screen, the result is undefined.
* *
* @param[in] x, y The start of the text * @param[in] x, y The start of the text
* *
* @notapi * @notapi
*/ */
color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) { color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
(void)x; (void)x;
(void)y; (void)y;
return 0; return 0;
} }
#endif #endif
#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__) #if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
/** /**
* @brief Scroll vertically a section of the screen. * @brief Scroll vertically a section of the screen.
* @note Optional. * @note Optional.
* @note If x,y + cx,cy is off the screen, the result is undefined. * @note If x,y + cx,cy is off the screen, the result is undefined.
* @note If lines is >= cy, it is equivelent to a area fill with bgcolor. * @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
* *
* @param[in] x, y The start of the area to be scrolled * @param[in] x, y The start of the area to be scrolled
* @param[in] cx, cy The size of the area to be scrolled * @param[in] cx, cy The size of the area to be scrolled
* @param[in] lines The number of lines to scroll (Can be positive or negative) * @param[in] lines The number of lines to scroll (Can be positive or negative)
* @param[in] bgcolor The color to fill the newly exposed area. * @param[in] bgcolor The color to fill the newly exposed area.
* *
* @notapi * @notapi
*/ */
void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) { void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
(void)x; (void)x;
(void)y; (void)y;
(void)cx; (void)cx;
(void)cy; (void)cy;
(void)lines; (void)lines;
(void)bgcolor; (void)bgcolor;
} }
#endif #endif
#endif /* GFX_USE_GDISP */ #endif /* GFX_USE_GDISP */
/** @} */ /** @} */

2052
drivers/multiple/Win32/gdisp_lld.c
View file

File diff suppressed because it is too large Load diff

328
drivers/tdisp/HD44780/tdisp_lld.c
View file

@ -1,164 +1,164 @@
/* /*
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 drivers/tdisp/HD44780/tdisp_lld.c * @file drivers/tdisp/HD44780/tdisp_lld.c
* @brief TDISP driver subsystem low level driver source for the HD44780 display * @brief TDISP driver subsystem low level driver source for the HD44780 display
* *
* @addtogroup TDISP * @addtogroup TDISP
* @{ * @{
*/ */
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_TDISP /*|| defined(__DOXYGEN__)*/ #if GFX_USE_TDISP /*|| defined(__DOXYGEN__)*/
/* The user may override the default display size */ /* Include the hardware interface details */
#ifndef TDISP_COLUMNS #if defined(TDISP_USE_CUSTOM_BOARD) && TDISP_USE_CUSTOM_BOARD
#define TDISP_COLUMNS 16 /* Include the user supplied board definitions */
#endif #include "tdisp_lld_board.h"
#ifndef TDISP_ROWS #elif defined(BOARD_UNKNOWN)
#define TDISP_ROWS 2 #include "gdisp_lld_board_unknown.h"
#endif #else
/* Include the user supplied board definitions */
/* Controller Specific Properties */ #include "gdisp_lld_board.h"
#define CUSTOM_CHAR_COUNT 8 #endif
#define CUSTOM_CHAR_XBITS 5
#define CUSTOM_CHAR_YBITS 8 /* The user may override the default display size */
#ifndef TDISP_COLUMNS
/* Define the properties of our controller */ #define TDISP_COLUMNS 16
tdispStruct TDISP = { #endif
TDISP_COLUMNS, TDISP_ROWS, /* cols, rows */ #ifndef TDISP_ROWS
CUSTOM_CHAR_XBITS, CUSTOM_CHAR_YBITS, /* charBitsX, charBitsY */ #define TDISP_ROWS 2
CUSTOM_CHAR_COUNT /* maxCustomChars */ #endif
};
/* Controller Specific Properties */
/* Include the hardware interface details */ #define CUSTOM_CHAR_COUNT 8
#if defined(TDISP_USE_CUSTOM_BOARD) && TDISP_USE_CUSTOM_BOARD #define CUSTOM_CHAR_XBITS 5
/* Include the user supplied board definitions */ #define CUSTOM_CHAR_YBITS 8
#include "tdisp_lld_board.h"
#elif defined(BOARD_UNKNOWN) /* Define the properties of our controller */
#include "gdisp_lld_board_unknown.h" tdispStruct TDISP = {
#else TDISP_COLUMNS, TDISP_ROWS, /* cols, rows */
/* Include the user supplied board definitions */ CUSTOM_CHAR_XBITS, CUSTOM_CHAR_YBITS, /* charBitsX, charBitsY */
#include "gdisp_lld_board.h" CUSTOM_CHAR_COUNT /* maxCustomChars */
#endif };
/* Our display control */ /* Our display control */
#define DISPLAY_ON 0x04 #define DISPLAY_ON 0x04
#define CURSOR_ON 0x02 #define CURSOR_ON 0x02
#define CURSOR_BLINK 0x01 #define CURSOR_BLINK 0x01
static uint8_t displaycontrol; static uint8_t displaycontrol;
bool_t tdisp_lld_init(void) { bool_t tdisp_lld_init(void) {
/* initialise hardware */ /* initialise hardware */
init_board(); init_board();
/* wait some time */ /* wait some time */
chThdSleepMilliseconds(50); chThdSleepMilliseconds(50);
write_cmd(0x38); write_cmd(0x38);
chThdSleepMilliseconds(64); chThdSleepMilliseconds(64);
displaycontrol = DISPLAY_ON | CURSOR_ON | CURSOR_BLINK; // The default displaycontrol displaycontrol = DISPLAY_ON | CURSOR_ON | CURSOR_BLINK; // The default displaycontrol
write_cmd(0x08 | displaycontrol); write_cmd(0x08 | displaycontrol);
chThdSleepMicroseconds(50); chThdSleepMicroseconds(50);
write_cmd(0x01); // Clear the screen write_cmd(0x01); // Clear the screen
chThdSleepMilliseconds(5); chThdSleepMilliseconds(5);
write_cmd(0x06); write_cmd(0x06);
chThdSleepMicroseconds(50); chThdSleepMicroseconds(50);
return TRUE; return TRUE;
} }
void tdisp_lld_clear(void) { void tdisp_lld_clear(void) {
write_cmd(0x01); write_cmd(0x01);
} }
void tdisp_lld_draw_char(char c) { void tdisp_lld_draw_char(char c) {
write_data(c); write_data(c);
} }
void tdisp_lld_set_cursor(coord_t col, coord_t row) { void tdisp_lld_set_cursor(coord_t col, coord_t row) {
static const uint8_t row_offsets[] = { 0x00, 0x40, 0x14, 0x54 }; static const uint8_t row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
/* /*
* Short-cut: * Short-cut:
* *
* If x and y = 0 then use the home command. * If x and y = 0 then use the home command.
* *
* Note: There is probably no advantage as both commands are a single byte * Note: There is probably no advantage as both commands are a single byte
*/ */
// if (col == 0 && row == 0) { // if (col == 0 && row == 0) {
// write_cmd(0x02); // write_cmd(0x02);
// return; // return;
// } // }
write_cmd(0x80 | (col + row_offsets[row])); write_cmd(0x80 | (col + row_offsets[row]));
} }
void tdisp_lld_create_char(uint8_t address, uint8_t *charmap) { void tdisp_lld_create_char(uint8_t address, uint8_t *charmap) {
int i; int i;
write_cmd(0x40 | (address << 3)); write_cmd(0x40 | (address << 3));
for(i = 0; i < CUSTOM_CHAR_YBITS; i++) for(i = 0; i < CUSTOM_CHAR_YBITS; i++)
write_data(charmap[i]); write_data(charmap[i]);
} }
void tdisp_lld_control(uint16_t what, void *value) { void tdisp_lld_control(uint16_t what, void *value) {
switch(what) { switch(what) {
case TDISP_CTRL_BACKLIGHT: case TDISP_CTRL_BACKLIGHT:
if ((uint8_t)value) if ((uint8_t)value)
displaycontrol |= DISPLAY_ON; displaycontrol |= DISPLAY_ON;
else else
displaycontrol &= ~DISPLAY_ON; displaycontrol &= ~DISPLAY_ON;
write_cmd(0x08 | displaycontrol); write_cmd(0x08 | displaycontrol);
break; break;
case TDISP_CTRL_CURSOR: case TDISP_CTRL_CURSOR:
switch((cursorshape)value) { switch((cursorshape)value) {
case cursorOff: case cursorOff:
displaycontrol &= ~CURSOR_ON; displaycontrol &= ~CURSOR_ON;
break; break;
case cursorBlock: case cursorBlock:
case cursorUnderline: case cursorUnderline:
case cursorBar: case cursorBar:
displaycontrol = (displaycontrol | CURSOR_ON) & ~CURSOR_BLINK; displaycontrol = (displaycontrol | CURSOR_ON) & ~CURSOR_BLINK;
break; break;
case cursorBlinkingBlock: case cursorBlinkingBlock:
case cursorBlinkingUnderline: case cursorBlinkingUnderline:
case cursorBlinkingBar: case cursorBlinkingBar:
default: default:
displaycontrol |= (CURSOR_ON | CURSOR_BLINK); displaycontrol |= (CURSOR_ON | CURSOR_BLINK);
break; break;
} }
write_cmd(0x08 | displaycontrol); write_cmd(0x08 | displaycontrol);
break; break;
} }
} }
#endif /* GFX_USE_TDISP */ #endif /* GFX_USE_TDISP */
/** @} */ /** @} */

109
drivers/tdisp/HD44780/tdisp_lld_board_example.h
View file

@ -1,48 +1,61 @@
/* /*
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 drivers/tdisp/HD44780/tdisp_lld_board_example.h * @file drivers/tdisp/HD44780/tdisp_lld_board_example.h
* @brief TDISP driver subsystem board interface for the HD44780 display * @brief TDISP driver subsystem board interface for the HD44780 display
* *
* @addtogroup TDISP * @addtogroup TDISP
* @{ * @{
*/ */
#ifndef _TDISP_LLD_BOARD_H #ifndef _TDISP_LLD_BOARD_H
#define _TDISP_LLD_BOARD_H #define _TDISP_LLD_BOARD_H
static void init_board(void) { /**
/* Code here */ * The board may override the default display size.
#error "tdispHD44780: You must supply a definition for init_board for your board" * Uncomment the below if your board needs a non-standard size.
} */
/*
static void write_cmd(uint8_t data) { #ifndef TDISP_COLUMNS
/* Code here */ #define TDISP_COLUMNS 16
#error "tdispHD44780: You must supply a definition for write_cmd for your board" #endif
} #ifndef TDISP_ROWS
#define TDISP_ROWS 2
static void write_data(uint8_t data) { #endif
/* Code here */ */
#error "tdispHD44780: You must supply a definition for write_data for your board"
} static void init_board(void) {
/* Code here */
#endif /* _TDISP_LLD_BOARD_H */ #error "tdispHD44780: You must supply a definition for init_board for your board"
/** @} */ }
static void write_cmd(uint8_t data) {
/* Code here */
#error "tdispHD44780: You must supply a definition for write_cmd for your board"
}
static void write_data(uint8_t data) {
/* Code here */
#error "tdispHD44780: You must supply a definition for write_data for your board"
}
#endif /* _TDISP_LLD_BOARD_H */
/** @} */

2
gfxconf.example.h
View file

@ -96,10 +96,8 @@
#define GDISP_SCREEN_HEIGHT 240 #define GDISP_SCREEN_HEIGHT 240
#define GDISP_USE_FSMC #define GDISP_USE_FSMC
#define GDISP_USE_GPIO #define GDISP_USE_GPIO
#define TDISP_COLUMNS 16 #define TDISP_COLUMNS 16
#define TDISP_ROWS 2 #define TDISP_ROWS 2
*/ */
#endif /* _GFXCONF_H */ #endif /* _GFXCONF_H */

508
include/gadc/gadc.h
View file

@ -1,250 +1,258 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012, 2013
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/gadc/gadc.h * @file include/gadc/gadc.h
* @brief GADC - Periodic ADC subsystem header file. * @brief GADC - Periodic ADC subsystem header file.
* *
* @addtogroup GADC * @addtogroup GADC
* *
* @details The reason why ChibiOS/GFX has it's own ADC abstraction is because * @details The reason why ChibiOS/GFX has it's own ADC abstraction is because
* the Chibi-OS drivers are very CPU specific and do not * the Chibi-OS drivers are very CPU specific and do not
* provide a way across all hardware platforms to create periodic * provide a way across all hardware platforms to create periodic
* ADC conversions. There are also issues with devices with different * ADC conversions. There are also issues with devices with different
* characteristics or periodic requirements on the same ADC * characteristics or periodic requirements on the same ADC
* device (but different channels). This layer attempts to solve these * device (but different channels). This layer attempts to solve these
* problems to provide a architecture neutral API. It also provides extra * problems to provide a architecture neutral API. It also provides extra
* features such as multi-buffer chaining for high speed ADC sources. * features such as multi-buffer chaining for high speed ADC sources.
* It provides one high speed virtual ADC device (eg a microphone) and * It provides one high speed virtual ADC device (eg a microphone) and
* numerous low speed (less than 100Hz) virtual ADC devices (eg dials, * numerous low speed (less than 100Hz) virtual ADC devices (eg dials,
* temperature sensors etc). The high speed device has timer based polling * temperature sensors etc). The high speed device has timer based polling
* to ensure exact conversion periods and a buffer management system. * to ensure exact conversion periods and a buffer management system.
* The low speed devices are assumed to be non-critical timing devices * The low speed devices are assumed to be non-critical timing devices
* and do not have any buffer management. * and do not have any buffer management.
* Note that while only one high speed device has been provided it can * Note that while only one high speed device has been provided it can
* be used to read multiple physical ADC channels on the one physical * be used to read multiple physical ADC channels on the one physical
* ADC device. * ADC device.
* All callback routines are thread based unlike the Chibi-OS interrupt based * All callback routines are thread based unlike the Chibi-OS interrupt based
* routines. * routines.
* *
* @{ * @{
*/ */
#ifndef _GADC_H #ifndef _GADC_H
#define _GADC_H #define _GADC_H
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GADC || defined(__DOXYGEN__) #if GFX_USE_GADC || defined(__DOXYGEN__)
/* Include the driver defines */ /* Include the driver defines */
#include "gadc_lld_config.h" #include "gadc_lld_config.h"
/*===========================================================================*/ /*===========================================================================*/
/* Type definitions */ /* Type definitions */
/*===========================================================================*/ /*===========================================================================*/
// Event types for GADC // Event types for GADC
#define GEVENT_ADC (GEVENT_GADC_FIRST+0) #define GEVENT_ADC (GEVENT_GADC_FIRST+0)
/** /**
* @brief The High Speed ADC event structure. * @brief The High Speed ADC event structure.
* @{ * @{
*/ */
typedef struct GEventADC_t { typedef struct GEventADC_t {
/** #if GFX_USE_GEVENT || defined(__DOXYGEN__)
* @brief The type of this event (GEVENT_ADC) /**
*/ * @brief The type of this event (GEVENT_ADC)
GEventType type; */
/** GEventType type;
* @brief The event flags #endif
*/
uint16_t flags; /**
/** * @brief The event flags
* @brief The event flag values. */
* @{ uint16_t flags;
*/ /**
#define GADC_HSADC_LOSTEVENT 0x0001 /**< @brief The last GEVENT_HSDADC event was lost */ * @brief The event flag values.
/** @} */ * @{
/** */
* @brief The number of conversions in the buffer #define GADC_HSADC_LOSTEVENT 0x0001 /**< @brief The last GEVENT_HSDADC event was lost */
*/ /** @} */
size_t count; /**
/** * @brief The number of conversions in the buffer
* @brief The buffer containing the conversion samples */
*/ size_t count;
adcsample_t *buffer; /**
} GEventADC; * @brief The buffer containing the conversion samples
*/
/** adcsample_t *buffer;
* @brief A callback function (executed in a thread context) } GEventADC;
*/
typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param); /**
* @brief A callback function (executed in a thread context)
/*===========================================================================*/ */
/* External declarations. */ typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param);
/*===========================================================================*/
/*===========================================================================*/
#ifdef __cplusplus /* External declarations. */
extern "C" { /*===========================================================================*/
#endif
#ifdef __cplusplus
/** extern "C" {
* @brief Initialise the high speed ADC. #endif
* @details Initialises but does not start the conversions.
* /**
* @param[in] physdev A value passed to describe which physical ADC devices/channels to use. * @brief Initialise the high speed ADC.
* @param[in] frequency The frequency to create ADC conversions * @details Initialises but does not start the conversions.
* @param[in] buffer The static buffer to put the ADC samples into. *
* @param[in] bufcount The total number of conversions that will fit in the buffer. * @param[in] physdev A value passed to describe which physical ADC devices/channels to use.
* @param[in] countPerEvent The number of conversions to do before returning an event. * @param[in] frequency The frequency to create ADC conversions
* * @param[in] buffer The static buffer to put the ADC samples into.
* @note If the high speed ADC is running it will be stopped. * @param[in] bufcount The total number of conversions that will fit in the buffer.
* @note Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not * @param[in] countPerEvent The number of conversions to do before returning an event.
* 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 If the high speed ADC is running it will be stopped. The Event subsystem is
* Each channel is then interleaved into the provided buffer. Note 'bufcount' * disconnected from the high speed ADC and any binary semaphore event is forgotten.
* and 'countPerEvent' parameters describe the number of conversions not the * @note bufcount must be greater than countPerEvent (usually 2 or more times) otherwise
* number of samples. * the buffer will be overwitten with new data while the application is still trying
* As an example, if physdev turns on 2 devices then the buffer contains * to process the old data.
* alternate device samples and the buffer must contain 2 * bufcount samples. * @note Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not
* The exact meaning of physdev is hardware dependent. * evenly divisable by countPerEvent, the remainder must also be even.
* @note The buffer is circular. When the end of the buffer is reached it will start * @note The physdev parameter may be used to turn on more than one ADC channel.
* putting data into the beginning of the buffer again. * Each channel is then interleaved into the provided buffer. Note 'bufcount'
* @note The event listener must process the event (and the data in it) before the * and 'countPerEvent' parameters describe the number of conversions not the
* next event occurs. If not, the following event will be lost. * number of samples.
* @note If bufcount is evenly divisable by countPerEvent, then every event will return * As an example, if physdev turns on 2 devices then the buffer contains
* countPerEvent conversions. If bufcount is not evenly divisable, it will return * alternate device samples and the buffer must contain 2 * bufcount samples.
* a block of samples containing less than countPerEvent samples when it reaches the * The exact meaning of physdev is hardware dependent.
* end of the buffer. * @note The buffer is circular. When the end of the buffer is reached it will start
* @note While the high speed ADC is running, low speed conversions can only occur at * putting data into the beginning of the buffer again.
* the frequency of the high speed events. Thus if high speed events are * @note The event listener must process the event (and the data in it) before the
* being created at 50Hz (eg countPerEvent = 100, frequency = 5kHz) then the maximum * next event occurs. If not, the following event will be lost.
* frequency for low speed conversions is likely to be 50Hz (although it might be * @note If bufcount is evenly divisable by countPerEvent, then every event will return
* 100Hz on some hardware). * countPerEvent conversions. If bufcount is not evenly divisable, it will return
* * a block of samples containing less than countPerEvent samples when it reaches the
* @api * end of the buffer.
*/ * @note While the high speed ADC is running, low speed conversions can only occur at
void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent); * 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
#if GFX_USE_GEVENT || defined(__DOXYGEN__) * frequency for low speed conversions is likely to be 50Hz (although it might be
/** * 100Hz on some hardware).
* @brief Turn on sending results to the GEVENT sub-system. *
* @details Returns a GSourceHandle to listen for GEVENT_ADC events. * @api
* */
* @note The high speed ADC will not use the GEVENT system unless this is void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent);
* called first. This saves processing time if the application does
* not want to use the GEVENT sub-system for the high speed ADC. #if GFX_USE_GEVENT || defined(__DOXYGEN__)
* Once turned on it cannot be turned off. /**
* @note The high speed ADC is capable of signalling via this method and a binary semaphore * @brief Turn on sending results to the GEVENT sub-system.
* at the same time. * @details Returns a GSourceHandle to listen for GEVENT_ADC events.
* *
* @api * @note The high speed ADC will not use the GEVENT system unless this is
*/ * called first. This saves processing time if the application does
GSourceHandle gadcHighSpeedGetSource(void); * not want to use the GEVENT sub-system for the high speed ADC.
#endif * 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
/** * at the same time.
* @brief Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer. *
* * @api
* @param[in] pbsem The binary semaphore is signaled when data is available. */
* @param[in] pEvent The static event buffer to place the result information. GSourceHandle gadcHighSpeedGetSource(void);
* #endif
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method.
* @note The high speed ADC is capable of signalling via this method and the GEVENT /**
* sub-system at the same time. * @brief Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer.
* *
* @api * @param[in] pbsem The binary semaphore is signaled when data is available.
*/ * @param[in] pEvent The static event buffer to place the result information.
void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent); *
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling
/** * @p gadcHighSpeedInit().
* @brief Start the high speed ADC conversions. * @note The high speed ADC is capable of signalling via this method and the GEVENT
* @pre It must have been initialised first with @p gadcHighSpeedInit() * sub-system at the same time.
* *
* @api * @api
*/ */
GSourceHandle gadcHighSpeedStart(void); void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent);
/** /**
* @brief Stop the high speed ADC conversions. * @brief Start the high speed ADC conversions.
* * @pre It must have been initialised first with @p gadcHighSpeedInit()
* @api *
*/ * @api
void gadcHighSpeedStop(void); */
void gadcHighSpeedStart(void);
/**
* @brief Perform a single low speed ADC conversion /**
* @details Blocks until the conversion is complete * @brief Stop the high speed ADC conversions.
* @pre This should not be called from within a GTimer callback as this routine *
* blocks until the conversion is ready. * @api
* */
* @param[in] physdev A value passed to describe which physical ADC devices/channels to use. void gadcHighSpeedStop(void);
* @param[in] buffer The static buffer to put the ADC samples into.
* /**
* @note This may take a while to complete if the high speed ADC is running as the * @brief Perform a single low speed ADC conversion
* conversion is interleaved with the high speed ADC conversions on a buffer * @details Blocks until the conversion is complete
* completion. * @pre This should not be called from within a GTimer callback as this routine
* @note The result buffer must be large enough to store one sample per device * blocks until the conversion is ready.
* described by the 'physdev' parameter. *
* @note If calling this routine would exceed @p GADC_MAX_LOWSPEED_DEVICES simultaneous low * @param[in] physdev A value passed to describe which physical ADC devices/channels to use.
* speed devices, the routine will wait for an available slot to complete the * @param[in] buffer The static buffer to put the ADC samples into.
* conversion. *
* @note Specifying more than one device in physdev is possible but discouraged as the * @note This may take a while to complete if the high speed ADC is running as the
* calculations to ensure the high speed ADC correctness will be incorrect. Symptoms * conversion is interleaved with the high speed ADC conversions on a buffer
* from over-running the high speed ADC include high speed samples being lost. * completion.
* * @note The result buffer must be large enough to store one sample per device
* @api * described by the 'physdev' parameter.
*/ * @note If calling this routine would exceed @p GADC_MAX_LOWSPEED_DEVICES simultaneous low
void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer); * speed devices, the routine will wait for an available slot to complete the
* conversion.
/** * @note Specifying more than one device in physdev is possible but discouraged as the
* @brief Perform a low speed ADC conversion with callback (in a thread context) * calculations to ensure the high speed ADC correctness will be incorrect. Symptoms
* @details Returns FALSE if there are no free low speed ADC slots. See @p GADC_MAX_LOWSPEED_DEVICES for details. * from over-running the high speed ADC include high speed samples being lost.
* *
* @param[in] physdev A value passed to describe which physical ADC devices/channels to use. * @api
* @param[in] buffer The static buffer to put the ADC samples into. */
* @param[in] fn The callback function to call when the conversion is complete. void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer);
* @param[in] param A parameter to pass to the callback function.
* /**
* @note This may be safely called from within a GTimer callback. * @brief Perform a low speed ADC conversion with callback (in a thread context)
* @note The callback may take a while to occur if the high speed ADC is running as the * @details Returns FALSE if there are no free low speed ADC slots. See @p GADC_MAX_LOWSPEED_DEVICES for details.
* conversion is interleaved with the high speed ADC conversions on a buffer *
* completion. * @param[in] physdev A value passed to describe which physical ADC devices/channels to use.
* @note The result buffer must be large enough to store one sample per device * @param[in] buffer The static buffer to put the ADC samples into.
* described by the 'physdev' parameter. * @param[in] fn The callback function to call when the conversion is complete.
* @note As this routine uses a low speed ADC, it asserts if you try to run more than @p GADC_MAX_LOWSPEED_DEVICES * @param[in] param A parameter to pass to the callback function.
* at the same time. *
* @note Specifying more than one device in physdev is possible but discouraged as the * @note This may be safely called from within a GTimer callback.
* calculations to ensure the high speed ADC correctness will be incorrect. Symptoms * @note The callback may take a while to occur if the high speed ADC is running as the
* from over-running the high speed ADC include high speed samples being lost. * conversion is interleaved with the high speed ADC conversions on a buffer
* * completion.
* @api * @note The result buffer must be large enough to store one sample per device
*/ * described by the 'physdev' parameter.
bool gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param); * @note As this routine uses a low speed ADC, it asserts if you try to run more than @p GADC_MAX_LOWSPEED_DEVICES
* at the same time.
#ifdef __cplusplus * @note Specifying more than one device in physdev is possible but discouraged as the
} * calculations to ensure the high speed ADC correctness will be incorrect. Symptoms
#endif * from over-running the high speed ADC include high speed samples being lost.
*
#endif /* GFX_USE_GADC */ * @api
*/
#endif /* _GADC_H */ bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* GFX_USE_GADC */
#endif /* _GADC_H */
/** @} */

190
include/gadc/lld/gadc_lld.h Normal file
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/>.
*/
/**
* @file include/gadc/lld/gadc_lld.h
* @brief GADC - Periodic ADC driver header file.
*
* @defgroup Driver Driver
* @ingroup GADC
* @{
*/
#ifndef _GADC_LLD_H
#define _GADC_LLD_H
#include "gfx.h"
#if GFX_USE_GADC || defined(__DOXYGEN__)
/*===========================================================================*/
/* Type definitions */
/*===========================================================================*/
/**
* @brief The structure passed to start a timer conversion
* @note We use the structure instead of parameters purely to save
* interrupt stack space which is very limited in some platforms.
* @{
*/
typedef struct GadcLldTimerData_t {
uint32_t physdev; /* @< A value passed to describe which physical ADC devices/channels to use. */
adcsample_t *buffer; /* @< The static buffer to put the ADC samples into. */
size_t count; /* @< The number of conversions to do before doing a callback and stopping the ADC. */
bool_t now; /* @< Trigger the first conversion now rather than waiting for the first timer interrupt (if possible) */
} GadcLldTimerData;
/* @} */
/**
* @brief The structure passed to start a non-timer conversion
* @note We use the structure instead of parameters purely to save
* interrupt stack space which is very limited in some platforms.
* @{
*/
typedef struct GadcLldNonTimerData_t {
uint32_t physdev; /* @< A value passed to describe which physical ADC devices/channels to use. */
adcsample_t *buffer; /* @< The static buffer to put the ADC samples into. */
} GadcLldNonTimerData;
/* @} */
/**
* @brief These routines are the callbacks that the driver uses.
* @details Defined in the high level GADC code.
*
* @notapi
* @{
*/
extern void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n);
extern void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err);
/**
* @}
*/
/**
* @brief This can be incremented by the low level driver if a timer interrupt is missed.
* @details Defined in the high level GADC code.
*
* @notapi
*/
extern volatile bool_t GADC_Timer_Missed;
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialise the driver
*
* @api
*/
void gadc_lld_init(void);
/**
* @brief Get the number of samples in a conversion.
* @details Calculates and returns the number of samples per conversion for the specified physdev.
*
* @param[in] physdev A value passed to describe which physical ADC devices/channels to use.
*
* @note A physdev describing a mono device would return 1, a stereo device would return 2.
* For most ADC's physdev is a bitmap so it is only a matter of counting the bits.
*
* @api
*/
size_t gadc_lld_samples_per_conversion(uint32_t physdev);
/**
* @brief Start a periodic timer for high frequency conversions.
*
* @param[in] physdev A value passed to describe which physical ADC devices/channels to use.
* @param[in] frequency The frequency to create ADC conversions
*
* @note The exact meaning of physdev is hardware dependent. It describes the channels
* the will be used later on when a "timer" conversion is actually scheduled.
* @note It is assumed that the timer is capable of free-running even when the ADC
* is stopped or doing something else.
* @details When a timer interrupt occurs a conversion should start if these is a "timer" conversion
* active.
* @note If the ADC is stopped, doesn't have a "timer" conversion active or is currently executing
* a non-timer conversion then the interrupt can be ignored other than (optionally) incrementing
* the GADC_Timer_Missed variable.
*
* @api
*/
void gadc_lld_start_timer(uint32_t physdev, uint32_t frequency);
/**
* @brief Stop the periodic timer for high frequency conversions.
* @details Also stops any current "timer" conversion (but not a current "non-timer" conversion).
*
* @param[in] physdev A value passed to describe which physical ADC devices/channels in use.
*
* @note The exact meaning of physdev is hardware dependent.
*
* @api
*/
void gadc_lld_stop_timer(uint32_t physdev);
/**
* @brief Start a "timer" conversion.
* @details Starts a series of conversions triggered by the timer.
*
* @param[in] pgtd Contains the parameters for the timer conversion.
*
* @note The exact meaning of physdev is hardware dependent. It is likely described in the
* drivers gadc_lld_config.h
* @note Some versions of ChibiOS actually call the callback function more than once, once
* at the half-way point and once on completion. The high level code handles this.
* @note The driver should call @p GADC_ISR_CompleteI() when it completes the operation
* (or at the half-way point), or @p GAD_ISR_ErrorI() on an error.
* @note The high level code ensures that this is not called while a non-timer conversion is in
* progress
*
* @iclass
*/
void gadc_lld_adc_timerI(GadcLldTimerData *pgtd);
/**
* @brief Start a "non-timer" conversion.
* @details Starts a single conversion now.
*
* @param[in] pgntd Contains the parameters for the non-timer conversion.
*
* @note The exact meaning of physdev is hardware dependent. It is likely described in the
* drivers gadc_lld_config.h
* @note The driver should call @p GADC_ISR_CompleteI() when it completes the operation
* or @p GAD_ISR_ErrorI() on an error.
* @note The high level code ensures that this is not called while a timer conversion is in
* progress
*
* @iclass
*/
void gadc_lld_adc_nontimerI(GadcLldNonTimerData *pgntd);
#ifdef __cplusplus
}
#endif
#endif /* GFX_USE_GADC */
#endif /* _GADC_LLD_H */
/** @} */

112
include/gadc/options.h
View file

@ -1,57 +1,55 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012, 2013
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/gadc/options.h * @file include/gadc/options.h
* @brief GADC - Periodic ADC subsystem options header file. * @brief GADC - Periodic ADC subsystem options header file.
* *
* @addtogroup GADC * @addtogroup GADC
* @{ * @{
*/ */
#ifndef _GADC_OPTIONS_H #ifndef _GADC_OPTIONS_H
#define _GADC_OPTIONS_H #define _GADC_OPTIONS_H
/** /**
* @name GADC Functionality to be included * @name GADC Functionality to be included
* @{ * @{
*/ */
/** /**
* @} * @}
* *
* @name GADC Optional Sizing Parameters * @name GADC Optional Sizing Parameters
* @{ * @{
*/ */
/** /**
* @brief The maximum simultaneous GADC low speed device conversions * @brief The maximum GADC sample rate
* @details Defaults to 4 * @details Defaults to 44000
* @note This value must be less than the number of conversions that can occur * @note This value must be less than half the maximum sample rate allowed by the CPU.
* in a single high speed ADC cycle including the high speed ADC conversion. * This is to ensure there is time between high speed samples to perform low
* For example, if the ADC can run at 132k samples per second and the high speed * speed device sampling.
* virtual ADC is using 44kHz then GADC_MAX_LOWSPEED_DEVICES should be set to */
* 132/44 - 1 = 2 #ifndef GADC_MAX_HIGH_SPEED_SAMPLERATE
*/ #define GADC_MAX_HIGH_SPEED_SAMPLERATE 44000
#ifndef GADC_MAX_LOWSPEED_DEVICES #endif
#define GADC_MAX_LOWSPEED_DEVICES 4 /** @} */
#endif
/** @} */ #endif /* _GADC_OPTIONS_H */
/** @} */
#endif /* _GADC_OPTIONS_H */
/** @} */

582
include/gdisp/gdisp.h
View file

@ -1,291 +1,291 @@
/* /*
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/gdisp/gdisp.h * @file include/gdisp/gdisp.h
* @brief GDISP Graphic Driver subsystem header file. * @brief GDISP Graphic Driver subsystem header file.
* *
* @addtogroup GDISP * @addtogroup GDISP
* *
* @details The GDISP module provides high level abstraction to interface pixel oriented graphic displays. * @details The GDISP module provides high level abstraction to interface pixel oriented graphic displays.
* *
* @pre GFX_USE_GDISP must be set to TRUE in gfxconf.h * @pre GFX_USE_GDISP must be set to TRUE in gfxconf.h
* *
* @{ * @{
*/ */
#ifndef _GDISP_H #ifndef _GDISP_H
#define _GDISP_H #define _GDISP_H
#include "gfx.h" #include "gfx.h"
/* This type definition is defined here as it gets used in other gfx sub-systems even /* This type definition is defined here as it gets used in other gfx sub-systems even
* if GFX_USE_GDISP is FALSE. * if GFX_USE_GDISP is FALSE.
*/ */
/** /**
* @brief The type for a coordinate or length on the screen. * @brief The type for a coordinate or length on the screen.
*/ */
typedef int16_t coord_t; typedef int16_t coord_t;
#if GFX_USE_GDISP || defined(__DOXYGEN__) #if GFX_USE_GDISP || defined(__DOXYGEN__)
/*===========================================================================*/ /*===========================================================================*/
/* Driver constants. */ /* Driver constants. */
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @name Some basic colors * @name Some basic colors
* @{ * @{
*/ */
#define White HTML2COLOR(0xFFFFFF) #define White HTML2COLOR(0xFFFFFF)
#define Black HTML2COLOR(0x000000) #define Black HTML2COLOR(0x000000)
#define Gray HTML2COLOR(0x808080) #define Gray HTML2COLOR(0x808080)
#define Grey Gray #define Grey Gray
#define Blue HTML2COLOR(0x0000FF) #define Blue HTML2COLOR(0x0000FF)
#define Red HTML2COLOR(0xFF0000) #define Red HTML2COLOR(0xFF0000)
#define Fuchsia HTML2COLOR(0xFF00FF) #define Fuchsia HTML2COLOR(0xFF00FF)
#define Magenta Fuchsia #define Magenta Fuchsia
#define Green HTML2COLOR(0x008000) #define Green HTML2COLOR(0x008000)
#define Yellow HTML2COLOR(0xFFFF00) #define Yellow HTML2COLOR(0xFFFF00)
#define Aqua HTML2COLOR(0x00FFFF) #define Aqua HTML2COLOR(0x00FFFF)
#define Cyan Aqua #define Cyan Aqua
#define Lime HTML2COLOR(0x00FF00) #define Lime HTML2COLOR(0x00FF00)
#define Maroon HTML2COLOR(0x800000) #define Maroon HTML2COLOR(0x800000)
#define Navy HTML2COLOR(0x000080) #define Navy HTML2COLOR(0x000080)
#define Olive HTML2COLOR(0x808000) #define Olive HTML2COLOR(0x808000)
#define Purple HTML2COLOR(0x800080) #define Purple HTML2COLOR(0x800080)
#define Silver HTML2COLOR(0xC0C0C0) #define Silver HTML2COLOR(0xC0C0C0)
#define Teal HTML2COLOR(0x008080) #define Teal HTML2COLOR(0x008080)
#define Orange HTML2COLOR(0xFFA500) #define Orange HTML2COLOR(0xFFA500)
#define Pink HTML2COLOR(0xFFC0CB) #define Pink HTML2COLOR(0xFFC0CB)
#define SkyBlue HTML2COLOR(0x87CEEB) #define SkyBlue HTML2COLOR(0x87CEEB)
/** @} */ /** @} */
/*===========================================================================*/ /*===========================================================================*/
/* Low Level Driver details and error checks. */ /* Low Level Driver details and error checks. */
/*===========================================================================*/ /*===========================================================================*/
/* Include the low level driver information */ /* Include the low level driver information */
#include "gdisp/lld/gdisp_lld.h" #include "gdisp/lld/gdisp_lld.h"
/*===========================================================================*/ /*===========================================================================*/
/* Type definitions */ /* Type definitions */
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @brief Type for the text justification. * @brief Type for the text justification.
*/ */
typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t; typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;
/** /**
* @brief Type for the font metric. * @brief Type for the font metric.
*/ */
typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t; typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;
/*===========================================================================*/ /*===========================================================================*/
/* External declarations. */ /* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__)
#if GDISP_INCLUDE_FONT_SMALL #if GDISP_INCLUDE_FONT_SMALL
extern const struct font fontSmall; extern const struct font fontSmall;
extern const struct font fontSmallDouble; extern const struct font fontSmallDouble;
extern const struct font fontSmallNarrow; extern const struct font fontSmallNarrow;
#endif #endif
#if GDISP_INCLUDE_FONT_LARGER #if GDISP_INCLUDE_FONT_LARGER
extern const struct font fontLarger; extern const struct font fontLarger;
extern const struct font fontLargerDouble; extern const struct font fontLargerDouble;
extern const struct font fontLargerNarrow; extern const struct font fontLargerNarrow;
#endif #endif
#if GDISP_INCLUDE_FONT_UI1 #if GDISP_INCLUDE_FONT_UI1
extern const struct font fontUI1; extern const struct font fontUI1;
extern const struct font fontUI1Double; extern const struct font fontUI1Double;
extern const struct font fontUI1Narrow; extern const struct font fontUI1Narrow;
#endif #endif
#if GDISP_INCLUDE_FONT_UI2 #if GDISP_INCLUDE_FONT_UI2
extern const struct font fontUI2; extern const struct font fontUI2;
extern const struct font fontUI2Double; extern const struct font fontUI2Double;
extern const struct font fontUI2Narrow; extern const struct font fontUI2Narrow;
#endif #endif
#if GDISP_INCLUDE_FONT_LARGENUMBERS #if GDISP_INCLUDE_FONT_LARGENUMBERS
extern const struct font fontLargeNumbers; extern const struct font fontLargeNumbers;
extern const struct font fontLargeNumbersDouble; extern const struct font fontLargeNumbersDouble;
extern const struct font fontLargeNumbersNarrow; extern const struct font fontLargeNumbersNarrow;
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC #if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC
/* These routines can be hardware accelerated /* These routines can be hardware accelerated
* - Do not add a routine here unless it has also been added to the hardware acceleration layer * - Do not add a routine here unless it has also been added to the hardware acceleration layer
*/ */
/* Base Functions */ /* Base Functions */
bool_t gdispInit(void); bool_t gdispInit(void);
bool_t gdispIsBusy(void); bool_t gdispIsBusy(void);
/* Drawing Functions */ /* Drawing Functions */
void gdispClear(color_t color); void gdispClear(color_t color);
void gdispDrawPixel(coord_t x, coord_t y, color_t color); void gdispDrawPixel(coord_t x, coord_t y, color_t color);
void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer); void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
/* Clipping Functions */ /* Clipping Functions */
#if GDISP_NEED_CLIP #if GDISP_NEED_CLIP
void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy); void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif #endif
/* Circle Functions */ /* Circle Functions */
#if GDISP_NEED_CIRCLE #if GDISP_NEED_CIRCLE
void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color); void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);
void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color); void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);
#endif #endif
/* Ellipse Functions */ /* Ellipse Functions */
#if GDISP_NEED_ELLIPSE #if GDISP_NEED_ELLIPSE
void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
#endif #endif
/* Arc Functions */ /* Arc Functions */
#if GDISP_NEED_ARC #if GDISP_NEED_ARC
void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color); void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color); void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
#endif #endif
/* Basic Text Rendering Functions */ /* Basic Text Rendering Functions */
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT
void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color); void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);
void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor); void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
#endif #endif
/* Read a pixel Function */ /* Read a pixel Function */
#if GDISP_NEED_PIXELREAD #if GDISP_NEED_PIXELREAD
color_t gdispGetPixelColor(coord_t x, coord_t y); color_t gdispGetPixelColor(coord_t x, coord_t y);
#endif #endif
/* Scrolling Function - clears the area scrolled out */ /* Scrolling Function - clears the area scrolled out */
#if GDISP_NEED_SCROLL #if GDISP_NEED_SCROLL
void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor); void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
#endif #endif
/* Set driver specific control */ /* Set driver specific control */
#if GDISP_NEED_CONTROL #if GDISP_NEED_CONTROL
void gdispControl(unsigned what, void *value); void gdispControl(unsigned what, void *value);
#endif #endif
/* Query driver specific data */ /* Query driver specific data */
void *gdispQuery(unsigned what); void *gdispQuery(unsigned what);
#else #else
/* The same as above but use the low level driver directly if no multi-thread support is needed */ /* The same as above but use the low level driver directly if no multi-thread support is needed */
#define gdispInit(gdisp) lld_gdisp_init() #define gdispInit(gdisp) gdisp_lld_init()
#define gdispIsBusy() FALSE #define gdispIsBusy() FALSE
#define gdispClear(color) lld_gdisp_clear(color) #define gdispClear(color) gdisp_lld_clear(color)
#define gdispDrawPixel(x, y, color) lld_gdisp_draw_pixel(x, y, color) #define gdispDrawPixel(x, y, color) gdisp_lld_draw_pixel(x, y, color)
#define gdispDrawLine(x0, y0, x1, y1, color) lld_gdisp_draw_line(x0, y0, x1, y1, color) #define gdispDrawLine(x0, y0, x1, y1, color) gdisp_lld_draw_line(x0, y0, x1, y1, color)
#define gdispFillArea(x, y, cx, cy, color) lld_gdisp_fill_area(x, y, cx, cy, color) #define gdispFillArea(x, y, cx, cy, color) gdisp_lld_fill_area(x, y, cx, cy, color)
#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf) lld_gdisp_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf) #define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf) gdisp_lld_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)
#define gdispSetClip(x, y, cx, cy) lld_gdisp_set_clip(x, y, cx, cy) #define gdispSetClip(x, y, cx, cy) gdisp_lld_set_clip(x, y, cx, cy)
#define gdispDrawCircle(x, y, radius, color) lld_gdisp_draw_circle(x, y, radius, color) #define gdispDrawCircle(x, y, radius, color) gdisp_lld_draw_circle(x, y, radius, color)
#define gdispFillCircle(x, y, radius, color) lld_gdisp_fill_circle(x, y, radius, color) #define gdispFillCircle(x, y, radius, color) gdisp_lld_fill_circle(x, y, radius, color)
#define gdispDrawArc(x, y, radius, sangle, eangle, color) lld_gdisp_draw_arc(x, y, radius, sangle, eangle, color) #define gdispDrawArc(x, y, radius, sangle, eangle, color) gdisp_lld_draw_arc(x, y, radius, sangle, eangle, color)
#define gdispFillArc(x, y, radius, sangle, eangle, color) lld_gdisp_fill_arc(x, y, radius, sangle, eangle, color) #define gdispFillArc(x, y, radius, sangle, eangle, color) gdisp_lld_fill_arc(x, y, radius, sangle, eangle, color)
#define gdispDrawEllipse(x, y, a, b, color) lld_gdisp_draw_ellipse(x, y, a, b, color) #define gdispDrawEllipse(x, y, a, b, color) gdisp_lld_draw_ellipse(x, y, a, b, color)
#define gdispFillEllipse(x, y, a, b, color) lld_gdisp_fill_ellipse(x, y, a, b, color) #define gdispFillEllipse(x, y, a, b, color) gdisp_lld_fill_ellipse(x, y, a, b, color)
#define gdispDrawChar(x, y, c, font, color) lld_gdisp_draw_char(x, y, c, font, color) #define gdispDrawChar(x, y, c, font, color) gdisp_lld_draw_char(x, y, c, font, color)
#define gdispFillChar(x, y, c, font, color, bgcolor) lld_gdisp_fill_char(x, y, c, font, color, bgcolor) #define gdispFillChar(x, y, c, font, color, bgcolor) gdisp_lld_fill_char(x, y, c, font, color, bgcolor)
#define gdispGetPixelColor(x, y) lld_gdisp_get_pixel_color(x, y) #define gdispGetPixelColor(x, y) gdisp_lld_get_pixel_color(x, y)
#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor) #define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor)
#define gdispControl(what, value) lld_gdisp_control(what, value) #define gdispControl(what, value) gdisp_lld_control(what, value)
#define gdispQuery(what) lld_gdisp_query(what) #define gdispQuery(what) gdisp_lld_query(what)
#endif #endif
/* These routines are not hardware accelerated /* These routines are not hardware accelerated
* - Do not add a hardware accelerated routines here. * - Do not add a hardware accelerated routines here.
*/ */
/* Extra drawing functions */ /* Extra drawing functions */
void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
/* Extra Text Functions */ /* Extra Text Functions */
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT
void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color); void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);
void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor); void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);
void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify); void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify);
void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify); void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);
coord_t gdispGetFontMetric(font_t font, fontmetric_t metric); coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);
coord_t gdispGetCharWidth(char c, font_t font); coord_t gdispGetCharWidth(char c, font_t font);
coord_t gdispGetStringWidth(const char* str, font_t font); coord_t gdispGetStringWidth(const char* str, font_t font);
font_t gdispOpenFont(const char *name); font_t gdispOpenFont(const char *name);
void gdispCloseFont(font_t font); void gdispCloseFont(font_t font);
const char *gdispGetFontName(font_t font); const char *gdispGetFontName(font_t font);
#endif #endif
/* Extra Arc Functions */ /* Extra Arc Functions */
#if GDISP_NEED_ARC #if GDISP_NEED_ARC
void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color); void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color); void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
#endif #endif
/* Support routine for packed pixel formats */ /* Support routine for packed pixel formats */
#ifndef gdispPackPixels #ifndef gdispPackPixels
void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color); void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
#endif #endif
/* /*
* Macro definitions * Macro definitions
*/ */
/* Now obsolete functions */ /* Now obsolete functions */
#define gdispBlitArea(x, y, cx, cy, buffer) gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer) #define gdispBlitArea(x, y, cx, cy, buffer) gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer)
/* Macro definitions for common gets and sets */ /* Macro definitions for common gets and sets */
#define gdispSetPowerMode(powerMode) gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode)) #define gdispSetPowerMode(powerMode) gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))
#define gdispSetOrientation(newOrientation) gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation)) #define gdispSetOrientation(newOrientation) gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation))
#define gdispSetBacklight(percent) gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent)) #define gdispSetBacklight(percent) gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))
#define gdispSetContrast(percent) gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent)) #define gdispSetContrast(percent) gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))
#define gdispGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH)) #define gdispGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))
#define gdispGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT)) #define gdispGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))
#define gdispGetPowerMode() ((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER)) #define gdispGetPowerMode() ((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))
#define gdispGetOrientation() ((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) #define gdispGetOrientation() ((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))
#define gdispGetBacklight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT)) #define gdispGetBacklight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))
#define gdispGetContrast() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST)) #define gdispGetContrast() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))
/* More interesting macro's */ /* More interesting macro's */
#define gdispUnsetClip() gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight()) #define gdispUnsetClip() gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight())
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* GFX_USE_GDISP */ #endif /* GFX_USE_GDISP */
#endif /* _GDISP_H */ #endif /* _GDISP_H */
/** @} */ /** @} */

1544
include/gdisp/lld/emulation.c
View file

File diff suppressed because it is too large Load diff

1078
include/gdisp/lld/gdisp_lld.h
View file

File diff suppressed because it is too large Load diff

386
include/gdisp/lld/gdisp_lld_msgs.h
View file

@ -1,193 +1,193 @@
/* /*
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/gdisp/lld/gdisp_lld_msgs.h * @file include/gdisp/lld/gdisp_lld_msgs.h
* @brief GDISP Graphic Driver subsystem low level driver message structures. * @brief GDISP Graphic Driver subsystem low level driver message structures.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef _GDISP_LLD_MSGS_H #ifndef _GDISP_LLD_MSGS_H
#define _GDISP_LLD_MSGS_H #define _GDISP_LLD_MSGS_H
/* This file describes the message API for gdisp_lld */ /* This file describes the message API for gdisp_lld */
#if GFX_USE_GDISP && GDISP_NEED_MSGAPI #if GFX_USE_GDISP && GDISP_NEED_MSGAPI
typedef enum gdisp_msgaction { typedef enum gdisp_msgaction {
GDISP_LLD_MSG_NOP, GDISP_LLD_MSG_NOP,
GDISP_LLD_MSG_INIT, GDISP_LLD_MSG_INIT,
GDISP_LLD_MSG_CLEAR, GDISP_LLD_MSG_CLEAR,
GDISP_LLD_MSG_DRAWPIXEL, GDISP_LLD_MSG_DRAWPIXEL,
GDISP_LLD_MSG_FILLAREA, GDISP_LLD_MSG_FILLAREA,
GDISP_LLD_MSG_BLITAREA, GDISP_LLD_MSG_BLITAREA,
GDISP_LLD_MSG_DRAWLINE, GDISP_LLD_MSG_DRAWLINE,
#if GDISP_NEED_CLIP #if GDISP_NEED_CLIP
GDISP_LLD_MSG_SETCLIP, GDISP_LLD_MSG_SETCLIP,
#endif #endif
#if GDISP_NEED_CIRCLE #if GDISP_NEED_CIRCLE
GDISP_LLD_MSG_DRAWCIRCLE, GDISP_LLD_MSG_DRAWCIRCLE,
GDISP_LLD_MSG_FILLCIRCLE, GDISP_LLD_MSG_FILLCIRCLE,
#endif #endif
#if GDISP_NEED_ELLIPSE #if GDISP_NEED_ELLIPSE
GDISP_LLD_MSG_DRAWELLIPSE, GDISP_LLD_MSG_DRAWELLIPSE,
GDISP_LLD_MSG_FILLELLIPSE, GDISP_LLD_MSG_FILLELLIPSE,
#endif #endif
#if GDISP_NEED_ARC #if GDISP_NEED_ARC
GDISP_LLD_MSG_DRAWARC, GDISP_LLD_MSG_DRAWARC,
GDISP_LLD_MSG_FILLARC, GDISP_LLD_MSG_FILLARC,
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT
GDISP_LLD_MSG_DRAWCHAR, GDISP_LLD_MSG_DRAWCHAR,
GDISP_LLD_MSG_FILLCHAR, GDISP_LLD_MSG_FILLCHAR,
#endif #endif
#if GDISP_NEED_PIXELREAD #if GDISP_NEED_PIXELREAD
GDISP_LLD_MSG_GETPIXELCOLOR, GDISP_LLD_MSG_GETPIXELCOLOR,
#endif #endif
#if GDISP_NEED_SCROLL #if GDISP_NEED_SCROLL
GDISP_LLD_MSG_VERTICALSCROLL, GDISP_LLD_MSG_VERTICALSCROLL,
#endif #endif
#if GDISP_NEED_CONTROL #if GDISP_NEED_CONTROL
GDISP_LLD_MSG_CONTROL, GDISP_LLD_MSG_CONTROL,
#endif #endif
GDISP_LLD_MSG_QUERY, GDISP_LLD_MSG_QUERY,
} gdisp_msgaction_t; } gdisp_msgaction_t;
typedef union gdisp_lld_msg { typedef union gdisp_lld_msg {
gdisp_msgaction_t action; gdisp_msgaction_t action;
struct gdisp_lld_msg_init { struct gdisp_lld_msg_init {
gdisp_msgaction_t action; // GDISP_LLD_MSG_INIT gdisp_msgaction_t action; // GDISP_LLD_MSG_INIT
} init; } init;
struct gdisp_lld_msg_clear { struct gdisp_lld_msg_clear {
gdisp_msgaction_t action; // GDISP_LLD_MSG_CLEAR gdisp_msgaction_t action; // GDISP_LLD_MSG_CLEAR
color_t color; color_t color;
} clear; } clear;
struct gdisp_lld_msg_drawpixel { struct gdisp_lld_msg_drawpixel {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWPIXEL gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWPIXEL
coord_t x, y; coord_t x, y;
color_t color; color_t color;
} drawpixel; } drawpixel;
struct gdisp_lld_msg_fillarea { struct gdisp_lld_msg_fillarea {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLAREA gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLAREA
coord_t x, y; coord_t x, y;
coord_t cx, cy; coord_t cx, cy;
color_t color; color_t color;
} fillarea; } fillarea;
struct gdisp_lld_msg_blitarea { struct gdisp_lld_msg_blitarea {
gdisp_msgaction_t action; // GDISP_LLD_MSG_BLITAREA gdisp_msgaction_t action; // GDISP_LLD_MSG_BLITAREA
coord_t x, y; coord_t x, y;
coord_t cx, cy; coord_t cx, cy;
coord_t srcx, srcy; coord_t srcx, srcy;
coord_t srccx; coord_t srccx;
const pixel_t *buffer; const pixel_t *buffer;
} blitarea; } blitarea;
struct gdisp_lld_msg_setclip { struct gdisp_lld_msg_setclip {
gdisp_msgaction_t action; // GDISP_LLD_MSG_SETCLIP gdisp_msgaction_t action; // GDISP_LLD_MSG_SETCLIP
coord_t x, y; coord_t x, y;
coord_t cx, cy; coord_t cx, cy;
} setclip; } setclip;
struct gdisp_lld_msg_drawline { struct gdisp_lld_msg_drawline {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWLINE gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWLINE
coord_t x0, y0; coord_t x0, y0;
coord_t x1, y1; coord_t x1, y1;
color_t color; color_t color;
} drawline; } drawline;
struct gdisp_lld_msg_drawcircle { struct gdisp_lld_msg_drawcircle {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCIRCLE gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCIRCLE
coord_t x, y; coord_t x, y;
coord_t radius; coord_t radius;
color_t color; color_t color;
} drawcircle; } drawcircle;
struct gdisp_lld_msg_fillcircle { struct gdisp_lld_msg_fillcircle {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCIRCLE gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCIRCLE
coord_t x, y; coord_t x, y;
coord_t radius; coord_t radius;
color_t color; color_t color;
} fillcircle; } fillcircle;
struct gdisp_lld_msg_drawellipse { struct gdisp_lld_msg_drawellipse {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWELLIPSE gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWELLIPSE
coord_t x, y; coord_t x, y;
coord_t a, b; coord_t a, b;
color_t color; color_t color;
} drawellipse; } drawellipse;
struct gdisp_lld_msg_fillellipse { struct gdisp_lld_msg_fillellipse {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLELLIPSE gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLELLIPSE
coord_t x, y; coord_t x, y;
coord_t a, b; coord_t a, b;
color_t color; color_t color;
} fillellipse; } fillellipse;
struct gdisp_lld_msg_drawarc { struct gdisp_lld_msg_drawarc {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWARC gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWARC
coord_t x, y; coord_t x, y;
coord_t radius; coord_t radius;
coord_t startangle, endangle; coord_t startangle, endangle;
color_t color; color_t color;
} drawcircle; } drawarc;
struct gdisp_lld_msg_fillarc { struct gdisp_lld_msg_fillarc {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLARC gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLARC
coord_t x, y; coord_t x, y;
coord_t radius; coord_t radius;
coord_t startangle, endangle; coord_t startangle, endangle;
color_t color; color_t color;
} fillcircle; } fillarc;
struct gdisp_lld_msg_drawchar { struct gdisp_lld_msg_drawchar {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCHAR gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCHAR
coord_t x, y; coord_t x, y;
char c; char c;
font_t font; font_t font;
color_t color; color_t color;
} drawchar; } drawchar;
struct gdisp_lld_msg_fillchar { struct gdisp_lld_msg_fillchar {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCHAR gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCHAR
coord_t x, y; coord_t x, y;
char c; char c;
font_t font; font_t font;
color_t color; color_t color;
color_t bgcolor; color_t bgcolor;
} fillchar; } fillchar;
struct gdisp_lld_msg_getpixelcolor { struct gdisp_lld_msg_getpixelcolor {
gdisp_msgaction_t action; // GDISP_LLD_MSG_GETPIXELCOLOR gdisp_msgaction_t action; // GDISP_LLD_MSG_GETPIXELCOLOR
coord_t x, y; coord_t x, y;
color_t result; color_t result;
} getpixelcolor; } getpixelcolor;
struct gdisp_lld_msg_verticalscroll { struct gdisp_lld_msg_verticalscroll {
gdisp_msgaction_t action; // GDISP_LLD_MSG_VERTICALSCROLL gdisp_msgaction_t action; // GDISP_LLD_MSG_VERTICALSCROLL
coord_t x, y; coord_t x, y;
coord_t cx, cy; coord_t cx, cy;
int lines; int lines;
color_t bgcolor; color_t bgcolor;
} verticalscroll; } verticalscroll;
struct gdisp_lld_msg_control { struct gdisp_lld_msg_control {
gdisp_msgaction_t action; // GDISP_LLD_MSG_CONTROL gdisp_msgaction_t action; // GDISP_LLD_MSG_CONTROL
int what; int what;
void * value; void * value;
} control; } control;
struct gdisp_lld_msg_query { struct gdisp_lld_msg_query {
gdisp_msgaction_t action; // GDISP_LLD_MSG_QUERY gdisp_msgaction_t action; // GDISP_LLD_MSG_QUERY
int what; int what;
void * result; void * result;
} query; } query;
} gdisp_lld_msg_t; } gdisp_lld_msg_t;
#endif /* GFX_USE_GDISP && GDISP_NEED_MSGAPI */ #endif /* GFX_USE_GDISP && GDISP_NEED_MSGAPI */
#endif /* _GDISP_LLD_MSGS_H */ #endif /* _GDISP_LLD_MSGS_H */
/** @} */ /** @} */

264
include/gfx_rules.h
View file

@ -1,128 +1,136 @@
/* /*
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_rules.h * @file include/gfx_rules.h
* @brief GFX system safety rules header file. * @brief GFX system safety rules header file.
* *
* @addtogroup GFX * @addtogroup GFX
* @{ * @{
*/ */
#ifndef _GFX_RULES_H #ifndef _GFX_RULES_H
#define _GFX_RULES_H #define _GFX_RULES_H
/** /**
* Safety checks on all the defines. * Safety checks on all the defines.
* *
* These are defined in the order of their inter-dependancies. * These are defined in the order of their inter-dependancies.
*/ */
#if GFX_USE_GWIN #if GFX_USE_GWIN
#if !GFX_USE_GDISP #if !GFX_USE_GDISP
#error "GWIN: GFX_USE_GDISP must be TRUE when using GWIN" #error "GWIN: GFX_USE_GDISP must be TRUE when using GWIN"
#endif #endif
#if !GDISP_NEED_CLIP #if !GDISP_NEED_CLIP
#warning "GWIN: Drawing can occur outside the defined windows as GDISP_NEED_CLIP is FALSE" #warning "GWIN: Drawing can occur outside the defined windows as GDISP_NEED_CLIP is FALSE"
#endif #endif
#if GWIN_NEED_BUTTON #if GWIN_NEED_BUTTON
#if !GDISP_NEED_TEXT #if !GDISP_NEED_TEXT
#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_BUTTON is TRUE." #error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_BUTTON is TRUE."
#endif #endif
#if !GFX_USE_GEVENT #if !GFX_USE_GEVENT
#warning "GWIN: GFX_USE_GEVENT is required if GWIN_NEED_BUTTON is TRUE. It has been turned on for you." #warning "GWIN: GFX_USE_GEVENT is required if GWIN_NEED_BUTTON is TRUE. It has been turned on for you."
#undef GFX_USE_GEVENT #undef GFX_USE_GEVENT
#define GFX_USE_GEVENT TRUE #define GFX_USE_GEVENT TRUE
#endif #endif
#if !GFX_USE_GINPUT || !(GINPUT_NEED_MOUSE || GINPUT_NEED_TOGGLE) #if !GFX_USE_GINPUT || !(GINPUT_NEED_MOUSE || GINPUT_NEED_TOGGLE)
#warning "GWIN: You have set GWIN_NEED_BUTTON to TRUE but no supported GINPUT (mouse/toggle) devices have been included" #warning "GWIN: You have set GWIN_NEED_BUTTON to TRUE but no supported GINPUT (mouse/toggle) devices have been included"
#endif #endif
#if !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC #if !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC
#warning "GWIN: Either GDISP_NEED_MULTITHREAD or GDISP_NEED_ASYNC is required if GWIN_NEED_BUTTON is TRUE." #warning "GWIN: Either GDISP_NEED_MULTITHREAD or GDISP_NEED_ASYNC is required if GWIN_NEED_BUTTON is TRUE."
#warning "GWIN: GDISP_NEED_MULTITHREAD has been turned on for you." #warning "GWIN: GDISP_NEED_MULTITHREAD has been turned on for you."
#undef GDISP_NEED_MULTITHREAD #undef GDISP_NEED_MULTITHREAD
#define GDISP_NEED_MULTITHREAD TRUE #define GDISP_NEED_MULTITHREAD TRUE
#endif #endif
#endif #endif
#if GWIN_NEED_CONSOLE #if GWIN_NEED_CONSOLE
#if !GDISP_NEED_TEXT #if !GDISP_NEED_TEXT
#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_CONSOLE is TRUE." #error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_CONSOLE is TRUE."
#endif #endif
#endif #endif
#if GWIN_NEED_GRAPH #if GWIN_NEED_GRAPH
#endif #endif
#endif #endif
#if GFX_USE_GINPUT #if GFX_USE_GINPUT
#if !GFX_USE_GEVENT #if !GFX_USE_GEVENT
#warning "GINPUT: GFX_USE_GEVENT is required if GFX_USE_GINPUT is TRUE. It has been turned on for you." #warning "GINPUT: GFX_USE_GEVENT is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."
#undef GFX_USE_GEVENT #undef GFX_USE_GEVENT
#define GFX_USE_GEVENT TRUE #define GFX_USE_GEVENT TRUE
#endif #endif
#if !GFX_USE_GTIMER #if !GFX_USE_GTIMER
#warning "GINPUT: GFX_USE_GTIMER is required if GFX_USE_GINPUT is TRUE. It has been turned on for you." #warning "GINPUT: GFX_USE_GTIMER is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."
#undef GFX_USE_GTIMER #undef GFX_USE_GTIMER
#define GFX_USE_GTIMER TRUE #define GFX_USE_GTIMER TRUE
#endif #endif
#endif #endif
#if GFX_USE_GDISP #if GFX_USE_GDISP
#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC #if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC
#error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined." #error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined."
#endif #endif
#if GDISP_NEED_ASYNC #if GDISP_NEED_ASYNC
#if !GDISP_NEED_MSGAPI #if !GDISP_NEED_MSGAPI
#warning "GDISP: Messaging API is required for Async Multi-Thread. It has been turned on for you." #warning "GDISP: Messaging API is required for Async Multi-Thread. It has been turned on for you."
#undef GDISP_NEED_MSGAPI #undef GDISP_NEED_MSGAPI
#define GDISP_NEED_MSGAPI TRUE #define GDISP_NEED_MSGAPI TRUE
#endif #endif
#endif #endif
#endif #endif
#if GFX_USE_TDISP #if GFX_USE_TDISP
#endif #endif
#if GFX_USE_GEVENT #if GFX_USE_GADC
#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES #if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
#error "GEVENT: 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"
#endif #endif
#endif #if !GFX_USE_GTIMER
#warning "GADC: GFX_USE_GTIMER is required if GFX_USE_GADC is TRUE. It has been turned on for you."
#if GFX_USE_GTIMER #undef GFX_USE_GTIMER
#if GFX_USE_GDISP && !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC #define GFX_USE_GTIMER TRUE
#warning "GTIMER: Neither GDISP_NEED_MULTITHREAD nor GDISP_NEED_ASYNC has been specified." #endif
#warning "GTIMER: Make sure you are not performing any GDISP/GWIN drawing operations in the timer callback!" #endif
#endif
#endif #if GFX_USE_GEVENT
#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
#if GFX_USE_GAUDIN #error "GEVENT: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
#endif #endif
#endif
#if GFX_USE_GAUDOUT
#endif #if GFX_USE_GTIMER
#if GFX_USE_GDISP && !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC
#if GFX_USE_GADC #warning "GTIMER: Neither GDISP_NEED_MULTITHREAD nor GDISP_NEED_ASYNC has been specified."
#endif #warning "GTIMER: Make sure you are not performing any GDISP/GWIN drawing operations in the timer callback!"
#endif
#if GFX_USE_GMISC #endif
#endif
#if GFX_USE_GAUDIN
#endif /* _GFX_H */ #endif
/** @} */
#if GFX_USE_GAUDOUT
#endif
#if GFX_USE_GMISC
#endif
#endif /* _GFX_H */
/** @} */

503
src/gadc/gadc.c
View file

@ -1,38 +1,465 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012 ChibiOS/GFX - Copyright (C) 2012, 2013
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/gadc/gadc.c * @file src/gadc/gadc.c
* @brief GADC sub-system code. * @brief GADC sub-system code.
* *
* @addtogroup GADC * @addtogroup GADC
* @{ * @{
*/ */
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GADC || defined(__DOXYGEN__) #if GFX_USE_GADC
#error "GADC: Not implemented yet" /* Include the driver defines */
#include "gadc/lld/gadc_lld.h"
#endif /* GFX_USE_GADC */
/** @} */ #if GADC_MAX_HIGH_SPEED_SAMPLERATE > GADC_MAX_SAMPLE_FREQUENCY/2
#error "GADC: GADC_MAX_HIGH_SPEED_SAMPLERATE has been set too high. It must be less than half the maximum CPU rate"
#endif
#define GADC_MAX_LOWSPEED_DEVICES ((GADC_MAX_SAMPLE_FREQUENCY/GADC_MAX_HIGH_SPEED_SAMPLERATE)-1)
#if GADC_MAX_LOWSPEED_DEVICES > 4
#undef GADC_MAX_LOWSPEED_DEVICES
#define GADC_MAX_LOWSPEED_DEVICES 4
#endif
volatile bool_t GADC_Timer_Missed;
static SEMAPHORE_DECL(gadcsem, GADC_MAX_LOWSPEED_DEVICES);
static MUTEX_DECL(gadcmutex);
static GTIMER_DECL(LowSpeedGTimer);
#if GFX_USE_GEVENT
static GTIMER_DECL(HighSpeedGTimer);
#endif
static volatile uint16_t gflags = 0;
#define GADC_GFLG_INITDONE 0x0001
#define GADC_GFLG_ISACTIVE 0x0002
#define GADC_FLG_ISACTIVE 0x0001
#define GADC_FLG_ISDONE 0x0002
#define GADC_FLG_ERROR 0x0004
#define GADC_FLG_GTIMER 0x0008
static struct hsdev {
// Our status flags
uint16_t flags;
// What we started with
uint32_t frequency;
adcsample_t *buffer;
size_t bufcount;
size_t samplesPerEvent;
// The last set of results
size_t lastcount;
adcsample_t *lastbuffer;
uint16_t lastflags;
// Other stuff we need to track progress and for signalling
GadcLldTimerData lld;
size_t samplesPerConversion;
size_t remaining;
BinarySemaphore *bsem;
GEventADC *pEvent;
} hs;
static struct lsdev {
// Our status flags
uint16_t flags;
// What we started with
GadcLldNonTimerData lld;
GADCCallbackFunction fn;
void *param;
} ls[GADC_MAX_LOWSPEED_DEVICES];
static struct lsdev *curlsdev;
/* Find the next conversion to activate */
static __inline void FindNextConversionI(void) {
if (curlsdev) {
/**
* Now we have done a low speed conversion - start looking for the next conversion
* We only look forward to ensure we get a high speed conversion at least once
* every GADC_MAX_LOWSPEED_DEVICES conversions.
*/
curlsdev++;
} else {
/* Now we have done a high speed conversion - start looking for low speed conversions */
curlsdev = ls;
}
/**
* Look for the next thing to do.
*/
while(curlsdev < &ls[GADC_MAX_LOWSPEED_DEVICES]) {
if ((curlsdev->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == GADC_FLG_ISACTIVE) {
gadc_lld_adc_nontimerI(&curlsdev->lld);
return;
}
curlsdev++;
}
curlsdev = 0;
/* No more low speed devices - do a high speed conversion */
if (hs.flags & GADC_FLG_ISACTIVE) {
hs.lld.now = GADC_Timer_Missed ? TRUE : FALSE;
GADC_Timer_Missed = 0;
gadc_lld_adc_timerI(&hs.lld);
return;
}
/* Nothing more to do */
gflags &= ~GADC_GFLG_ISACTIVE;
}
void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
(void) adcp;
if (curlsdev) {
/* This interrupt must be in relation to the low speed device */
if (curlsdev->flags & GADC_FLG_ISACTIVE) {
/**
* As we only handle a single low speed conversion at a time, we know
* we know we won't get any half completion interrupts.
*/
curlsdev->flags |= GADC_FLG_ISDONE;
gtimerJabI(&LowSpeedGTimer);
}
#if ADC_ISR_FULL_CODE_BUG
/**
* Oops - We have just finished a low speed conversion but a bug prevents us
* restarting the ADC here. Other code will restart it in the thread based
* ADC handler.
*/
gflags &= ~GADC_GFLG_ISACTIVE;
return;
#endif
} else {
/* This interrupt must be in relation to the high speed device */
if (hs.flags & GADC_FLG_ISACTIVE) {
/* Save the details */
hs.lastcount = n;
hs.lastbuffer = buffer;
hs.lastflags = GADC_Timer_Missed ? GADC_HSADC_LOSTEVENT : 0;
/* Signal the user with the data */
if (hs.pEvent) {
#if GFX_USE_GEVENT
hs.pEvent->type = GEVENT_ADC;
#endif
hs.pEvent->count = hs.lastcount;
hs.pEvent->buffer = hs.lastbuffer;
hs.pEvent->flags = hs.lastflags;
}
if (hs.bsem)
chBSemSignalI(hs.bsem);
#if GFX_USE_GEVENT
if (hs.flags & GADC_FLG_GTIMER)
gtimerJabI(&HighSpeedGTimer);
#endif
/* Adjust what we have left to do */
hs.lld.count -= n;
hs.remaining -= n;
/* Half completion - We have done all we can for now - wait for the next interrupt */
if (hs.lld.count)
return;
/* Our buffer is cyclic - set up the new buffer pointers */
if (hs.remaining) {
hs.lld.buffer = buffer + (n * hs.samplesPerConversion);
} else {
hs.remaining = hs.bufcount;
hs.lld.buffer = hs.buffer;
}
hs.lld.count = hs.remaining < hs.samplesPerEvent ? hs.remaining : hs.samplesPerEvent;
}
}
/**
* Look for the next thing to do.
*/
FindNextConversionI();
}
void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err) {
(void) adcp;
(void) err;
if (curlsdev) {
if ((curlsdev->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == GADC_FLG_ISACTIVE)
/* Mark the error then try to repeat it */
curlsdev->flags |= GADC_FLG_ERROR;
#if ADC_ISR_FULL_CODE_BUG
/**
* Oops - We have just finished a low speed conversion but a bug prevents us
* restarting the ADC here. Other code will restart it in the thread based
* ADC handler.
*/
gflags &= ~GADC_GFLG_ISACTIVE;
gtimerJabI(&LowSpeedGTimer);
return;
#endif
} else {
if (hs.flags & GADC_FLG_ISACTIVE)
/* Mark the error and then try to repeat it */
hs.flags |= GADC_FLG_ERROR;
}
/* Start the next conversion */
FindNextConversionI();
}
static __inline void DoInit(void) {
if (!(gflags & GADC_GFLG_INITDONE)) {
gflags |= GADC_GFLG_INITDONE;
gadc_lld_init();
}
}
static __inline void StartADC(bool_t onNoHS) {
chSysLock();
if (!(gflags & GADC_GFLG_ISACTIVE) || (onNoHS && !curlsdev))
FindNextConversionI();
chSysUnlock();
}
static void BSemSignalCallback(adcsample_t *buffer, void *param) {
(void) buffer;
/* Signal the BinarySemaphore parameter */
chBSemSignal((BinarySemaphore *)param);
}
#if GFX_USE_GEVENT
static void HighSpeedGTimerCallback(void *param) {
(void) param;
GSourceListener *psl;
GEventADC *pe;
psl = 0;
while ((psl = geventGetSourceListener((GSourceHandle)(&HighSpeedGTimer), psl))) {
if (!(pe = (GEventADC *)geventGetEventBuffer(psl))) {
// This listener is missing - save this.
psl->srcflags |= GADC_HSADC_LOSTEVENT;
continue;
}
pe->type = GEVENT_ADC;
pe->count = hs.lastcount;
pe->buffer = hs.lastbuffer;
pe->flags = hs.lastflags | psl->srcflags;
psl->srcflags = 0;
geventSendEvent(psl);
}
}
#endif
static void LowSpeedGTimerCallback(void *param) {
(void) param;
GADCCallbackFunction fn;
void *prm;
adcsample_t *buffer;
struct lsdev *p;
#if ADC_ISR_FULL_CODE_BUG
/* Ensure the ADC is running if it needs to be - Bugfix HACK */
StartADC(FALSE);
#endif
/**
* Look for completed low speed timers.
* We don't need to take the mutex as we are the only place that things are freed and we
* do that atomically.
*/
for(p=ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
if ((p->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) {
/* This item is done - perform its callback */
fn = p->fn; // Save the callback details
prm = p->param;
buffer = p->lld.buffer;
p->fn = 0; // Needed to prevent the compiler removing the local variables
p->param = 0; // Needed to prevent the compiler removing the local variables
p->lld.buffer = 0; // Needed to prevent the compiler removing the local variables
p->flags = 0; // The slot is available (indivisible operation)
chSemSignal(&gadcsem); // Tell everyone
fn(buffer, prm); // Perform the callback
}
}
}
void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent)
{
gadcHighSpeedStop(); /* This does the init for us */
/* Just save the details and reset everything for now */
hs.frequency = frequency;
hs.buffer = buffer;
hs.bufcount = bufcount;
hs.samplesPerEvent = samplesPerEvent;
hs.lastcount = 0;
hs.lastbuffer = 0;
hs.lastflags = 0;
hs.lld.physdev = physdev;
hs.lld.buffer = buffer;
hs.lld.count = samplesPerEvent;
hs.lld.now = FALSE;
hs.samplesPerConversion = gadc_lld_samples_per_conversion(physdev);
hs.remaining = bufcount;
hs.bsem = 0;
hs.pEvent = 0;
}
#if GFX_USE_GEVENT
GSourceHandle gadcHighSpeedGetSource(void) {
DoInit();
if (!gtimerIsActive(&HighSpeedGTimer))
gtimerStart(&HighSpeedGTimer, HighSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
hs.flags |= GADC_FLG_GTIMER;
return (GSourceHandle)&HighSpeedGTimer;
}
#endif
void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent) {
DoInit();
/* Use the system lock to ensure they occur atomically */
chSysLock();
hs.pEvent = pEvent;
hs.bsem = pbsem;
chSysUnlock();
}
void gadcHighSpeedStart(void) {
DoInit();
/* If its already going we don't need to do anything */
if (hs.flags & GADC_FLG_ISACTIVE)
return;
gadc_lld_start_timer(hs.lld.physdev, hs.frequency);
hs.flags = GADC_FLG_ISACTIVE;
StartADC(FALSE);
}
void gadcHighSpeedStop(void) {
DoInit();
if (hs.flags & GADC_FLG_ISACTIVE) {
/* No more from us */
hs.flags = 0;
gadc_lld_stop_timer(hs.lld.physdev);
/*
* We have to pass TRUE to StartADC() as we might have the ADC marked as active when it isn't
* due to stopping the timer while it was converting.
*/
StartADC(TRUE);
}
}
void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer) {
struct lsdev *p;
BSEMAPHORE_DECL(mysem, TRUE);
/* Start the Low Speed Timer */
chMtxLock(&gadcmutex);
if (!gtimerIsActive(&LowSpeedGTimer))
gtimerStart(&LowSpeedGTimer, LowSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
chMtxUnlock();
while(1) {
/* Wait for an available slot */
chSemWait(&gadcsem);
/* Find a slot */
chMtxLock(&gadcmutex);
for(p = ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
if (!(p->flags & GADC_FLG_ISACTIVE)) {
p->lld.physdev = physdev;
p->lld.buffer = buffer;
p->fn = BSemSignalCallback;
p->param = &mysem;
p->flags = GADC_FLG_ISACTIVE;
chMtxUnlock();
StartADC(FALSE);
chBSemWait(&mysem);
return;
}
}
chMtxUnlock();
/**
* We should never get here - the count semaphore must be wrong.
* Decrement it and try again.
*/
}
}
bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param) {
struct lsdev *p;
DoInit();
/* Start the Low Speed Timer */
chMtxLock(&gadcmutex);
if (!gtimerIsActive(&LowSpeedGTimer))
gtimerStart(&LowSpeedGTimer, LowSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
/* Find a slot */
for(p = ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
if (!(p->flags & GADC_FLG_ISACTIVE)) {
/* We know we have a slot - this should never wait anyway */
chSemWaitTimeout(&gadcsem, TIME_IMMEDIATE);
p->lld.physdev = physdev;
p->lld.buffer = buffer;
p->fn = fn;
p->param = param;
p->flags = GADC_FLG_ISACTIVE;
chMtxUnlock();
StartADC(FALSE);
return TRUE;
}
}
chMtxUnlock();
return FALSE;
}
#endif /* GFX_USE_GADC */
/** @} */

2536
src/gdisp/gdisp.c
View file

File diff suppressed because it is too large Load diff

8
src/gwin/gwin.mk
View file

@ -1,5 +1,5 @@
GFXSRC += $(GFXLIB)/src/gwin/gwin.c \ GFXSRC += $(GFXLIB)/src/gwin/gwin.c \
$(GFXLIB)/src/gwin/console.c \ $(GFXLIB)/src/gwin/console.c \
$(GFXLIB)/src/gwin/button.c \ $(GFXLIB)/src/gwin/button.c \
$(GFXLIB)/src/gwin/graph.c $(GFXLIB)/src/gwin/graph.c