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 */
/** @} */

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

@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
}
static __inline void lld_lcdWriteIndex(uint16_t index) {
lld_gdisp_write_index(index);
gdisp_lld_write_index(index);
}
static __inline void lld_lcdWriteData(uint16_t data) {
lld_gdisp_write_data(data);
gdisp_lld_write_data(data);
}
static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
lld_gdisp_write_index(lcdReg);
lld_gdisp_write_data(lcdRegValue);
gdisp_lld_write_index(lcdReg);
gdisp_lld_write_data(lcdRegValue);
}
static __inline uint16_t lld_lcdReadData(void) {
/* fix this! */
//return lld_gdisp_read_data;
//return gdisp_lld_read_data;
return GDISP_RAM;
}
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
volatile uint16_t dummy;
lld_gdisp_write_index(lcdReg);
gdisp_lld_write_index(lcdReg);
dummy = lld_lcdReadData();
(void)dummy;
@ -143,14 +143,14 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
buffer[i] = lld_lcdReadData();
}
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise your display */
lld_gdisp_init_board();
gdisp_lld_init_board();
/* Hardware reset */
lld_gdisp_reset_pin(TRUE);
gdisp_lld_reset_pin(TRUE);
lld_lcdDelay(1000);
lld_gdisp_reset_pin(FALSE);
gdisp_lld_reset_pin(FALSE);
lld_lcdDelay(1000);
DISPLAY_CODE = lld_lcdReadReg(0);
@ -215,7 +215,7 @@ bool_t lld_gdisp_init(void) {
lld_lcdWriteReg(0x0007, 0x0173); //display On
// Turn on the backlight
lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
gdisp_lld_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
@ -298,7 +298,7 @@ static __inline void lld_lcdResetViewPort(void) {
}
}
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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -307,7 +307,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
}
#if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)
void lld_gdisp_clear(color_t color) {
void gdisp_lld_clear(color_t color) {
unsigned i;
lld_lcdSetCursor(0, 0);
@ -321,7 +321,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
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) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@ -343,7 +343,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
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;
unsigned lg;
@ -372,7 +372,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
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) {
color_t color;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -392,7 +392,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
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) {
static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
coord_t row0, row1;
unsigned i, gap, abslines;
@ -445,7 +445,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_POWER:
if(GDISP.Powermode == (gdisp_powermode_t)value)
@ -457,7 +457,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0011, 0x0000);
lld_lcdWriteReg(0x0012, 0x0000);
lld_lcdWriteReg(0x0013, 0x0000);
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
case powerOn:
@ -476,9 +476,9 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
lld_lcdDelay(500);
lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */
lld_gdisp_backlight(GDISP.Backlight);
gdisp_lld_backlight(GDISP.Backlight);
if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
lld_gdisp_init();
gdisp_lld_init();
break;
case powerSleep:
@ -489,7 +489,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
case powerDeepSleep:
@ -500,7 +500,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
default:
@ -554,7 +554,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
case GDISP_CONTROL_BACKLIGHT:
if((unsigned)value > 100) value = (void *)100;
lld_gdisp_backlight((unsigned)value);
gdisp_lld_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value;
break;

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

@ -29,28 +29,28 @@
#ifndef 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"
}
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"
}
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"
}
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"
}
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"
}
/* 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"
}

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

@ -32,7 +32,7 @@
#define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#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 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
@ -54,26 +54,26 @@ static __inline void lld_gdisp_init_board(void) {
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)
palClearPad(GPIOE, GPIOE_TFT_RST);
else
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;
}
static __inline void lld_gdisp_write_data(uint16_t data) {
static __inline void gdisp_lld_write_data(uint16_t 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;
}
static __inline void lld_gdisp_backlight(uint8_t percent) {
static __inline void gdisp_lld_backlight(uint8_t percent) {
if(percent == 100)
palClearPad(GPIOD, GPIOD_TFT_LIGHT);
else

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

@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
}
static __inline void lld_lcdWriteIndex(uint16_t index) {
lld_gdisp_write_index(index);
gdisp_lld_write_index(index);
}
static __inline void lld_lcdWriteData(uint16_t data) {
lld_gdisp_write_data(data);
gdisp_lld_write_data(data);
}
static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
lld_gdisp_write_index(lcdReg);
lld_gdisp_write_data(lcdRegValue);
gdisp_lld_write_index(lcdReg);
gdisp_lld_write_data(lcdRegValue);
}
static __inline uint16_t lld_lcdReadData(void) {
/* fix this! */
//return lld_gdisp_read_data;
//return gdisp_lld_read_data;
return GDISP_RAM;
}
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
volatile uint16_t dummy;
lld_gdisp_write_index(lcdReg);
gdisp_lld_write_index(lcdReg);
dummy = lld_lcdReadData();
(void)dummy;
@ -143,14 +143,14 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
buffer[i] = lld_lcdReadData();
}
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise your display */
lld_gdisp_init_board();
gdisp_lld_init_board();
/* Hardware reset */
lld_gdisp_reset_pin(TRUE);
gdisp_lld_reset_pin(TRUE);
lld_lcdDelay(1000);
lld_gdisp_reset_pin(FALSE);
gdisp_lld_reset_pin(FALSE);
lld_lcdDelay(1000);
// chinese code starts here
@ -210,7 +210,7 @@ bool_t lld_gdisp_init(void) {
// chinese code ends here
// Turn on the backlight
lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
gdisp_lld_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
@ -302,7 +302,7 @@ static __inline void lld_lcdResetViewPort(void) {
}
}
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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -311,7 +311,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
}
#if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)
void lld_gdisp_clear(color_t color) {
void gdisp_lld_clear(color_t color) {
unsigned i;
lld_lcdSetCursor(0, 0);
@ -325,7 +325,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
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) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@ -347,7 +347,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
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;
unsigned lg;
@ -376,7 +376,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
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) {
color_t color;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -396,7 +396,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
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) {
static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
coord_t row0, row1;
unsigned i, gap, abslines;
@ -449,7 +449,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
#endif
#if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_POWER:
if(GDISP.Powermode == (gdisp_powermode_t)value)
@ -461,7 +461,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0011, 0x0000);
lld_lcdWriteReg(0x0012, 0x0000);
lld_lcdWriteReg(0x0013, 0x0000);
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
case powerOn:
@ -480,9 +480,9 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
lld_lcdDelay(500);
lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */
lld_gdisp_backlight(GDISP.Backlight);
gdisp_lld_backlight(GDISP.Backlight);
if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
lld_gdisp_init();
gdisp_lld_init();
break;
case powerSleep:
@ -493,7 +493,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
case powerDeepSleep:
@ -504,7 +504,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
lld_gdisp_backlight(0);
gdisp_lld_backlight(0);
break;
default:
@ -564,7 +564,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
case GDISP_CONTROL_BACKLIGHT:
if((unsigned)value > 100) value = (void *)100;
lld_gdisp_backlight((unsigned)value);
gdisp_lld_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value;
break;

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

