mirror
/
OpenRTX
kopia lustrzana https://github.com/OpenRTX/OpenRTX
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność

Moving to miosix kernel: swapped old uC/OS-III task management functions with pthread ones

replace/f3fc701f24a2f962f6a16b2e6d468db8eb38ccfd
Silvano Seva 2021-03-10 16:32:40 +01:00
rodzic 2b28ea0525
commit fb3447b0c6
13 zmienionych plików z 327 dodań i 383 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

122
meson.build
Wyświetl plik

@ -1,7 +1,7 @@
## ##
## OpenRTX - Modular Open Source Radio Firmware ## OpenRTX - Modular Open Source Radio Firmware
## ##
project('OpenRTX', 'c', project('OpenRTX', ['c', 'cpp'],
version : '0.1', version : '0.1',
default_options : ['warning_level=3']) default_options : ['warning_level=3'])
@ -11,8 +11,7 @@ project('OpenRTX', 'c',
## OpenRTX ## OpenRTX
openrtx_src = ['openrtx/src/bootstrap.c', openrtx_src = ['openrtx/src/state.c',
'openrtx/src/state.c',
'openrtx/src/ui/ui.c', 'openrtx/src/ui/ui.c',
'openrtx/src/ui/ui_main.c', 'openrtx/src/ui/ui_main.c',
'openrtx/src/ui/ui_menu.c', 'openrtx/src/ui/ui_menu.c',
@ -21,6 +20,7 @@ openrtx_src = ['openrtx/src/bootstrap.c',
'openrtx/src/graphics.c', 'openrtx/src/graphics.c',
'openrtx/src/input.c', 'openrtx/src/input.c',
'openrtx/src/calibUtils.c', 'openrtx/src/calibUtils.c',
'openrtx/src/queue.c',
'openrtx/src/rtx.c', 'openrtx/src/rtx.c',
'openrtx/src/gps.c'] 'openrtx/src/gps.c']
@ -28,10 +28,8 @@ openrtx_src = ['openrtx/src/bootstrap.c',
## Replace main executable with platform test ## Replace main executable with platform test
if get_option('test') != '' if get_option('test') != ''
openrtx_src += 'tests/platform/'+get_option('test')+'.c' openrtx_src += 'tests/platform/'+get_option('test')+'.c'
openrtx_def = {'RUN_TESTSUITE': ''}
else else
openrtx_src += 'openrtx/src/main.c' openrtx_src += 'openrtx/src/main.c'
openrtx_def = {}
endif endif
openrtx_inc = ['openrtx/include', openrtx_inc = ['openrtx/include',
@ -45,36 +43,11 @@ openrtx_inc = ['openrtx/include',
'platform/drivers/baseband'] 'platform/drivers/baseband']
## RTOS ## RTOS
rtos_src = ['lib/rtos/uC-OS3/Source/__dbg_uCOS-III.c', rtos_inc = ['lib/miosix-kernel',
'lib/rtos/uC-OS3/Source/os_cfg_app.c', 'lib/miosix-kernel/arch',
'lib/rtos/uC-OS3/Source/os_core.c', 'lib/miosix-kernel/arch/cortexM4_stm32f4/common',
'lib/rtos/uC-OS3/Source/os_dbg.c', 'lib/miosix-kernel/arch/cortexM4_stm32f4/M4_openrtx',
'lib/rtos/uC-OS3/Source/os_flag.c', 'lib/miosix-kernel/config/arch/cortexM4_stm32f4/M4_openrtx']
'lib/rtos/uC-OS3/Source/os_mem.c',
'lib/rtos/uC-OS3/Source/os_msg.c',
'lib/rtos/uC-OS3/Source/os_mutex.c',
'lib/rtos/uC-OS3/Source/os_prio.c',
'lib/rtos/uC-OS3/Source/os_q.c',
'lib/rtos/uC-OS3/Source/os_sem.c',
'lib/rtos/uC-OS3/Source/os_stat.c',
'lib/rtos/uC-OS3/Source/os_task.c',
'lib/rtos/uC-OS3/Source/os_tick.c',
'lib/rtos/uC-OS3/Source/os_time.c',
'lib/rtos/uC-OS3/Source/os_tmr.c',
'lib/rtos/uC-OS3/Source/os_var.c',
'lib/rtos/uC-OS3/Cfg/os_app_hooks.c',
'lib/rtos/uC-CPU/cpu_core.c',
'lib/rtos/uC-LIB/lib_ascii.c',
'lib/rtos/uC-LIB/lib_math.c',
'lib/rtos/uC-LIB/lib_mem.c',
'lib/rtos/uC-LIB/lib_str.c']
rtos_inc = ['lib/rtos/uC-OS3/Source',
'lib/rtos/uC-OS3/Cfg',
'lib/rtos/uC-CPU',
'lib/rtos/uC-CPU/Cfg',
'lib/rtos/uC-LIB',
'lib/rtos/uC-LIB/Cfg']
## minmea, a lightweight GPS NMEA 0183 parser library ## minmea, a lightweight GPS NMEA 0183 parser library
@ -82,13 +55,13 @@ minmea_src = ['lib/minmea/minmea.c']
minmea_inc = ['lib/minmea/include'] minmea_inc = ['lib/minmea/include']
src = openrtx_src + rtos_src + minmea_src src = openrtx_src + minmea_src
inc = openrtx_inc + rtos_inc + minmea_inc inc = openrtx_inc + rtos_inc + minmea_inc
## ##
## Definitions ## Definitions
## ##
def = openrtx_def + {'DONT_USE_CMSIS_INIT': ''} def = {'DONT_USE_CMSIS_INIT': ''}
## ##
## MCU-dependent sources and includes ## MCU-dependent sources and includes
@ -96,8 +69,9 @@ def = openrtx_def + {'DONT_USE_CMSIS_INIT': ''}
## STM32F405 ## STM32F405
stm32f405_src = ['platform/mcu/STM32F4xx/boot/startup.c', stm32f405_src = ['platform/mcu/STM32F4xx/boot/startup.cpp',
'platform/mcu/STM32F4xx/boot/libc_integration.c', 'platform/mcu/STM32F4xx/boot/bsp.cpp',
'platform/mcu/STM32F4xx/boot/libc_integration.cpp',
'platform/mcu/STM32F4xx/drivers/usb/usb_bsp.c', 'platform/mcu/STM32F4xx/drivers/usb/usb_bsp.c',
'platform/mcu/STM32F4xx/drivers/usb/usb_core.c', 'platform/mcu/STM32F4xx/drivers/usb/usb_core.c',
'platform/mcu/STM32F4xx/drivers/usb/usb_dcd.c', 'platform/mcu/STM32F4xx/drivers/usb/usb_dcd.c',
@ -109,50 +83,38 @@ stm32f405_src = ['platform/mcu/STM32F4xx/boot/startup.c',
'platform/mcu/STM32F4xx/drivers/usb/usbd_usr.c', 'platform/mcu/STM32F4xx/drivers/usb/usbd_usr.c',
'platform/mcu/STM32F4xx/drivers/gpio.c', 'platform/mcu/STM32F4xx/drivers/gpio.c',
'platform/mcu/STM32F4xx/drivers/usb_vcom.c', 'platform/mcu/STM32F4xx/drivers/usb_vcom.c',
'platform/mcu/STM32F4xx/drivers/delays.c', 'platform/mcu/STM32F4xx/drivers/delays.cpp',
'platform/mcu/STM32F4xx/drivers/rtc.c', 'platform/mcu/STM32F4xx/drivers/rtc.c',
'platform/mcu/CMSIS/Device/ST/STM32F4xx/Source/system_stm32f4xx.c', 'platform/mcu/CMSIS/Device/ST/STM32F4xx/Source/system_stm32f4xx.c']
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M/os_cpu_c.c',
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M/os_cpu_a.s',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M/cpu_c.c',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M/cpu_a.s']
stm32f405_inc = ['platform/mcu/CMSIS/Include', stm32f405_inc = ['platform/mcu/CMSIS/Include',
'platform/mcu/CMSIS/Device/ST/STM32F4xx/Include', 'platform/mcu/CMSIS/Device/ST/STM32F4xx/Include',
'platform/mcu/STM32F4xx', 'platform/mcu/STM32F4xx',
'platform/mcu/STM32F4xx/drivers', 'platform/mcu/STM32F4xx/drivers',
'platform/mcu/STM32F4xx/drivers/usb', 'platform/mcu/STM32F4xx/drivers/usb']
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M']
stm32f405_def = {'STM32F40_41xxx': '', 'HSE_VALUE':'8000000'} stm32f405_def = {'STM32F40_41xxx': '', 'HSE_VALUE':'8000000'}
## MK22FN512 ## MK22FN512
mk22fn512_src = ['platform/mcu/MK22FN512xxx12/boot/startup.c', mk22fn512_src = ['platform/mcu/MK22FN512xxx12/boot/startup.cpp',
'platform/mcu/MK22FN512xxx12/boot/libc_integration.c', 'platform/mcu/MK22FN512xxx12/boot/bsp.cpp',
'platform/mcu/MK22FN512xxx12/boot/libc_integration.cpp',
'platform/mcu/MK22FN512xxx12/drivers/gpio.c', 'platform/mcu/MK22FN512xxx12/drivers/gpio.c',
'platform/mcu/MK22FN512xxx12/drivers/delays.c', 'platform/mcu/MK22FN512xxx12/drivers/delays.cpp',
'platform/mcu/MK22FN512xxx12/drivers/rtc.c',
'platform/mcu/MK22FN512xxx12/drivers/I2C0.c', 'platform/mcu/MK22FN512xxx12/drivers/I2C0.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_cdc_acm.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_cdc_acm.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_ch9.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_ch9.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_dci.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_dci.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_descriptor.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_descriptor.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_khci.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_device_khci.c',
'platform/mcu/MK22FN512xxx12/drivers/usb/usb_osa_bm.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb/usb_osa_bm.c',
'platform/mcu/MK22FN512xxx12/drivers/usb_vcom.c', # 'platform/mcu/MK22FN512xxx12/drivers/usb_vcom.c',
'platform/mcu/CMSIS/Device/NXP/MK22FN512xxx12/Source/system_MK22F51212.c', 'platform/mcu/CMSIS/Device/NXP/MK22FN512xxx12/Source/system_MK22F51212.c']
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M/os_cpu_c.c',
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M/os_cpu_a.s',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M/cpu_c.c',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M/cpu_a.s']
mk22fn512_inc = ['platform/mcu/CMSIS/Include', mk22fn512_inc = ['platform/mcu/CMSIS/Include',
'platform/mcu/CMSIS/Device/NXP/MK22FN512xxx12/Include', 'platform/mcu/CMSIS/Device/NXP/MK22FN512xxx12/Include',
'platform/mcu/MK22FN512xxx12/drivers', 'platform/mcu/MK22FN512xxx12/drivers']
'lib/rtos/uC-OS3/Ports/ARM-Cortex-M/ARMv7-M',
'lib/rtos/uC-CPU/ARM-Cortex-M/ARMv7-M']
mk22fn512_def = {} mk22fn512_def = {}
@ -170,9 +132,7 @@ linux_src = src + ['platform/targets/linux/emulator/emulator.c',
'platform/mcu/x86_64/drivers/delays.c', 'platform/mcu/x86_64/drivers/delays.c',
'platform/mcu/x86_64/drivers/rtc.c', 'platform/mcu/x86_64/drivers/rtc.c',
'platform/drivers/baseband/radio_linux.c', 'platform/drivers/baseband/radio_linux.c',
'platform/targets/linux/platform.c', 'platform/targets/linux/platform.c']
'lib/rtos/uC-OS3/Ports/POSIX/os_cpu_c.c',
'lib/rtos/uC-CPU/Posix/cpu_c.c']
# GDx family display emulation # GDx family display emulation
@ -180,9 +140,7 @@ linux_src = src + ['platform/targets/linux/emulator/emulator.c',
# MDx family display emulation # MDx family display emulation
linux_def = def + {'SCREEN_WIDTH': '160', 'SCREEN_HEIGHT': '128', 'PIX_FMT_RGB565': ''} linux_def = def + {'SCREEN_WIDTH': '160', 'SCREEN_HEIGHT': '128', 'PIX_FMT_RGB565': ''}
linux_inc = inc + ['lib/rtos/uC-OS3/Ports/POSIX', linux_inc = inc + ['platform/targets/linux',
'lib/rtos/uC-CPU/Posix',
'platform/targets/linux',
'platform/targets/linux/emulator'] 'platform/targets/linux/emulator']
if not meson.is_cross_build() if not meson.is_cross_build()
@ -194,7 +152,7 @@ else
endif endif
## TYT MD-3x0 family ## TYT MD-3x0 family
md3x0_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.c', md3x0_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.cpp',
'platform/drivers/keyboard/keyboard_MDx.c', 'platform/drivers/keyboard/keyboard_MDx.c',
'platform/drivers/NVM/W25Qx.c', 'platform/drivers/NVM/W25Qx.c',
'platform/drivers/NVM/spiFlash_MDx.c', 'platform/drivers/NVM/spiFlash_MDx.c',
@ -204,7 +162,7 @@ md3x0_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.c',
'platform/drivers/baseband/SKY72310.c', 'platform/drivers/baseband/SKY72310.c',
'platform/drivers/baseband/radio_MD3x0.c', 'platform/drivers/baseband/radio_MD3x0.c',
'platform/drivers/baseband/HR_C5000.c', 'platform/drivers/baseband/HR_C5000.c',
'platform/drivers/GPS/GPS_MDx.c', 'platform/drivers/GPS/GPS_MDx.cpp',
'platform/targets/MD-3x0/platform.c'] 'platform/targets/MD-3x0/platform.c']
md3x0_inc = inc + stm32f405_inc + ['platform/targets/MD-3x0'] md3x0_inc = inc + stm32f405_inc + ['platform/targets/MD-3x0']
@ -212,7 +170,7 @@ md3x0_def = def + stm32f405_def + {'PLATFORM_MD3x0': '',
'timegm': 'mktime'} 'timegm': 'mktime'}
## TYT MD-UV380 ## TYT MD-UV380
mduv380_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.c', mduv380_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.cpp',
'platform/drivers/keyboard/keyboard_MDx.c', 'platform/drivers/keyboard/keyboard_MDx.c',
'platform/drivers/NVM/W25Qx.c', 'platform/drivers/NVM/W25Qx.c',
'platform/drivers/NVM/spiFlash_MDx.c', 'platform/drivers/NVM/spiFlash_MDx.c',
@ -220,7 +178,7 @@ mduv380_src = src + stm32f405_src + ['platform/drivers/display/HX8353_MDx.c',
'platform/drivers/ADC/ADC1_MDx.c', 'platform/drivers/ADC/ADC1_MDx.c',
'platform/drivers/tones/toneGenerator_MDx.c', 'platform/drivers/tones/toneGenerator_MDx.c',
'platform/drivers/baseband/radio_UV3x0.c', 'platform/drivers/baseband/radio_UV3x0.c',
'platform/drivers/GPS/GPS_MDx.c', 'platform/drivers/GPS/GPS_MDx.cpp',
'platform/targets/MD-UV380/platform.c'] 'platform/targets/MD-UV380/platform.c']
mduv380_inc = inc + stm32f405_inc + ['platform/targets/MD-UV380'] mduv380_inc = inc + stm32f405_inc + ['platform/targets/MD-UV380']
@ -355,38 +313,44 @@ linux_opts = {'sources': linux_src,
'dependencies': linux_dep, 'dependencies': linux_dep,
'link_args' : linux_l_args} 'link_args' : linux_l_args}
md3x0_opts = {'sources': md3x0_src, md3x0_opts = {'sources' : md3x0_src,
'c_args': md3x0_args, 'c_args' : md3x0_args,
'cpp_args': md3x0_args,
'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories': md3x0_inc} 'include_directories': md3x0_inc}
mduv380_opts = {'sources': mduv380_src, mduv380_opts = {'sources': mduv380_src,
'c_args': mduv380_args, 'c_args': mduv380_args,
'cpp_args': mduv380_args,
'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories': mduv380_inc} 'include_directories': mduv380_inc}
mduv380g_opts = {'sources': mduv380_src, mduv380g_opts = {'sources': mduv380_src,
'c_args': mduv380g_args, 'c_args': mduv380g_args,
'cpp_args': mduv380g_args,
'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories': mduv380_inc} 'include_directories': mduv380_inc}
gd77_opts = {'sources': gd77_src, gd77_opts = {'sources': gd77_src,
'c_args': gd77_args, 'c_args': gd77_args,
'cpp_args': gd77_args,
'link_args' : ['-Wl,-T../platform/mcu/MK22FN512xxx12/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/MK22FN512xxx12/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories':gd77_inc} 'include_directories':gd77_inc}
dm1801_opts = {'sources': dm1801_src, dm1801_opts = {'sources': dm1801_src,
'c_args': dm1801_args, 'c_args': dm1801_args,
'cpp_args': dm1801_args,
'link_args' : ['-Wl,-T../platform/mcu/MK22FN512xxx12/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/MK22FN512xxx12/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories':dm1801_inc} 'include_directories':dm1801_inc}
md9600_opts = {'sources': md9600_src, md9600_opts = {'sources': md9600_src,
'c_args': md9600_args, 'c_args': md9600_args,
'cpp_args': md9600_args,
'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld', 'link_args' : ['-Wl,-T../platform/mcu/STM32F4xx/linker_script.ld',
'-Wl,--print-memory-usage'], '-Wl,--print-memory-usage'],
'include_directories': md9600_inc} 'include_directories': md9600_inc}

2
openrtx/include/event.h
Wyświetl plik

@ -48,7 +48,7 @@ typedef union
payload : 30; payload : 30;
}; };
void *value; uint32_t value;
}event_t; }event_t;
#endif /* EVENT_H */ #endif /* EVENT_H */