@ -29,28 +29,28 @@
#ifndef 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"
}
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"
}
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"
}
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"
}
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"
}
/* 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"
}

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

@ -45,7 +45,7 @@
#define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#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 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
@ -68,26 +68,26 @@ static __inline void lld_gdisp_init_board(void) {
}
static __inline void lld_gdisp_reset_pin(bool_t state) {
static __inline void gdisp_lld_reset_pin(bool_t state) {
if(state)
palClearPad(GPIOE, GPIOE_TFT_RST);
else
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;
}
static __inline void lld_gdisp_write_data(uint16_t data) {
static __inline void gdisp_lld_write_data(uint16_t 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;
}
static __inline void lld_gdisp_backlight(uint8_t percent) {
static __inline void gdisp_lld_backlight(uint8_t percent) {
percent=percent; // avoid a warning
}

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

@ -113,7 +113,7 @@ static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise your display */
init_board();
@ -219,7 +219,7 @@ bool_t lld_gdisp_init(void) {
*
* @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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -241,7 +241,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -276,7 +276,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
color_t c1, c2;
#if GDISP_PACKED_PIXELS
@ -386,7 +386,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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 */
/* Some board hardware might support this in the future.
* The Olimex board doesn't.
@ -407,7 +407,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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 */
/* The hardware seems capable of doing this.
* It is just really complex so we leave it out for now.
@ -435,7 +435,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
/* The hardware is capable of supporting...
* GDISP_CONTROL_POWER - not implemented yet
* GDISP_CONTROL_ORIENTATION - not implemented yet
@ -456,7 +456,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
// Code here
/* You may need this ---
* if (GDISP.Powermode != powerSleep)
* lld_gdisp_init();
* gdisp_lld_init();
*/
break;
case powerSleep:

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

@ -112,7 +112,7 @@ static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise your display */
init_board();
@ -174,7 +174,7 @@ bool_t lld_gdisp_init(void) {
*
* @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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -196,7 +196,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -231,7 +231,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
color_t c1, c2;
#if GDISP_PACKED_PIXELS
@ -341,7 +341,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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 */
/* Some board hardware might support this in the future.
* The Olimex board doesn't.
@ -362,7 +362,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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 */
/* The hardware seems capable of doing this.
* It is just really complex so we leave it out for now.
@ -390,7 +390,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
/* The hardware is capable of supporting...
* GDISP_CONTROL_POWER - not implemented yet
* GDISP_CONTROL_ORIENTATION - not implemented yet
@ -411,7 +411,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
// Code here
/* You may need this ---
* if (GDISP.Powermode != powerSleep)
* lld_gdisp_init();
* gdisp_lld_init();
*/
break;
case powerSleep:

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

@ -150,7 +150,7 @@ static __inline void reset_viewport(void) {
}
}
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* initialize the hardware */
init_board();
@ -255,7 +255,7 @@ bool_t lld_gdisp_init(void) {
*
* @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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -277,7 +277,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_clear(color_t color) {
void gdisp_lld_clear(color_t color) {
unsigned i;
acquire_bus();
@ -303,7 +303,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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, area;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -339,7 +339,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
unsigned lg;
@ -379,7 +379,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
/* This routine is marked "DO NOT USE" in the original
* GLCD driver. We just keep our GDISP_HARDWARE_READPIXEL
* turned off for now.
@ -418,7 +418,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
/* This is marked as "TODO: Test this" in the original GLCD driver.
* For now we just leave the GDISP_HARDWARE_SCROLL off.
*/
@ -495,7 +495,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_POWER:
if (GDISP.Powermode == (gdisp_powermode_t)value)
@ -508,7 +508,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
/* Code here */
/* You may need this ---
if (GDISP.Powermode != powerSleep)
lld_gdisp_init();
gdisp_lld_init();
*/
/* break; */
case powerSleep:

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

@ -157,7 +157,7 @@ static __inline void reset_viewport(void) {
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise your display */
init_board();
@ -243,7 +243,7 @@ bool_t lld_gdisp_init(void) {
*
* @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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -280,7 +280,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_clear(color_t color) {
void gdisp_lld_clear(color_t color) {
unsigned i;
acquire_bus();
@ -305,7 +305,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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, area;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -341,7 +341,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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;
unsigned lg;
@ -380,7 +380,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
color_t color;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -413,7 +413,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
coord_t row0, row1;
unsigned i, gap, abslines, j;
@ -489,7 +489,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_POWER:
if (GDISP.Powermode == (gdisp_powermode_t)value)
@ -508,7 +508,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
write_reg(0x0010, 0x0000); // leave sleep mode
release_bus();
if (GDISP.Powermode != powerSleep)
lld_gdisp_init();
gdisp_lld_init();
break;
case powerSleep:
acquire_bus();

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

@ -187,7 +187,7 @@ __inline void GDISP_LLD(readstream)(uint16_t *buffer, size_t size) {
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise the display */
#if defined(GDISP_USE_FSMC)
@ -358,7 +358,7 @@ void GDISP_LLD(setwindow)(coord_t x0, coord_t y0, coord_t x1, coord_t y1) {
*
* @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 (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
#endif
@ -381,7 +381,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
@ -430,7 +430,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; srcx += GDISP.clipx0 - x; x = GDISP.clipx0; }
@ -486,7 +486,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@ -535,7 +535,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
/* NOT IMPLEMENTED YET */
switch(what) {
case GDISP_CONTROL_POWER:
@ -552,7 +552,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
GDISP_LLD(readreg)(0x0000); chThdSleepMicroseconds(5000); // 2x Dummy reads to wake up from deep sleep
GDISP_LLD(readreg)(0x0000); chThdSleepMicroseconds(5000);
if (GDISP.Powermode != powerSleep)
lld_gdisp_init();
gdisp_lld_init();
GDISP_LLD(writeindex)(SSD1963_SET_DISPLAY_ON);
break;

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

@ -53,7 +53,7 @@
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
/* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT;
@ -79,7 +79,7 @@ bool_t lld_gdisp_init(void) {
*
* @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)y;
(void)color;
@ -97,7 +97,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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)y;
@ -119,7 +119,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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)y;
(void)cx;

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

@ -314,7 +314,7 @@ static DWORD WINAPI WindowThread(LPVOID lpParameter) {
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
bool_t gdisp_lld_init(void) {
RECT rect;
/* Set the window dimensions */
@ -356,7 +356,7 @@ bool_t lld_gdisp_init(void) {
*
* @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) {
HDC dc;
#if WIN32_USE_MSG_REDRAW
RECT rect;
@ -422,7 +422,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
POINT p;
HPEN pen;
HDC dc;
@ -550,7 +550,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
HDC dc;
RECT rect;
HBRUSH hbr;
@ -681,7 +681,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
BITMAPV4HEADER bmpInfo;
RECT rect;
#if GDISP_NEED_CONTROL
@ -788,7 +788,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
color_t color;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@ -834,7 +834,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @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) {
RECT rect, frect, srect;
HBRUSH hbr;
@ -958,7 +958,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
*
* @notapi
*/
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_ORIENTATION:
if (GDISP.Orientation == (gdisp_orientation_t)value)

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

@ -32,6 +32,17 @@
#if GFX_USE_TDISP /*|| defined(__DOXYGEN__)*/
/* Include the hardware interface details */
#if defined(TDISP_USE_CUSTOM_BOARD) && TDISP_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */
#include "tdisp_lld_board.h"
#elif defined(BOARD_UNKNOWN)
#include "gdisp_lld_board_unknown.h"
#else
/* Include the user supplied board definitions */
#include "gdisp_lld_board.h"
#endif
/* The user may override the default display size */
#ifndef TDISP_COLUMNS
#define TDISP_COLUMNS 16
@ -52,17 +63,6 @@ tdispStruct TDISP = {
CUSTOM_CHAR_COUNT /* maxCustomChars */
};
/* Include the hardware interface details */
#if defined(TDISP_USE_CUSTOM_BOARD) && TDISP_USE_CUSTOM_BOARD
/* Include the user supplied board definitions */
#include "tdisp_lld_board.h"
#elif defined(BOARD_UNKNOWN)
#include "gdisp_lld_board_unknown.h"
#else
/* Include the user supplied board definitions */
#include "gdisp_lld_board.h"
#endif
/* Our display control */
#define DISPLAY_ON 0x04
#define CURSOR_ON 0x02

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

@ -29,6 +29,19 @@
#ifndef _TDISP_LLD_BOARD_H
#define _TDISP_LLD_BOARD_H
/**
* The board may override the default display size.
* Uncomment the below if your board needs a non-standard size.
*/
/*
#ifndef TDISP_COLUMNS
#define TDISP_COLUMNS 16
#endif
#ifndef TDISP_ROWS
#define TDISP_ROWS 2
#endif
*/
static void init_board(void) {
/* Code here */
#error "tdispHD44780: You must supply a definition for init_board for your board"

2
gfxconf.example.h
View file

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

20
include/gadc/gadc.h
View file

@ -1,5 +1,5 @@
/*
ChibiOS/GFX - Copyright (C) 2012
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
@ -68,10 +68,13 @@
* @{
*/
typedef struct GEventADC_t {
#if GFX_USE_GEVENT || defined(__DOXYGEN__)
/**
* @brief The type of this event (GEVENT_ADC)
*/
GEventType type;
#endif
/**
* @brief The event flags
*/
@ -115,7 +118,11 @@ extern "C" {
* @param[in] bufcount The total number of conversions that will fit in the buffer.
* @param[in] countPerEvent The number of conversions to do before returning an event.
*
* @note If the high speed ADC is running it will be stopped.
* @note If the high speed ADC is running it will be stopped. The Event subsystem is
* disconnected from the high speed ADC and any binary semaphore event is forgotten.
* @note bufcount must be greater than countPerEvent (usually 2 or more times) otherwise
* the buffer will be overwitten with new data while the application is still trying
* to process the old data.
* @note Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not
* 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.
@ -151,7 +158,7 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
* @note The high speed ADC will not use the GEVENT system unless this is
* called first. This saves processing time if the application does
* not want to use the GEVENT sub-system for the high speed ADC.
* Once turned on it cannot be turned off.
* 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.
*
@ -166,7 +173,8 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
* @param[in] pbsem The binary semaphore is signaled when data is available.
* @param[in] pEvent The static event buffer to place the result information.
*
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method.
* @note Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling
* @p gadcHighSpeedInit().
* @note The high speed ADC is capable of signalling via this method and the GEVENT
* sub-system at the same time.
*
@ -180,7 +188,7 @@ void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent);
*
* @api
*/
GSourceHandle gadcHighSpeedStart(void);
void gadcHighSpeedStart(void);
/**
* @brief Stop the high speed ADC conversions.
@ -237,7 +245,7 @@ void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer);
*
* @api
*/
bool gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
#ifdef __cplusplus
}

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 */
/** @} */

18
include/gadc/options.h
View file

@ -1,5 +1,5 @@
/*
ChibiOS/GFX - Copyright (C) 2012
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
@ -40,16 +40,14 @@
* @{
*/
/**
* @brief The maximum simultaneous GADC low speed device conversions
* @details Defaults to 4
* @note This value must be less than the number of conversions that can occur
* in a single high speed ADC cycle including the high speed ADC conversion.
* For example, if the ADC can run at 132k samples per second and the high speed
* virtual ADC is using 44kHz then GADC_MAX_LOWSPEED_DEVICES should be set to
* 132/44 - 1 = 2
* @brief The maximum GADC sample rate
* @details Defaults to 44000
* @note This value must be less than half the maximum sample rate allowed by the CPU.
* This is to ensure there is time between high speed samples to perform low
* speed device sampling.
*/
#ifndef GADC_MAX_LOWSPEED_DEVICES
#define GADC_MAX_LOWSPEED_DEVICES 4
#ifndef GADC_MAX_HIGH_SPEED_SAMPLERATE
#define GADC_MAX_HIGH_SPEED_SAMPLERATE 44000
#endif
/** @} */

38
include/gdisp/gdisp.h
View file

@ -201,26 +201,26 @@ extern "C" {
#else
/* 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 gdispClear(color) lld_gdisp_clear(color)
#define gdispDrawPixel(x, y, color) lld_gdisp_draw_pixel(x, y, color)
#define gdispDrawLine(x0, y0, x1, y1, color) lld_gdisp_draw_line(x0, y0, x1, y1, color)
#define gdispFillArea(x, y, cx, cy, color) lld_gdisp_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 gdispSetClip(x, y, cx, cy) lld_gdisp_set_clip(x, y, cx, cy)
#define gdispDrawCircle(x, y, radius, color) lld_gdisp_draw_circle(x, y, radius, color)
#define gdispFillCircle(x, y, radius, color) lld_gdisp_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 gdispFillArc(x, y, radius, sangle, eangle, color) lld_gdisp_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 gdispFillEllipse(x, y, a, b, color) lld_gdisp_fill_ellipse(x, y, a, b, color)
#define gdispDrawChar(x, y, c, font, color) lld_gdisp_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 gdispGetPixelColor(x, y) lld_gdisp_get_pixel_color(x, y)
#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor)
#define gdispControl(what, value) lld_gdisp_control(what, value)
#define gdispQuery(what) lld_gdisp_query(what)
#define gdispClear(color) gdisp_lld_clear(color)
#define gdispDrawPixel(x, y, color) gdisp_lld_draw_pixel(x, y, color)
#define gdispDrawLine(x0, y0, x1, y1, color) gdisp_lld_draw_line(x0, y0, x1, y1, 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) gdisp_lld_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)
#define gdispSetClip(x, y, cx, cy) gdisp_lld_set_clip(x, y, cx, cy)
#define gdispDrawCircle(x, y, radius, color) gdisp_lld_draw_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) gdisp_lld_draw_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) gdisp_lld_draw_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) gdisp_lld_draw_char(x, y, c, font, color)
#define gdispFillChar(x, y, c, font, color, bgcolor) gdisp_lld_fill_char(x, y, c, font, color, bgcolor)
#define gdispGetPixelColor(x, y) gdisp_lld_get_pixel_color(x, y)
#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor)
#define gdispControl(what, value) gdisp_lld_control(what, value)
#define gdispQuery(what) gdisp_lld_query(what)
#endif

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

@ -52,13 +52,13 @@
#endif
#if !GDISP_HARDWARE_CLEARS
void lld_gdisp_clear(color_t color) {
lld_gdisp_fill_area(0, 0, GDISP.Width, GDISP.Height, color);
void gdisp_lld_clear(color_t color) {
gdisp_lld_fill_area(0, 0, GDISP.Width, GDISP.Height, color);
}
#endif
#if !GDISP_HARDWARE_LINES
void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
int16_t dy, dx;
int16_t addx, addy;
int16_t P, diff, i;
@ -67,16 +67,16 @@
// speed improvement if vertical or horizontal
if (x0 == x1) {
if (y1 > y0)
lld_gdisp_fill_area(x0, y0, 1, y1-y0+1, color);
gdisp_lld_fill_area(x0, y0, 1, y1-y0+1, color);
else
lld_gdisp_fill_area(x0, y1, 1, y0-y1+1, color);
gdisp_lld_fill_area(x0, y1, 1, y0-y1+1, color);
return;
}
if (y0 == y1) {
if (x1 > x0)
lld_gdisp_fill_area(x0, y0, x1-x0+1, 1, color);
gdisp_lld_fill_area(x0, y0, x1-x0+1, 1, color);
else
lld_gdisp_fill_area(x0, y1, x0-x1+1, 1, color);
gdisp_lld_fill_area(x0, y1, x0-x1+1, 1, color);
return;
}
#endif
@ -102,7 +102,7 @@
diff = P - dx;
for(i=0; i<=dx; ++i) {
lld_gdisp_draw_pixel(x0, y0, color);
gdisp_lld_draw_pixel(x0, y0, color);
if (P < 0) {
P += dy;
x0 += addx;
@ -118,7 +118,7 @@
diff = P - dy;
for(i=0; i<=dy; ++i) {
lld_gdisp_draw_pixel(x0, y0, color);
gdisp_lld_draw_pixel(x0, y0, color);
if (P < 0) {
P += dx;
y0 += addy;
@ -133,16 +133,16 @@
#endif
#if !GDISP_HARDWARE_FILLS
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) {
#if GDISP_HARDWARE_SCROLL
lld_gdisp_vertical_scroll(x, y, cx, cy, cy, color);
gdisp_lld_vertical_scroll(x, y, cx, cy, cy, color);
#elif GDISP_HARDWARE_LINES
coord_t x1, y1;
x1 = x + cx - 1;
y1 = y + cy;
for(; y < y1; y++)
lld_gdisp_draw_line(x, y, x1, y, color);
gdisp_lld_draw_line(x, y, x1, y, color);
#else
coord_t x0, x1, y1;
@ -151,13 +151,13 @@
y1 = y + cy;
for(; y < y1; y++)
for(x = x0; x < x1; x++)
lld_gdisp_draw_pixel(x, y, color);
gdisp_lld_draw_pixel(x, y, color);
#endif
}
#endif
#if !GDISP_HARDWARE_BITFILLS
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 x0, x1, y1;
x0 = x;
@ -167,12 +167,12 @@
srccx -= cx;
for(; y < y1; y++, buffer += srccx)
for(x=x0; x < x1; x++)
lld_gdisp_draw_pixel(x, y, *buffer++);
gdisp_lld_draw_pixel(x, y, *buffer++);
}
#endif
#if GDISP_NEED_CLIP && !GDISP_HARDWARE_CLIP
void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
#if GDISP_NEED_VALIDATION
if (x >= GDISP.Width || y >= GDISP.Height || cx < 0 || cy < 0)
return;
@ -189,7 +189,7 @@
#endif
#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES
void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
coord_t a, b, P;
a = 0;
@ -197,14 +197,14 @@
P = 1 - radius;
do {
lld_gdisp_draw_pixel(x+a, y+b, color);
lld_gdisp_draw_pixel(x+b, y+a, color);
lld_gdisp_draw_pixel(x-a, y+b, color);
lld_gdisp_draw_pixel(x-b, y+a, color);
lld_gdisp_draw_pixel(x+b, y-a, color);
lld_gdisp_draw_pixel(x+a, y-b, color);
lld_gdisp_draw_pixel(x-a, y-b, color);
lld_gdisp_draw_pixel(x-b, y-a, color);
gdisp_lld_draw_pixel(x+a, y+b, color);
gdisp_lld_draw_pixel(x+b, y+a, color);
gdisp_lld_draw_pixel(x-a, y+b, color);
gdisp_lld_draw_pixel(x-b, y+a, color);
gdisp_lld_draw_pixel(x+b, y-a, color);
gdisp_lld_draw_pixel(x+a, y-b, color);
gdisp_lld_draw_pixel(x-a, y-b, color);
gdisp_lld_draw_pixel(x-b, y-a, color);
if (P < 0)
P += 3 + 2*a++;
else
@ -214,7 +214,7 @@
#endif
#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS
void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
coord_t a, b, P;
a = 0;
@ -222,10 +222,10 @@
P = 1 - radius;
do {
lld_gdisp_draw_line(x-a, y+b, x+a, y+b, color);
lld_gdisp_draw_line(x-a, y-b, x+a, y-b, color);
lld_gdisp_draw_line(x-b, y+a, x+b, y+a, color);
lld_gdisp_draw_line(x-b, y-a, x+b, y-a, color);
gdisp_lld_draw_line(x-a, y+b, x+a, y+b, color);
gdisp_lld_draw_line(x-a, y-b, x+a, y-b, color);
gdisp_lld_draw_line(x-b, y+a, x+b, y+a, color);
gdisp_lld_draw_line(x-b, y-a, x+b, y-a, color);
if (P < 0)
P += 3 + 2*a++;
else
@ -235,16 +235,16 @@
#endif
#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES
void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
void gdisp_lld_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
long a2 = a*a, b2 = b*b;
long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */
do {
lld_gdisp_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */
lld_gdisp_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */
lld_gdisp_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */
lld_gdisp_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */
gdisp_lld_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */
gdisp_lld_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */
gdisp_lld_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */
gdisp_lld_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */
e2 = 2*err;
if(e2 < (2*dx+1)*b2) {
@ -258,21 +258,21 @@
} while(dy >= 0);
while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
lld_gdisp_draw_pixel(x-dx, y, color);
gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
gdisp_lld_draw_pixel(x-dx, y, color);
}
}
#endif
#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS
void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
void gdisp_lld_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
long a2 = a*a, b2 = b*b;
long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */
do {
lld_gdisp_draw_line(x-dx,y+dy,x+dx,y+dy, color);
lld_gdisp_draw_line(x-dx,y-dy,x+dx,y-dy, color);
gdisp_lld_draw_line(x-dx,y+dy,x+dx,y+dy, color);
gdisp_lld_draw_line(x-dx,y-dy,x+dx,y-dy, color);
e2 = 2*err;
if(e2 < (2*dx+1)*b2) {
@ -286,8 +286,8 @@
} while(dy >= 0);
while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
lld_gdisp_draw_pixel(x-dx, y, color);
gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
gdisp_lld_draw_pixel(x-dx, y, color);
}
}
#endif
@ -325,13 +325,13 @@
do {
if(x-a <= x_maxI && x-a >= x_minI)
lld_gdisp_draw_pixel(x-a, y-b, color);
gdisp_lld_draw_pixel(x-a, y-b, color);
if(x+a <= x_maxI && x+a >= x_minI)
lld_gdisp_draw_pixel(x+a, y-b, color);
gdisp_lld_draw_pixel(x+a, y-b, color);
if(x-b <= x_maxI && x-b >= x_minI)
lld_gdisp_draw_pixel(x-b, y-a, color);
gdisp_lld_draw_pixel(x-b, y-a, color);
if(x+b <= x_maxI && x+b >= x_minI)
lld_gdisp_draw_pixel(x+b, y-a, color);
gdisp_lld_draw_pixel(x+b, y-a, color);
if (P < 0) {
P = P + 3 + 2*a;
@ -359,13 +359,13 @@
do {
if(x-a <= x_maxII && x-a >= x_minII)
lld_gdisp_draw_pixel(x-a, y+b, color);
gdisp_lld_draw_pixel(x-a, y+b, color);
if(x+a <= x_maxII && x+a >= x_minII)
lld_gdisp_draw_pixel(x+a, y+b, color);
gdisp_lld_draw_pixel(x+a, y+b, color);
if(x-b <= x_maxII && x-b >= x_minII)
lld_gdisp_draw_pixel(x-b, y+a, color);
gdisp_lld_draw_pixel(x-b, y+a, color);
if(x+b <= x_maxII && x+b >= x_minII)
lld_gdisp_draw_pixel(x+b, y+a, color);
gdisp_lld_draw_pixel(x+b, y+a, color);
if (P < 0) {
P = P + 3 + 2*a;
@ -379,7 +379,7 @@
}
}
void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
if(endangle < startangle) {
_draw_arc(x, y, startangle, 360, radius, color);
_draw_arc(x, y, 0, endangle, radius, color);
@ -419,13 +419,13 @@
do {
if(x-a <= x_maxI && x-a >= x_minI)
lld_gdisp_draw_line(x, y, x-a, y-b, color);
gdisp_lld_draw_line(x, y, x-a, y-b, color);
if(x+a <= x_maxI && x+a >= x_minI)
lld_gdisp_draw_line(x, y, x+a, y-b, color);
gdisp_lld_draw_line(x, y, x+a, y-b, color);
if(x-b <= x_maxI && x-b >= x_minI)
lld_gdisp_draw_line(x, y, x-b, y-a, color);
gdisp_lld_draw_line(x, y, x-b, y-a, color);
if(x+b <= x_maxI && x+b >= x_minI)
lld_gdisp_draw_line(x, y, x+b, y-a, color);
gdisp_lld_draw_line(x, y, x+b, y-a, color);
if (P < 0) {
P = P + 3 + 2*a;
@ -453,13 +453,13 @@
do {
if(x-a <= x_maxII && x-a >= x_minII)
lld_gdisp_draw_line(x, y, x-a, y+b, color);
gdisp_lld_draw_line(x, y, x-a, y+b, color);
if(x+a <= x_maxII && x+a >= x_minII)
lld_gdisp_draw_line(x, y, x+a, y+b, color);
gdisp_lld_draw_line(x, y, x+a, y+b, color);
if(x-b <= x_maxII && x-b >= x_minII)
lld_gdisp_draw_line(x, y, x-b, y+a, color);
gdisp_lld_draw_line(x, y, x-b, y+a, color);
if(x+b <= x_maxII && x+b >= x_minII)
lld_gdisp_draw_line(x, y, x+b, y+a, color);
gdisp_lld_draw_line(x, y, x+b, y+a, color);
if (P < 0) {
P = P + 3 + 2*a;
@ -473,7 +473,7 @@
}
}
void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
if(endangle < startangle) {
_fill_arc(x, y, startangle, 360, radius, color);
_fill_arc(x, y, 0, endangle, radius, color);
@ -488,7 +488,7 @@
#endif
#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color) {
void gdisp_lld_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color) {
const fontcolumn_t *ptr;
fontcolumn_t column;
coord_t width, height, xscale, yscale;
@ -515,7 +515,7 @@
if (column & 0x01) {
for(xs=0; xs < xscale; xs++)
for(ys=0; ys < yscale; ys++)
lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);
gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
}
}
}
@ -523,7 +523,7 @@
#endif
#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS
void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
void gdisp_lld_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
coord_t width, height;
coord_t xscale, yscale;
@ -540,10 +540,10 @@
#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW
/* Fill the area */
lld_gdisp_fill_area(x, y, width, height, bgcolor);
gdisp_lld_fill_area(x, y, width, height, bgcolor);
/* Draw the text */
lld_gdisp_draw_char(x, y, c, font, color);
gdisp_lld_draw_char(x, y, c, font, color);
/* Method 2: Create a single column bitmap and then blit it */
#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN
@ -582,7 +582,7 @@
}
for(xs=0; xs < xscale; xs++)
lld_gdisp_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);
gdisp_lld_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);
}
}
@ -626,7 +626,7 @@
}
/* [Patch by Badger] Write all in one stroke */
lld_gdisp_blit_area_ex(x, y, width, height, 0, 0, width, buf);
gdisp_lld_blit_area_ex(x, y, width, height, 0, 0, width, buf);
}
/* Method 4: Draw pixel by pixel */
@ -648,11 +648,11 @@
if (column & 0x01) {
for(xs=0; xs < xscale; xs++)
for(ys=0; ys < yscale; ys++)
lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);
gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
} else {
for(xs=0; xs < xscale; xs++)
for(ys=0; ys < yscale; ys++)
lld_gdisp_draw_pixel(x+i+xs, y+j+ys, bgcolor);
gdisp_lld_draw_pixel(x+i+xs, y+j+ys, bgcolor);
}
}
}
@ -663,7 +663,7 @@
#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL
void lld_gdisp_control(unsigned what, void *value) {
void gdisp_lld_control(unsigned what, void *value) {
(void)what;
(void)value;
/* Ignore everything */
@ -671,7 +671,7 @@
#endif
#if !GDISP_HARDWARE_QUERY
void *lld_gdisp_query(unsigned what) {
void *gdisp_lld_query(unsigned what) {
switch(what) {
case GDISP_QUERY_WIDTH: return (void *)(unsigned)GDISP.Width;
case GDISP_QUERY_HEIGHT: return (void *)(unsigned)GDISP.Height;
@ -685,82 +685,82 @@ void *lld_gdisp_query(unsigned what) {
#endif
#if GDISP_NEED_MSGAPI
void lld_gdisp_msg_dispatch(gdisp_lld_msg_t *msg) {
void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg) {
switch(msg->action) {
case GDISP_LLD_MSG_NOP:
break;
case GDISP_LLD_MSG_INIT:
lld_gdisp_init();
gdisp_lld_init();
break;
case GDISP_LLD_MSG_CLEAR:
lld_gdisp_clear(msg->clear.color);
gdisp_lld_clear(msg->clear.color);
break;
case GDISP_LLD_MSG_DRAWPIXEL:
lld_gdisp_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);
gdisp_lld_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);
break;
case GDISP_LLD_MSG_FILLAREA:
lld_gdisp_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);
gdisp_lld_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);
break;
case GDISP_LLD_MSG_BLITAREA:
lld_gdisp_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);
gdisp_lld_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);
break;
case GDISP_LLD_MSG_DRAWLINE:
lld_gdisp_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);
gdisp_lld_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);
break;
#if GDISP_NEED_CLIP
case GDISP_LLD_MSG_SETCLIP:
lld_gdisp_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);
gdisp_lld_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);
break;
#endif
#if GDISP_NEED_CIRCLE
case GDISP_LLD_MSG_DRAWCIRCLE:
lld_gdisp_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);
gdisp_lld_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);
break;
case GDISP_LLD_MSG_FILLCIRCLE:
lld_gdisp_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);
gdisp_lld_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);
break;
#endif
#if GDISP_NEED_ELLIPSE
case GDISP_LLD_MSG_DRAWELLIPSE:
lld_gdisp_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);
gdisp_lld_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);
break;
case GDISP_LLD_MSG_FILLELLIPSE:
lld_gdisp_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);
gdisp_lld_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);
break;
#endif
#if GDISP_NEED_ARC
case GDISP_LLD_MSG_DRAWARC:
lld_gdisp_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);
gdisp_lld_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);
break;
case GDISP_LLD_MSG_FILLARC:
lld_gdisp_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);
gdisp_lld_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);
break;
#endif
#if GDISP_NEED_TEXT
case GDISP_LLD_MSG_DRAWCHAR:
lld_gdisp_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);
gdisp_lld_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);
break;
case GDISP_LLD_MSG_FILLCHAR:
lld_gdisp_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);
gdisp_lld_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);
break;
#endif
#if GDISP_NEED_PIXELREAD
case GDISP_LLD_MSG_GETPIXELCOLOR:
msg->getpixelcolor.result = lld_gdisp_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);
msg->getpixelcolor.result = gdisp_lld_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);
break;
#endif
#if GDISP_NEED_SCROLL
case GDISP_LLD_MSG_VERTICALSCROLL:
lld_gdisp_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);
gdisp_lld_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);
break;
#endif
#if GDISP_NEED_CONTROL
case GDISP_LLD_MSG_CONTROL:
lld_gdisp_control(msg->control.what, msg->control.value);
gdisp_lld_control(msg->control.what, msg->control.value);
break;
#endif
case GDISP_LLD_MSG_QUERY:
msg->query.result = lld_gdisp_query(msg->query.what);
msg->query.result = gdisp_lld_query(msg->query.what);
break;
}
}

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