26
openrtx/include/queue.h 100644
Wyświetl plik

@ -0,0 +1,26 @@
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
// Ring buffer size (MAX = 255)
#define MSG_QTY 10
typedef struct queue_t
{
pthread_mutex_t mutex;
pthread_cond_t not_empty;
uint8_t read_pos;
uint8_t write_pos;
uint8_t msg_num;
uint32_t buffer[MSG_QTY];
} queue_t;
void queue_init(queue_t *q);
void queue_terminate(queue_t *q);
bool queue_pend(queue_t *q, uint32_t *msg, bool blocking);
bool queue_post(queue_t *q, uint32_t msg);

52
openrtx/include/threads.h
Wyświetl plik

@ -28,7 +28,7 @@
*/ */
void create_threads(); void create_threads();
#ifdef __arm__ // #ifdef __arm__
/** /**
* Stack size for UI task, in bytes. * Stack size for UI task, in bytes.
@ -55,30 +55,30 @@ void create_threads();
*/ */
#define GPS_TASK_STKSIZE 2048 #define GPS_TASK_STKSIZE 2048
#else /* __arm__ */ // #else /* __arm__ */
//
#define UI_TASK_STKSIZE 4096 // #define UI_TASK_STKSIZE 4096
//
/** // /**
* Stack size for Keyboard task, in bytes. // * Stack size for Keyboard task, in bytes.
*/ // */
#define KBD_TASK_STKSIZE 256 // #define KBD_TASK_STKSIZE 256
//
/** // /**
* Stack size for device update task, in bytes. // * Stack size for device update task, in bytes.
*/ // */
#define DEV_TASK_STKSIZE 1024 // #define DEV_TASK_STKSIZE 1024
//
/** // /**
* Stack size for baseband control task, in bytes. // * Stack size for baseband control task, in bytes.
*/ // */
#define RTX_TASK_STKSIZE 1024 // #define RTX_TASK_STKSIZE 1024
//
/** // /**
* Stack size for GPS task, in bytes. // * Stack size for GPS task, in bytes.
*/ // */
#define GPS_TASK_STKSIZE 1024 // #define GPS_TASK_STKSIZE 1024
//
#endif /* __arm__ */ // #endif /* __arm__ */
#endif /* THREADS_H */ #endif /* THREADS_H */