@ -19,7 +19,7 @@
*/
/**
* @file include/gdisp/lld/lld_gdisp.h
* @file include/gdisp/lld/gdisp_lld.h
* @brief GDISP Graphic Driver subsystem low level driver header.
*
* @addtogroup GDISP
@ -463,69 +463,69 @@ extern "C" {
#endif
/* Core functions */
extern bool_t lld_gdisp_init(void);
extern bool_t gdisp_lld_init(void);
/* Some of these functions will be implemented in software by the high level driver
depending on the GDISP_HARDWARE_XXX macros defined in lld_gdisp_config.h.
depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h.
*/
/* Drawing functions */
extern void lld_gdisp_clear(color_t color);
extern void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color);
extern void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
extern 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);
extern void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
extern void gdisp_lld_clear(color_t color);
extern void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color);
extern void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
extern 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);
extern void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
/* Circular Drawing Functions */
#if GDISP_NEED_CIRCLE
extern void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);
extern void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);
extern void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);
extern void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);
#endif
#if GDISP_NEED_ELLIPSE
extern void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
extern void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
extern void gdisp_lld_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
extern void gdisp_lld_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
#endif
/* Arc Drawing Functions */
#if GDISP_NEED_ARC
extern void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
extern void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
extern void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
extern void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
#endif
/* Text Rendering Functions */
#if GDISP_NEED_TEXT
extern void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);
extern void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
extern void gdisp_lld_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);
extern void gdisp_lld_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
#endif
/* Pixel readback */
#if GDISP_NEED_PIXELREAD
extern color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y);
extern color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y);
#endif
/* Scrolling Function - clears the area scrolled out */
#if GDISP_NEED_SCROLL
extern void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
extern void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
#endif
/* Set driver specific control */
#if GDISP_NEED_CONTROL
extern void lld_gdisp_control(unsigned what, void *value);
extern void gdisp_lld_control(unsigned what, void *value);
#endif
/* Query driver specific data */
extern void *lld_gdisp_query(unsigned what);
extern void *gdisp_lld_query(unsigned what);
/* Clipping Functions */
#if GDISP_NEED_CLIP
extern void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);
extern void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif
/* Messaging API */
#if GDISP_NEED_MSGAPI
#include "lld_gdisp_msgs.h"
extern void lld_gdisp_msg_dispatch(lld_gdisp_msg_t *msg);
#include "gdisp_lld_msgs.h"
extern void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg);
#endif
#ifdef __cplusplus

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

@ -140,14 +140,14 @@ typedef union gdisp_lld_msg {
coord_t radius;
coord_t startangle, endangle;
color_t color;
} drawcircle;
} drawarc;
struct gdisp_lld_msg_fillarc {
gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLARC
coord_t x, y;
coord_t radius;
coord_t startangle, endangle;
color_t color;
} fillcircle;
} fillarc;
struct gdisp_lld_msg_drawchar {
gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCHAR
coord_t x, y;

14
include/gfx_rules.h
View file

@ -99,6 +99,17 @@
#if GFX_USE_TDISP
#endif
#if GFX_USE_GADC
#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
#error "GADC: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
#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."
#undef GFX_USE_GTIMER
#define GFX_USE_GTIMER TRUE
#endif
#endif
#if GFX_USE_GEVENT
#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
#error "GEVENT: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
@ -118,9 +129,6 @@
#if GFX_USE_GAUDOUT
#endif
#if GFX_USE_GADC
#endif
#if GFX_USE_GMISC
#endif

433
src/gadc/gadc.c
View file

@ -1,5 +1,5 @@
/*
ChibiOS/GFX - Copyright (C) 2012
ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX.
@ -29,9 +29,436 @@
#include "hal.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"
#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 */
/** @} */

42
src/gdisp/gdisp.c
View file

@ -95,7 +95,7 @@
/* OK - we need to obtain the mutex in case a synchronous operation is occurring */
chMtxLock(&gdispMutex);
lld_gdisp_msg_dispatch(pmsg);
gdisp_lld_msg_dispatch(pmsg);
chMtxUnlock();
/* Mark the message as free */
@ -153,7 +153,7 @@
/* Initialise driver */
chMtxLock(&gdispMutex);
res = lld_gdisp_init();
res = gdisp_lld_init();
chMtxUnlock();
return res;
@ -180,7 +180,7 @@
/* Initialise driver - synchronous */
chMtxLock(&gdispMutex);
res = lld_gdisp_init();
res = gdisp_lld_init();
chMtxUnlock();
return res;
@ -216,7 +216,7 @@
*/
void gdispClear(color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_clear(color);
gdisp_lld_clear(color);
chMtxUnlock();
}
#elif GDISP_NEED_ASYNC
@ -238,7 +238,7 @@
*/
void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_pixel(x, y, color);
gdisp_lld_draw_pixel(x, y, color);
chMtxUnlock();
}
#elif GDISP_NEED_ASYNC
@ -263,7 +263,7 @@
*/
void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_line(x0, y0, x1, y1, color);
gdisp_lld_draw_line(x0, y0, x1, y1, color);
chMtxUnlock();
}
#elif GDISP_NEED_ASYNC
@ -290,7 +290,7 @@
*/
void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_fill_area(x, y, cx, cy, color);
gdisp_lld_fill_area(x, y, cx, cy, color);
chMtxUnlock();
}
#elif GDISP_NEED_ASYNC
@ -326,7 +326,7 @@
*/
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) {
chMtxLock(&gdispMutex);
lld_gdisp_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
gdisp_lld_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
chMtxUnlock();
}
#elif GDISP_NEED_ASYNC
@ -355,7 +355,7 @@
*/
void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
chMtxLock(&gdispMutex);
lld_gdisp_set_clip(x, y, cx, cy);
gdisp_lld_set_clip(x, y, cx, cy);
chMtxUnlock();
}
#elif GDISP_NEED_CLIP && GDISP_NEED_ASYNC
@ -381,7 +381,7 @@
*/
void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_circle(x, y, radius, color);
gdisp_lld_draw_circle(x, y, radius, color);
chMtxUnlock();
}
#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
@ -407,7 +407,7 @@
*/
void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_fill_circle(x, y, radius, color);
gdisp_lld_fill_circle(x, y, radius, color);
chMtxUnlock();
}
#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
@ -433,7 +433,7 @@
*/
void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_ellipse(x, y, a, b, color);
gdisp_lld_draw_ellipse(x, y, a, b, color);
chMtxUnlock();
}
#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
@ -460,7 +460,7 @@
*/
void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_fill_ellipse(x, y, a, b, color);
gdisp_lld_fill_ellipse(x, y, a, b, color);
chMtxUnlock();
}
#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
@ -489,7 +489,7 @@
*/
void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_arc(x, y, radius, start, end, color);
gdisp_lld_draw_arc(x, y, radius, start, end, color);
chMtxUnlock();
}
#elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
@ -520,7 +520,7 @@
*/
void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_fill_arc(x, y, radius, start, end, color);
gdisp_lld_fill_arc(x, y, radius, start, end, color);
chMtxUnlock();
}
#elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
@ -605,7 +605,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
*/
void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
chMtxLock(&gdispMutex);
lld_gdisp_draw_char(x, y, c, font, color);
gdisp_lld_draw_char(x, y, c, font, color);
chMtxUnlock();
}
#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
@ -634,7 +634,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
*/
void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
chMtxLock(&gdispMutex);
lld_gdisp_fill_char(x, y, c, font, color, bgcolor);
gdisp_lld_fill_char(x, y, c, font, color, bgcolor);
chMtxUnlock();
}
#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
@ -664,7 +664,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
/* Always synchronous as it must return a value */
chMtxLock(&gdispMutex);
c = lld_gdisp_get_pixel_color(x, y);
c = gdisp_lld_get_pixel_color(x, y);
chMtxUnlock();
return c;
@ -687,7 +687,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
*/
void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
chMtxLock(&gdispMutex);
lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor);
gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor);
chMtxUnlock();
}
#elif GDISP_NEED_SCROLL && GDISP_NEED_ASYNC
@ -717,7 +717,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
*/
void gdispControl(unsigned what, void *value) {
chMtxLock(&gdispMutex);
lld_gdisp_control(what, value);
gdisp_lld_control(what, value);
chMtxUnlock();
chThdSleepMilliseconds(100);
}
@ -746,7 +746,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
void *res;
chMtxLock(&gdispMutex);
res = lld_gdisp_query(what);
res = gdisp_lld_query(what);
chMtxUnlock();
return res;
}