1
openrtx/src/graphics.c
Wyświetl plik

@ -22,7 +22,6 @@
* It is suitable for both color, grayscale and B/W display * It is suitable for both color, grayscale and B/W display
*/ */
#include <os.h>
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>

8
openrtx/src/main.c
Wyświetl plik

@ -18,7 +18,6 @@
* along with this program; if not, see <http://www.gnu.org/licenses/> * * along with this program; if not, see <http://www.gnu.org/licenses/> *
***************************************************************************/ ***************************************************************************/
#include <os.h>
#include <ui.h> #include <ui.h>
#include <stdlib.h> #include <stdlib.h>
#include <inttypes.h> #include <inttypes.h>
@ -26,12 +25,11 @@
#include <interfaces/platform.h> #include <interfaces/platform.h>
#include <battery.h> #include <battery.h>
#include <interfaces/graphics.h> #include <interfaces/graphics.h>
#include <interfaces/delays.h>
#include <hwconfig.h> #include <hwconfig.h>
int main(void) int main(void)
{ {
OS_ERR os_err;
// Initialize platform drivers // Initialize platform drivers
platform_init(); platform_init();
@ -46,11 +44,11 @@ int main(void)
gfx_render(); gfx_render();
// Wait 30ms before turning on backlight to hide random pixels on screen // Wait 30ms before turning on backlight to hide random pixels on screen
OSTimeDlyHMSM(0u, 0u, 0u, 30u, OS_OPT_TIME_HMSM_STRICT, &os_err); sleepFor(0u, 30u);
platform_setBacklightLevel(255); platform_setBacklightLevel(255);
// Keep the splash screen for 1 second // Keep the splash screen for 1 second
OSTimeDlyHMSM(0u, 0u, 1u, 0u, OS_OPT_TIME_HMSM_STRICT, &os_err); sleepFor(1u, 0u);
// Create OpenRTX threads // Create OpenRTX threads
create_threads(); create_threads();

68
openrtx/src/queue.c 100644
Wyświetl plik

@ -0,0 +1,68 @@
#include <stdio.h>
#include "queue.h"
void queue_init(queue_t *q) {
if(q == NULL)
return;
pthread_mutex_init(&q->mutex, NULL);
pthread_cond_init(&q->not_empty, NULL);
q->read_pos = 0;
q->write_pos = 0;
q->msg_num = 0;
}
void queue_terminate(queue_t *q) {
if(q == NULL)
return;
pthread_mutex_destroy(&q->mutex);
pthread_cond_destroy(&q->not_empty);
}
bool queue_pend(queue_t *q, uint32_t *msg, bool blocking) {
if((q == NULL) || (msg == NULL))
return false;
pthread_mutex_lock(&q->mutex);
// The queue is empty
if(q->msg_num == 0)
{
if(blocking)
{
while(q->msg_num == 0)
pthread_cond_wait(&q->not_empty, &q->mutex);
}
else
{
pthread_mutex_unlock(&q->mutex);
return false;
}
}
*msg = q->buffer[q->read_pos];
// Wrap around pointer to make a circular buffer
q->read_pos = (q->read_pos + 1) % MSG_QTY;
q->msg_num -= 1;
pthread_mutex_unlock(&q->mutex);
return true;
}
bool queue_post(queue_t *q, uint32_t msg) {
if(q == NULL)
return false;
pthread_mutex_lock(&q->mutex);
if(q->msg_num < MSG_QTY)
{
q->buffer[q->write_pos] = msg;
// Wrap around pointer to make a circular buffer
q->write_pos = (q->write_pos + 1) % MSG_QTY;
// Signal that the queue is not empty
if(q->msg_num == 0)
pthread_cond_signal(&q->not_empty);
q->msg_num += 1;
}
else
{
pthread_mutex_unlock(&q->mutex);
return false;
}
pthread_mutex_unlock(&q->mutex);
return true;
}

133
openrtx/src/rtx.c
Wyświetl plik

@ -26,15 +26,15 @@
#include <interfaces/gpio.h> #include <interfaces/gpio.h>
#include <hwconfig.h> #include <hwconfig.h>
OS_MUTEX *cfgMutex; /* Mutex for incoming config messages */ pthread_mutex_t *cfgMutex; /* Mutex for incoming config messages */
OS_Q cfgMailbox; /* Queue for incoming config messages */
rtxStatus_t rtxStatus; /* RTX driver status */ const rtxStatus_t *newCnf; /* Pointer for incoming config messages */
rtxStatus_t rtxStatus; /* RTX driver status */
bool sqlOpen; /* Flag for squelch open/close */ bool sqlOpen; /* Flag for squelch open/close */
bool enterRx; /* Flag for RX mode activation */ bool enterRx; /* Flag for RX mode activation */
float rssi; /* Current RSSI in dBm */ float rssi; /* Current RSSI in dBm */
/* /*
* These functions below provide a basic API for audio path management. They * These functions below provide a basic API for audio path management. They
@ -100,17 +100,11 @@ void _afCtrlTerminate()
} }
void rtx_init(OS_MUTEX *m) void rtx_init(pthread_mutex_t *m)
{ {
/* Initialise mutex for configuration access */ /* Initialise mutex for configuration access */
cfgMutex = m; cfgMutex = m;
newCnf = NULL;
/* Create the message queue for RTX configuration */
OS_ERR err;
OSQCreate((OS_Q *) &cfgMailbox,
(CPU_CHAR *) "",
(OS_MSG_QTY) 1,
(OS_ERR *) &err);
/* /*
* Default initialisation for rtx status * Default initialisation for rtx status
@ -152,28 +146,9 @@ void rtx_terminate()
void rtx_configure(const rtxStatus_t *cfg) void rtx_configure(const rtxStatus_t *cfg)
{ {
OS_ERR err; pthread_mutex_lock(cfgMutex);
OSQPost((OS_Q *) &cfgMailbox, newCnf = cfg;
(void *) cfg, pthread_mutex_unlock(cfgMutex);
(OS_MSG_SIZE) sizeof(rtxStatus_t *),
(OS_OPT ) OS_OPT_POST_FIFO,
(OS_ERR *) &err);
/*
* In case message queue is not empty, flush the old and unread configuration
* and post the new one.
*/
if(err == OS_ERR_Q_MAX)
{
OSQFlush((OS_Q *) &cfgMailbox,
(OS_ERR *) &err);
OSQPost((OS_Q *) &cfgMailbox,
(void *) cfg,
(OS_MSG_SIZE) sizeof(rtxStatus_t *),
(OS_OPT ) OS_OPT_POST_FIFO,
(OS_ERR *) &err);
}
} }
rtxStatus_t rtx_getCurrentStatus() rtxStatus_t rtx_getCurrentStatus()
@ -183,60 +158,54 @@ rtxStatus_t rtx_getCurrentStatus()
void rtx_taskFunc() void rtx_taskFunc()
{ {
OS_ERR err;
OS_MSG_SIZE size;
void *msg = OSQPend((OS_Q *) &cfgMailbox,
(OS_TICK ) 0,
(OS_OPT ) OS_OPT_PEND_NON_BLOCKING,
(OS_MSG_SIZE *) &size,
(CPU_TS *) NULL,
(OS_ERR *) &err);
/* Configuration update logic */ /* Configuration update logic */
if((err == OS_ERR_NONE) && (msg != NULL)) bool reconfigure = false;
if(pthread_mutex_trylock(cfgMutex) == 0)
{ {
/* Try locking mutex for read access */ if(newCnf != NULL)
OSMutexPend(cfgMutex, 0, OS_OPT_PEND_NON_BLOCKING, NULL, &err);
if(err == OS_ERR_NONE)
{ {
/* Copy new configuration and override opStatus flags */ /* Copy new configuration and override opStatus flags */
uint8_t tmp = rtxStatus.opStatus; uint8_t tmp = rtxStatus.opStatus;
memcpy(&rtxStatus, msg, sizeof(rtxStatus_t)); memcpy(&rtxStatus, newCnf, sizeof(rtxStatus_t));
rtxStatus.opStatus = tmp; rtxStatus.opStatus = tmp;
/* Done, release mutex */ reconfigure = true;
OSMutexPost(cfgMutex, OS_OPT_POST_NONE, &err); newCnf = NULL;
/* Update HW configuration */
radio_setOpmode(rtxStatus.opMode);
radio_setBandwidth(rtxStatus.bandwidth);
radio_setCSS(rtxStatus.rxTone, rtxStatus.txTone);
radio_updateCalibrationParams(&rtxStatus);
/*
* If currently transmitting or receiving, update VCO frequency and
* call again enableRx/enableTx.
* This is done because the new configuration may have changed the
* RX and TX frequencies, requiring an update of both the VCO
* settings and of some tuning parameters, like APC voltage, which
* are managed by enableRx/enableTx.
*/
if(rtxStatus.opStatus == TX)
{
radio_setVcoFrequency(rtxStatus.txFrequency, true);
radio_enableTx(rtxStatus.txPower, rtxStatus.txToneEn);
}
if(rtxStatus.opStatus == RX)
{
radio_setVcoFrequency(rtxStatus.rxFrequency, false);
radio_enableRx();
}
/* TODO: temporarily force to RX mode if rtx is off. */
if(rtxStatus.opStatus == OFF) enterRx = true;
} }
pthread_mutex_unlock(cfgMutex);
}
if(reconfigure)
{
/* Update HW configuration */
radio_setOpmode(rtxStatus.opMode);
radio_setBandwidth(rtxStatus.bandwidth);
radio_setCSS(rtxStatus.rxTone, rtxStatus.txTone);
radio_updateCalibrationParams(&rtxStatus);
/*
* If currently transmitting or receiving, update VCO frequency and
* call again enableRx/enableTx.
* This is done because the new configuration may have changed the
* RX and TX frequencies, requiring an update of both the VCO
* settings and of some tuning parameters, like APC voltage, which
* are managed by enableRx/enableTx.
*/
if(rtxStatus.opStatus == TX)
{
radio_setVcoFrequency(rtxStatus.txFrequency, true);
radio_enableTx(rtxStatus.txPower, rtxStatus.txToneEn);
}
if(rtxStatus.opStatus == RX)
{
radio_setVcoFrequency(rtxStatus.rxFrequency, false);
radio_enableRx();
}
/* TODO: temporarily force to RX mode if rtx is off. */
if(rtxStatus.opStatus == OFF) enterRx = true;
} }
/* RX logic */ /* RX logic */

246
openrtx/src/threads.c
Wyświetl plik

@ -19,7 +19,7 @@
***************************************************************************/ ***************************************************************************/
#include <hwconfig.h> #include <hwconfig.h>
#include <os.h> #include <pthread.h>
#include <ui.h> #include <ui.h>
#include <state.h> #include <state.h>
#include <threads.h> #include <threads.h>
@ -27,8 +27,10 @@
#include <interfaces/keyboard.h> #include <interfaces/keyboard.h>
#include <interfaces/graphics.h> #include <interfaces/graphics.h>
#include <interfaces/platform.h> #include <interfaces/platform.h>
#include <interfaces/delays.h>
#include <event.h> #include <event.h>
#include <rtx.h> #include <rtx.h>
#include <queue.h>
#include <minmea.h> #include <minmea.h>
#ifdef HAS_GPS #ifdef HAS_GPS
#include <interfaces/gps.h> #include <interfaces/gps.h>
@ -36,67 +38,31 @@
#endif #endif
/* Mutex for concurrent access to state variable */ /* Mutex for concurrent access to state variable */
static OS_MUTEX state_mutex; pthread_mutex_t state_mutex;
/* Queue for sending and receiving ui update requests */
static OS_Q ui_queue;
/* Mutex for concurrent access to RTX state variable */ /* Mutex for concurrent access to RTX state variable */
static OS_MUTEX rtx_mutex; pthread_mutex_t rtx_mutex;
/* Mutex to avoid reading keyboard during display update */ /* Mutex to avoid reading keyboard during display update */
static OS_MUTEX display_mutex; pthread_mutex_t display_mutex;
/**************************** IMPORTANT NOTE *********************************** /* Queue for sending and receiving ui update requests */
* * queue_t ui_queue;
* Rationale for "xx_TASK_STKSIZE/sizeof(CPU_STK)": uC/OS-III manages task *
* stack in terms of CPU_STK elements which, on a 32-bit target, are something *
* like uint32_t, that is, one CPU_STK elements takes four bytes. *
* *
* Now, the majority of the world manages stack in terms of *bytes* and this *
* leads to an excessive RAM usage if not properly managed. For example, if *
* we have, say, xx_TASK_SIZE = 128 with these odd CPU_STK elements we end *
* up eating 128*4 = 512 bytes. *
* The simple workaround for this is dividing the stack size by sizeof(CPU_STK)*
*******************************************************************************/
/* UI task control block and stack */
static OS_TCB ui_tcb;
static CPU_STK ui_stk[UI_TASK_STKSIZE/sizeof(CPU_STK)];
/* Keyboard task control block and stack */
static OS_TCB kbd_tcb;
static CPU_STK kbd_stk[KBD_TASK_STKSIZE/sizeof(CPU_STK)];
/* Device task control block and stack */
static OS_TCB dev_tcb;
static CPU_STK dev_stk[DEV_TASK_STKSIZE/sizeof(CPU_STK)];
/* Baseband task control block and stack */
static OS_TCB rtx_tcb;
static CPU_STK rtx_stk[RTX_TASK_STKSIZE/sizeof(CPU_STK)];
#ifdef HAS_GPS
/* GPS task control block and stack */
static OS_TCB gps_tcb;
static CPU_STK gps_stk[GPS_TASK_STKSIZE/sizeof(CPU_STK)];
#endif
/** /**
* \internal Task function in charge of updating the UI. * \internal Task function in charge of updating the UI.
*/ */
static void ui_task(void *arg) void *ui_task(void *arg)
{ {
(void) arg; (void) arg;
OS_ERR os_err;
OS_MSG_SIZE msg_size = 0;
rtxStatus_t rtx_cfg;
// RTX needs synchronization // RTX needs synchronization
bool sync_rtx = true; bool sync_rtx = true;
rtxStatus_t rtx_cfg;
// Get initial state local copy // Get initial state local copy
OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); // OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err);
OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err); // OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err);
// Initial GUI draw // Initial GUI draw
ui_updateGUI(last_state); ui_updateGUI(last_state);
@ -106,23 +72,23 @@ static void ui_task(void *arg)
{ {
// Read from the keyboard queue (returns 0 if no message is present) // Read from the keyboard queue (returns 0 if no message is present)
// Copy keyboard_t keys from received void * pointer msg // Copy keyboard_t keys from received void * pointer msg
void *msg = OSQPend(&ui_queue, 0u, OS_OPT_PEND_BLOCKING, event_t event;
&msg_size, 0u, &os_err); event.value = 0;
event_t event = ((event_t) msg); (void) queue_pend(&ui_queue, &event.value, true);
// Lock mutex, read and write state // Lock mutex, read and write state
OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); pthread_mutex_lock(&state_mutex);
// React to keypresses and update FSM inside state // React to keypresses and update FSM inside state
ui_updateFSM(event, &sync_rtx); ui_updateFSM(event, &sync_rtx);
// Update state local copy // Update state local copy
ui_saveState(); ui_saveState();
// Unlock mutex // Unlock mutex
OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&state_mutex);
// If synchronization needed take mutex and update RTX configuration // If synchronization needed take mutex and update RTX configuration
if(sync_rtx) if(sync_rtx)
{ {
OSMutexPend(&rtx_mutex, 0, OS_OPT_PEND_BLOCKING, NULL, &os_err); pthread_mutex_lock(&rtx_mutex);
rtx_cfg.opMode = state.channel.mode; rtx_cfg.opMode = state.channel.mode;
rtx_cfg.bandwidth = state.channel.bandwidth; rtx_cfg.bandwidth = state.channel.bandwidth;
rtx_cfg.rxFrequency = state.channel.rx_frequency; rtx_cfg.rxFrequency = state.channel.rx_frequency;
@ -133,7 +99,7 @@ static void ui_task(void *arg)
rtx_cfg.rxTone = ctcss_tone[state.channel.fm.rxTone]; rtx_cfg.rxTone = ctcss_tone[state.channel.fm.rxTone];
rtx_cfg.txToneEn = state.channel.fm.txToneEn; rtx_cfg.txToneEn = state.channel.fm.txToneEn;
rtx_cfg.txTone = ctcss_tone[state.channel.fm.txTone]; rtx_cfg.txTone = ctcss_tone[state.channel.fm.txTone];
OSMutexPost(&rtx_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&rtx_mutex);
rtx_configure(&rtx_cfg); rtx_configure(&rtx_cfg);
sync_rtx = false; sync_rtx = false;
@ -142,9 +108,9 @@ static void ui_task(void *arg)
// Redraw GUI based on last state copy // Redraw GUI based on last state copy
ui_updateGUI(); ui_updateGUI();
// Lock display mutex and render display // Lock display mutex and render display
OSMutexPend(&display_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); pthread_mutex_lock(&display_mutex);
gfx_render(); gfx_render();
OSMutexPost(&display_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&display_mutex);
// We don't need a delay because we lock on incoming events // We don't need a delay because we lock on incoming events
// TODO: Enable self refresh when a continuous visualization is enabled // TODO: Enable self refresh when a continuous visualization is enabled
@ -156,17 +122,16 @@ static void ui_task(void *arg)
/** /**
* \internal Task function for reading and sending keyboard status. * \internal Task function for reading and sending keyboard status.
*/ */
static void kbd_task(void *arg) void *kbd_task(void *arg)
{ {
(void) arg; (void) arg;
OS_ERR os_err;
// Initialize keyboard driver // Initialize keyboard driver
kbd_init(); kbd_init();
// Allocate timestamp array // Allocate timestamp array
OS_TICK key_ts[kbd_num_keys]; long long key_ts[kbd_num_keys];
OS_TICK now; long long now;
// Allocate bool array to send only one long-press event // Allocate bool array to send only one long-press event
bool long_press_sent[kbd_num_keys]; bool long_press_sent[kbd_num_keys];
@ -183,10 +148,10 @@ static void kbd_task(void *arg)
long_press = false; long_press = false;
send_event = false; send_event = false;
// Lock display mutex and read keyboard status // Lock display mutex and read keyboard status
OSMutexPend(&display_mutex, 0u, OS_OPT_PEND_NON_BLOCKING, 0u, &os_err); pthread_mutex_lock(&display_mutex);
keys = kbd_getKeys(); keys = kbd_getKeys();
OSMutexPost(&display_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&display_mutex);
now = OSTimeGet(&os_err); now = getTick();
// The key status has changed // The key status has changed
if(keys != prev_keys) if(keys != prev_keys)
{ {
@ -232,29 +197,27 @@ static void kbd_task(void *arg)
event.type = EVENT_KBD; event.type = EVENT_KBD;
event.payload = msg.value; event.payload = msg.value;
// Send keyboard status in queue // Send keyboard status in queue
OSQPost(&ui_queue, (void *)event.value, sizeof(event_t), (void) queue_post(&ui_queue, event.value);
OS_OPT_POST_FIFO + OS_OPT_POST_NO_SCHED, &os_err);
} }
// Save current keyboard state as previous // Save current keyboard state as previous
prev_keys = keys; prev_keys = keys;
// Read keyboard state at 20Hz // Read keyboard state at 20Hz
OSTimeDlyHMSM(0u, 0u, 0u, 50u, OS_OPT_TIME_HMSM_STRICT, &os_err); sleepFor(0u, 50u);
} }
} }
/** /**
* \internal Task function in charge of updating the radio state. * \internal Task function in charge of updating the radio state.
*/ */
static void dev_task(void *arg) void *dev_task(void *arg)
{ {
(void) arg; (void) arg;
OS_ERR os_err;
while(1) while(1)
{ {
// Lock mutex and update internal state // Lock mutex and update internal state
OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); pthread_mutex_lock(&state_mutex);
#ifdef HAS_RTC #ifdef HAS_RTC
state.time = rtc_getTime(); state.time = rtc_getTime();
@ -268,34 +231,32 @@ static void dev_task(void *arg)
state.charge = battery_getCharge(state.v_bat); state.charge = battery_getCharge(state.v_bat);
state.rssi = rtx_getRssi(); state.rssi = rtx_getRssi();
OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&state_mutex);
// Signal state update to UI thread // Signal state update to UI thread
event_t dev_msg; event_t dev_msg;
dev_msg.type = EVENT_STATUS; dev_msg.type = EVENT_STATUS;
dev_msg.payload = 0; dev_msg.payload = 0;
OSQPost(&ui_queue, (void *)dev_msg.value, sizeof(event_t), (void) queue_post(&ui_queue, dev_msg.value);
OS_OPT_POST_FIFO + OS_OPT_POST_NO_SCHED, &os_err);
// Execute state update thread every 1s // Execute state update thread every 1s
OSTimeDlyHMSM(0u, 0u, 1u, 0u, OS_OPT_TIME_HMSM_STRICT, &os_err); sleepFor(1u, 0u);
} }
} }
/** /**
* \internal Task function for RTX management. * \internal Task function for RTX management.
*/ */
static void rtx_task(void *arg) void *rtx_task(void *arg)
{ {
(void) arg; (void) arg;
OS_ERR os_err;
rtx_init(&rtx_mutex); rtx_init(&rtx_mutex);
while(1) while(1)
{ {
rtx_taskFunc(); rtx_taskFunc();
OSTimeDlyHMSM(0u, 0u, 0u, 30u, OS_OPT_TIME_HMSM_STRICT, &os_err); sleepFor(0u, 30u);
} }
} }
@ -303,20 +264,19 @@ static void rtx_task(void *arg)
/** /**
* \internal Task function for parsing GPS data and updating radio state. * \internal Task function for parsing GPS data and updating radio state.
*/ */
static void gps_task(void *arg) void *gps_task(void *arg)
{ {
(void) arg; (void) arg;
OS_ERR os_err;
char line[MINMEA_MAX_LENGTH*10]; char line[MINMEA_MAX_LENGTH*10];
if (!gps_detect(5000)) if (!gps_detect(5000)) return NULL;
return;
gps_init(9600); gps_init(9600);
// Lock mutex to read internal state // Lock mutex to read internal state
OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); pthread_mutex_lock(&state_mutex);
bool enabled = state.settings.gps_enabled; bool enabled = state.settings.gps_enabled;
OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&state_mutex);
if(enabled) if(enabled)
gps_enable(); gps_enable();
else else
@ -328,13 +288,13 @@ static void gps_task(void *arg)
if(len != -1) if(len != -1)
{ {
// Lock mutex and update internal state // Lock mutex and update internal state
OSMutexPend(&state_mutex, 0u, OS_OPT_PEND_BLOCKING, 0u, &os_err); pthread_mutex_lock(&state_mutex);
// GPS readout is blocking, no need to delay here // GPS readout is blocking, no need to delay here
gps_taskFunc(line, len, &state); gps_taskFunc(line, len, &state);
// Unlock state mutex // Unlock state mutex
OSMutexPost(&state_mutex, OS_OPT_POST_NONE, &os_err); pthread_mutex_unlock(&state_mutex);
} }
} }
} }
@ -345,107 +305,61 @@ static void gps_task(void *arg)
*/ */
void create_threads() void create_threads()
{ {
OS_ERR os_err;
// Create state mutex // Create state mutex
OSMutexCreate((OS_MUTEX *) &state_mutex, pthread_mutex_init(&state_mutex, NULL);
(CPU_CHAR *) "State Mutex",
(OS_ERR *) &os_err);
// Create UI event queue
OSQCreate((OS_Q *) &ui_queue,
(CPU_CHAR *) "UI event queue",
(OS_MSG_QTY ) 10,
(OS_ERR *) &os_err);
// Create RTX state mutex // Create RTX state mutex
OSMutexCreate((OS_MUTEX *) &rtx_mutex, pthread_mutex_init(&rtx_mutex, NULL);
(CPU_CHAR *) "RTX Mutex",
(OS_ERR *) &os_err);
// Create display mutex // Create display mutex
OSMutexCreate((OS_MUTEX *) &display_mutex, pthread_mutex_init(&display_mutex, NULL);
(CPU_CHAR *) "Display Mutex",
(OS_ERR *) &os_err); // Create UI event queue
queue_init(&ui_queue);
// State initialization, execute before starting all tasks // State initialization, execute before starting all tasks
state_init(); state_init();
// Create rtx radio thread // Create rtx radio thread
OSTaskCreate((OS_TCB *) &rtx_tcb, pthread_t rtx_thread;
(CPU_CHAR *) "RTX Task", pthread_attr_t rtx_attr;
(OS_TASK_PTR ) rtx_task,
(void *) 0, pthread_attr_init(&rtx_attr);
(OS_PRIO ) 5, pthread_attr_setstacksize(&rtx_attr, RTX_TASK_STKSIZE);
(CPU_STK *) &rtx_stk[0], pthread_create(&rtx_thread, &rtx_attr, rtx_task, NULL);
(CPU_STK ) 0,
(CPU_STK_SIZE) RTX_TASK_STKSIZE/sizeof(CPU_STK),
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT ) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *) &os_err);
// Create UI thread // Create UI thread
OSTaskCreate((OS_TCB *) &ui_tcb, pthread_t ui_thread;
(CPU_CHAR *) "UI Task", pthread_attr_t ui_attr;
(OS_TASK_PTR ) ui_task,
(void *) 0, pthread_attr_init(&ui_attr);
(OS_PRIO ) 10, pthread_attr_setstacksize(&ui_attr, UI_TASK_STKSIZE);
(CPU_STK *) &ui_stk[0], pthread_create(&ui_thread, &ui_attr, ui_task, NULL);
(CPU_STK ) 0,
(CPU_STK_SIZE) UI_TASK_STKSIZE/sizeof(CPU_STK),
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT ) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *) &os_err);
// Create Keyboard thread // Create Keyboard thread
OSTaskCreate((OS_TCB *) &kbd_tcb, pthread_t kbd_thread;
(CPU_CHAR *) "Keyboard Task", pthread_attr_t kbd_attr;
(OS_TASK_PTR ) kbd_task,
(void *) 0, pthread_attr_init(&kbd_attr);
(OS_PRIO ) 20, pthread_attr_setstacksize(&kbd_attr, KBD_TASK_STKSIZE);
(CPU_STK *) &kbd_stk[0], // pthread_create(&kbd_thread, &kbd_attr, kbd_task, NULL);
(CPU_STK ) 0,
(CPU_STK_SIZE) KBD_TASK_STKSIZE/4,
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT ) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *) &os_err);
#ifdef HAS_GPS #ifdef HAS_GPS
// Create GPS thread // Create GPS thread
OSTaskCreate((OS_TCB *) &gps_tcb, pthread_t gps_thread;
(CPU_CHAR *) "GPS Task", pthread_attr_t gps_attr;
(OS_TASK_PTR ) gps_task,
(void *) 0, pthread_attr_init(&gps_attr);
(OS_PRIO ) 25, pthread_attr_setstacksize(&gps_attr, GPS_TASK_STKSIZE);
(CPU_STK *) &gps_stk[0], // pthread_create(&gps_thread, &gps_attr, gps_task, NULL);
(CPU_STK ) 0,
(CPU_STK_SIZE) GPS_TASK_STKSIZE/sizeof(CPU_STK),
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT ) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *) &os_err);
#endif #endif
// Create state thread // Create state thread
OSTaskCreate((OS_TCB *) &dev_tcb, pthread_t state_thread;
(CPU_CHAR *) "Device Task", pthread_attr_t state_attr;
(OS_TASK_PTR ) dev_task,
(void *) 0,
(OS_PRIO ) 30,
(CPU_STK *) &dev_stk[0],
(CPU_STK ) 0,
(CPU_STK_SIZE) DEV_TASK_STKSIZE/sizeof(CPU_STK),
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT ) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *) &os_err);
pthread_attr_init(&state_attr);
pthread_attr_setstacksize(&state_attr, DEV_TASK_STKSIZE);
// pthread_create(&state_thread, &state_attr, dev_task, NULL);
} }

3
platform/mcu/STM32F4xx/boot/bsp.cpp
Wyświetl plik

@ -28,6 +28,7 @@
#include <kernel/kernel.h> #include <kernel/kernel.h>
#include <kernel/sync.h> #include <kernel/sync.h>
#include <hwconfig.h> #include <hwconfig.h>
#include "../drivers/usb_vcom.h"
namespace miosix namespace miosix
{ {
@ -53,7 +54,7 @@ void IRQbspInit()
void bspInit2() void bspInit2()
{ {
vcom_init();
} }
// //

28
platform/mcu/STM32F4xx/boot/libc_integration.cpp
Wyświetl plik

@ -17,6 +17,7 @@
#include <stdio.h> #include <stdio.h>
#include <reent.h> #include <reent.h>
#include "../drivers/usb_vcom.h"
#include "filesystem/file_access.h" #include "filesystem/file_access.h"
using namespace std; using namespace std;
@ -31,11 +32,11 @@ extern "C" {
*/ */
int _write_r(struct _reent *ptr, int fd, const void *buf, size_t cnt) int _write_r(struct _reent *ptr, int fd, const void *buf, size_t cnt)
{ {
// if(fd == STDOUT_FILENO || fd == STDERR_FILENO) if(fd == STDOUT_FILENO || fd == STDERR_FILENO)
// { {
// vcom_writeBlock(buf, cnt); vcom_writeBlock(buf, cnt);
// return cnt; return cnt;
// } }
/* If fd is not stdout or stderr */ /* If fd is not stdout or stderr */
ptr->_errno = EBADF; ptr->_errno = EBADF;
@ -48,15 +49,14 @@ int _write_r(struct _reent *ptr, int fd, const void *buf, size_t cnt)
*/ */
int _read_r(struct _reent *ptr, int fd, void *buf, size_t cnt) int _read_r(struct _reent *ptr, int fd, void *buf, size_t cnt)
{ {
// if(fd == STDIN_FILENO) if(fd == STDIN_FILENO)
// { {
// for(;;) for(;;)
// { {
// ssize_t r = vcom_readBlock(buf, cnt); ssize_t r = vcom_readBlock(buf, cnt);
// if((r < 0) || (r == (ssize_t)(cnt))) return r; if((r < 0) || (r == (ssize_t)(cnt))) return r;
// } }
// } }
// else
/* If fd is not stdin */ /* If fd is not stdin */
ptr->_errno = EBADF; ptr->_errno = EBADF;

13
platform/mcu/STM32F4xx/drivers/usb/usb_bsp.c
Wyświetl plik

@ -4,7 +4,7 @@
* @author MCD Application Team * @author MCD Application Team
* @version V1.1.0 * @version V1.1.0
* @date 19-March-2012 * @date 19-March-2012
* @brief This file is responsible to offer board support package and is * @brief This file is responsible to offer board support package and is
* configurable by user. * configurable by user.
****************************************************************************** ******************************************************************************
* @attention * @attention
@ -17,21 +17,20 @@
* *
* http://www.st.com/software_license_agreement_liberty_v2 * http://www.st.com/software_license_agreement_liberty_v2
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
* *
****************************************************************************** ******************************************************************************
*/ */
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "usb_bsp.h" #include "usb_bsp.h"
#include "usbd_conf.h" #include "usbd_conf.h"
#include "stm32f4xx.h" #include "stm32f4xx.h"
#include <interfaces/gpio.h> #include <interfaces/gpio.h>
#include <os.h>
#include <interfaces/delays.h> #include <interfaces/delays.h>
extern USB_OTG_CORE_HANDLE USB_OTG_dev; extern USB_OTG_CORE_HANDLE USB_OTG_dev;
@ -98,10 +97,8 @@ void USB_OTG_BSP_mDelay (const uint32_t msec)
delayMs(msec); delayMs(msec);
} }
void OTG_FS_IRQHandler(void) void _Z17OTG_FS_IRQHandlerv(void)
{ {
OSIntEnter();
USBD_OTG_ISR_Handler (&USB_OTG_dev); USBD_OTG_ISR_Handler (&USB_OTG_dev);
OSIntExit();
} }

8
platform/mcu/STM32F4xx/drivers/usb_vcom.h
Wyświetl plik

@ -22,6 +22,10 @@
#include <unistd.h> #include <unistd.h>
#include "stm32f4xx.h" #include "stm32f4xx.h"
#ifdef __cplusplus
extern "C" {
#endif
/** /**
* Size of the reception buffer for incoming data from the USB host, in bytes. * Size of the reception buffer for incoming data from the USB host, in bytes.
* NOTE: value is equal to the size of one USB bulk transfer, do not change * NOTE: value is equal to the size of one USB bulk transfer, do not change
@ -53,4 +57,8 @@ ssize_t vcom_writeBlock(const void *buf, size_t len);
*/ */
ssize_t vcom_readBlock(void *buf, size_t len); ssize_t vcom_readBlock(void *buf, size_t len);
#ifdef __cplusplus
}
#endif
#endif /* USB_VCOM_H */ #endif /* USB_VCOM_H */