rooty/LibrePilot
1
0
Fork 0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2025-02-17 07:54:17 +01:00
Code Issues Releases Activity

OP-943 uses pios_mem API for heap allocation

Browse Source
This commit is contained in:
Alessio Morale 2014-06-11 20:11:48 +02:00
parent 50bef2dc12
commit 6226aec2a7
73 changed files with 155 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
flight/libraries/WorldMagModel.c
View File

@ -40,7 +40,6 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
// I don't want this dependency, but currently using pvPortMalloc
#include "openpilot.h"
#include <stdio.h>
@ -52,7 +51,7 @@
#include "WorldMagModel.h"
#include "WMMInternal.h"
#define MALLOC(x) pvPortMalloc(x)
#define MALLOC(x) pios_malloc(x)
#define FREE(x) vPortFree(x)
// #define MALLOC(x) malloc(x)
// #define FREE(x) free(x)

2
flight/libraries/math/sin_lookup.c
View File

@ -78,7 +78,7 @@ int sin_lookup_initalize()
return 0;
}
sin_table = (float *)pvPortMalloc(sizeof(float) * SIN_RESOLUTION);
sin_table = (float *)pios_malloc(sizeof(float) * SIN_RESOLUTION);
if (sin_table == NULL) {
return -1;
}

2
flight/modules/Airspeed/gps_airspeed.c
View File

@ -73,7 +73,7 @@ static inline float Sq(float x)
void gps_airspeedInitialize()
{
// This method saves memory in case we don't use the GPS module.
gps = (struct GPSGlobals *)pvPortMalloc(sizeof(struct GPSGlobals));
gps = (struct GPSGlobals *)pios_malloc(sizeof(struct GPSGlobals));
// GPS airspeed calculation variables
VelocityStateInitialize();

2
flight/modules/CameraStab/camerastab.c
View File

@ -110,7 +110,7 @@ int32_t CameraStabInitialize(void)
if (cameraStabEnabled) {
// allocate and initialize the static data storage only if module is enabled
csd = (struct CameraStab_data *)pvPortMalloc(sizeof(struct CameraStab_data));
csd = (struct CameraStab_data *)pios_malloc(sizeof(struct CameraStab_data));
if (!csd) {
return -1;
}

4
flight/modules/ComUsbBridge/ComUsbBridge.c
View File

@ -115,9 +115,9 @@ static int32_t comUsbBridgeInitialize(void)
#endif
if (bridge_enabled) {
com2usb_buf = pvPortMalloc(BRIDGE_BUF_LEN);
com2usb_buf = pios_malloc(BRIDGE_BUF_LEN);
PIOS_Assert(com2usb_buf);
usb2com_buf = pvPortMalloc(BRIDGE_BUF_LEN);
usb2com_buf = pios_malloc(BRIDGE_BUF_LEN);
PIOS_Assert(usb2com_buf);
updateSettings();

4
flight/modules/Fault/Fault.c
View File

@ -73,7 +73,7 @@ static int32_t fault_initialize(void)
break;
case FAULTSETTINGS_ACTIVATEFAULT_INITOUTOFMEMORY:
/* Leak all available memory */
while (pvPortMalloc(10)) {
while (pios_malloc(10)) {
;
}
break;
@ -126,7 +126,7 @@ static void fault_task(__attribute__((unused)) void *parameters)
break;
case FAULTSETTINGS_ACTIVATEFAULT_TASKOUTOFMEMORY:
/* Leak all available memory and then sleep */
while (pvPortMalloc(10)) {
while (pios_malloc(10)) {
;
}
while (1) {

2
flight/modules/FirmwareIAP/firmwareiap.c
View File

@ -193,7 +193,7 @@ static void FirmwareIAPCallback(UAVObjEvent *ev)
/* Note: Cant just wait timeout value, because first time is randomized */
reset_count = 0;
lastResetSysTime = xTaskGetTickCount();
UAVObjEvent *event = pvPortMalloc(sizeof(UAVObjEvent));
UAVObjEvent *event = pios_malloc(sizeof(UAVObjEvent));
memset(event, 0, sizeof(UAVObjEvent));
EventPeriodicCallbackCreate(event, resetTask, 100);
iap_state = IAP_STATE_RESETTING;

4
flight/modules/GPS/GPS.c
View File

@ -175,10 +175,10 @@ int32_t GPSInitialize(void)
GPSSettingsDataProtocolGet(&gpsProtocol);
switch (gpsProtocol) {
case GPSSETTINGS_DATAPROTOCOL_NMEA:
gps_rx_buffer = pvPortMalloc(NMEA_MAX_PACKET_LENGTH);
gps_rx_buffer = pios_malloc(NMEA_MAX_PACKET_LENGTH);
break;
case GPSSETTINGS_DATAPROTOCOL_UBX:
gps_rx_buffer = pvPortMalloc(sizeof(struct UBXPacket));
gps_rx_buffer = pios_malloc(sizeof(struct UBXPacket));
break;
default:
gps_rx_buffer = NULL;

2
flight/modules/Logging/Logging.c
View File

@ -58,7 +58,7 @@ int32_t LoggingInitialize(void)
DebugLogEntryInitialize();
FlightStatusInitialize();
PIOS_DEBUGLOG_Initialize();
entry = pvPortMalloc(sizeof(DebugLogEntryData));
entry = pios_malloc(sizeof(DebugLogEntryData));
if (!entry) {
return -1;
}

2
flight/modules/Osd/osdinput/osdinput.c
View File

@ -102,7 +102,7 @@ int32_t osdinputInitialize(void)
oposdPort = PIOS_COM_OSD;
oposd_rx_buffer = pvPortMalloc(MAX_PACKET_LENGTH);
oposd_rx_buffer = pios_malloc(MAX_PACKET_LENGTH);
PIOS_Assert(oposd_rx_buffer);
return 0;

2
flight/modules/OveroSync/overosync.c
View File

@ -118,7 +118,7 @@ int32_t OveroSyncStart(void)
return -1;
}
overosync = (struct overosync *)pvPortMalloc(sizeof(*overosync));
overosync = (struct overosync *)pios_malloc(sizeof(*overosync));
if (overosync == NULL) {
return -1;
}

2
flight/modules/OveroSync/simulated/overosync.c
View File

@ -106,7 +106,7 @@ int32_t OveroSyncInitialize(void)
*/
int32_t OveroSyncStart(void)
{
overosync = (struct overosync *)pvPortMalloc(sizeof(*overosync));
overosync = (struct overosync *)pios_malloc(sizeof(*overosync));
if (overosync == NULL) {
return -1;
}

2
flight/modules/RadioComBridge/RadioComBridge.c
View File

@ -225,7 +225,7 @@ static int32_t RadioComBridgeStart(void)
static int32_t RadioComBridgeInitialize(void)
{
// allocate and initialize the static data storage only if module is enabled
data = (RadioComBridgeData *)pvPortMalloc(sizeof(RadioComBridgeData));
data = (RadioComBridgeData *)pios_malloc(sizeof(RadioComBridgeData));
if (!data) {
return -1;
}

2
flight/modules/StateEstimation/filterair.c
View File

@ -57,7 +57,7 @@ int32_t filterAirInitialize(stateFilter *handle)
{
handle->init = &init;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}

2
flight/modules/StateEstimation/filteraltitude.c
View File

@ -82,7 +82,7 @@ int32_t filterAltitudeInitialize(stateFilter *handle)
{
handle->init = &init;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
HomeLocationInitialize();
AttitudeStateInitialize();
AltitudeFilterSettingsInitialize();

4
flight/modules/StateEstimation/filterbaro.c
View File

@ -63,7 +63,7 @@ int32_t filterBaroInitialize(stateFilter *handle)
{
handle->init = &initwithgps;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}
@ -71,7 +71,7 @@ int32_t filterBaroiInitialize(stateFilter *handle)
{
handle->init = &initwithoutgps;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}

4
flight/modules/StateEstimation/filtercf.c
View File

@ -106,7 +106,7 @@ int32_t filterCFInitialize(stateFilter *handle)
globalInit();
handle->init = &initwithoutmag;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}
@ -115,7 +115,7 @@ int32_t filterCFMInitialize(stateFilter *handle)
globalInit();
handle->init = &initwithmag;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}

8
flight/modules/StateEstimation/filterekf.c
View File

@ -104,7 +104,7 @@ int32_t filterEKF13iInitialize(stateFilter *handle)
globalInit();
handle->init = &init13i;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}
int32_t filterEKF13Initialize(stateFilter *handle)
@ -112,7 +112,7 @@ int32_t filterEKF13Initialize(stateFilter *handle)
globalInit();
handle->init = &init13;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}
// XXX
@ -123,7 +123,7 @@ int32_t filterEKF16iInitialize(stateFilter *handle)
globalInit();
handle->init = &init13i;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}
int32_t filterEKF16Initialize(stateFilter *handle)
@ -131,7 +131,7 @@ int32_t filterEKF16Initialize(stateFilter *handle)
globalInit();
handle->init = &init13;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
return STACK_REQUIRED;
}

2
flight/modules/StateEstimation/filterlla.c
View File

@ -60,7 +60,7 @@ int32_t filterLLAInitialize(stateFilter *handle)
{
handle->init = &init;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
GPSSettingsInitialize();
GPSPositionSensorInitialize();
HomeLocationInitialize();

2
flight/modules/StateEstimation/filtermag.c
View File

@ -68,7 +68,7 @@ int32_t filterMagInitialize(stateFilter *handle)
{
handle->init = &init;
handle->filter = &filter;
handle->localdata = pvPortMalloc(sizeof(struct data));
handle->localdata = pios_malloc(sizeof(struct data));
HomeLocationInitialize();
return STACK_REQUIRED;
}

2
flight/pios/common/pios_adxl345.c
View File

@ -59,7 +59,7 @@ static struct adxl345_dev *PIOS_ADXL345_alloc(void)
{
struct adxl345_dev *adxl345_dev;
adxl345_dev = (struct adxl345_dev *)pvPortMalloc(sizeof(*adxl345_dev));
adxl345_dev = (struct adxl345_dev *)pios_malloc(sizeof(*adxl345_dev));
if (!adxl345_dev) {
return NULL;
}

2
flight/pios/common/pios_bma180.c
View File

@ -73,7 +73,7 @@ static struct bma180_dev *PIOS_BMA180_alloc(void)
{
struct bma180_dev *bma180_dev;
bma180_dev = (struct bma180_dev *)pvPortMalloc(sizeof(*bma180_dev));
bma180_dev = (struct bma180_dev *)pios_malloc(sizeof(*bma180_dev));
if (!bma180_dev) {
return NULL;
}

4
flight/pios/common/pios_callbackscheduler.c
View File

@ -273,7 +273,7 @@ DelayedCallbackInfo *PIOS_CALLBACKSCHEDULER_Create(
// if given priorityTask does not exist, create it
if (!task) {
// allocate memory if possible
task = (struct DelayedCallbackTaskStruct *)pvPortMalloc(sizeof(struct DelayedCallbackTaskStruct));
task = (struct DelayedCallbackTaskStruct *)pios_malloc(sizeof(struct DelayedCallbackTaskStruct));
if (!task) {
xSemaphoreGiveRecursive(mutex);
return NULL;
@ -329,7 +329,7 @@ DelayedCallbackInfo *PIOS_CALLBACKSCHEDULER_Create(
}
// initialize callback scheduling info
DelayedCallbackInfo *info = (DelayedCallbackInfo *)pvPortMalloc(sizeof(DelayedCallbackInfo));
DelayedCallbackInfo *info = (DelayedCallbackInfo *)pios_malloc(sizeof(DelayedCallbackInfo));
if (!info) {
xSemaphoreGiveRecursive(mutex);
return NULL; // error - not enough memory

2
flight/pios/common/pios_com.c
View File

@ -71,7 +71,7 @@ static struct pios_com_dev *PIOS_COM_alloc(void)
{
struct pios_com_dev *com_dev;
com_dev = (struct pios_com_dev *)pvPortMalloc(sizeof(struct pios_com_dev));
com_dev = (struct pios_com_dev *)pios_malloc(sizeof(struct pios_com_dev));
if (!com_dev) {
return NULL;
}

2
flight/pios/common/pios_debuglog.c
View File

@ -66,7 +66,7 @@ void PIOS_DEBUGLOG_Initialize()
#if defined(PIOS_INCLUDE_FREERTOS)
if (!mutex) {
mutex = xSemaphoreCreateRecursiveMutex();
buffer = pvPortMalloc(sizeof(DebugLogEntryData));
buffer = pios_malloc(sizeof(DebugLogEntryData));
}
#else
buffer = &staticbuffer;

2
flight/pios/common/pios_flash_jedec.c
View File

@ -93,7 +93,7 @@ static struct jedec_flash_dev *PIOS_Flash_Jedec_alloc(void)
{
struct jedec_flash_dev *flash_dev;
flash_dev = (struct jedec_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
flash_dev = (struct jedec_flash_dev *)pios_malloc(sizeof(*flash_dev));
if (!flash_dev) {
return NULL;
}

2
flight/pios/common/pios_flashfs_logfs.c
View File

@ -485,7 +485,7 @@ static struct logfs_state *PIOS_FLASHFS_Logfs_alloc(void)
{
struct logfs_state *logfs;
logfs = (struct logfs_state *)pvPortMalloc(sizeof(*logfs));
logfs = (struct logfs_state *)pios_malloc(sizeof(*logfs));
if (!logfs) {
return NULL;
}

2
flight/pios/common/pios_gcsrcvr.c
View File

@ -70,7 +70,7 @@ static struct pios_gcsrcvr_dev *PIOS_gcsrcvr_alloc(void)
{
struct pios_gcsrcvr_dev *gcsrcvr_dev;
gcsrcvr_dev = (struct pios_gcsrcvr_dev *)pvPortMalloc(sizeof(*gcsrcvr_dev));
gcsrcvr_dev = (struct pios_gcsrcvr_dev *)pios_malloc(sizeof(*gcsrcvr_dev));
if (!gcsrcvr_dev) {
return NULL;
}

2
flight/pios/common/pios_hcsr04.c
View File

@ -69,7 +69,7 @@ static struct pios_hcsr04_dev *PIOS_PWM_alloc(void)
{
struct pios_hcsr04_dev *hcsr04_dev;
hcsr04_dev = (struct pios_hcsr04_dev *)pvPortMalloc(sizeof(*hcsr04_dev));
hcsr04_dev = (struct pios_hcsr04_dev *)pios_malloc(sizeof(*hcsr04_dev));
if (!hcsr04_dev) {
return NULL;
}

2
flight/pios/common/pios_l3gd20.c
View File

@ -77,7 +77,7 @@ static struct l3gd20_dev *PIOS_L3GD20_alloc(void)
{
struct l3gd20_dev *l3gd20_dev;
l3gd20_dev = (struct l3gd20_dev *)pvPortMalloc(sizeof(*l3gd20_dev));
l3gd20_dev = (struct l3gd20_dev *)pios_malloc(sizeof(*l3gd20_dev));
if (!l3gd20_dev) {
return NULL;
}

2
flight/pios/common/pios_mpu6000.c
View File

@ -79,7 +79,7 @@ static struct mpu6000_dev *PIOS_MPU6000_alloc(void)
{
struct mpu6000_dev *mpu6000_dev;
mpu6000_dev = (struct mpu6000_dev *)pvPortMalloc(sizeof(*mpu6000_dev));
mpu6000_dev = (struct mpu6000_dev *)pios_malloc(sizeof(*mpu6000_dev));
if (!mpu6000_dev) {
return NULL;
}

2
flight/pios/common/pios_oplinkrcvr.c
View File

@ -70,7 +70,7 @@ static struct pios_oplinkrcvr_dev *PIOS_oplinkrcvr_alloc(void)
{
struct pios_oplinkrcvr_dev *oplinkrcvr_dev;
oplinkrcvr_dev = (struct pios_oplinkrcvr_dev *)pvPortMalloc(sizeof(*oplinkrcvr_dev));
oplinkrcvr_dev = (struct pios_oplinkrcvr_dev *)pios_malloc(sizeof(*oplinkrcvr_dev));
if (!oplinkrcvr_dev) {
return NULL;
}

2
flight/pios/common/pios_rcvr.c
View File

@ -24,7 +24,7 @@ static struct pios_rcvr_dev *PIOS_RCVR_alloc(void)
{
struct pios_rcvr_dev *rcvr_dev;
rcvr_dev = (struct pios_rcvr_dev *)pvPortMalloc(sizeof(*rcvr_dev));
rcvr_dev = (struct pios_rcvr_dev *)pios_malloc(sizeof(*rcvr_dev));
if (!rcvr_dev) {
return NULL;
}

2
flight/pios/common/pios_rfm22b.c
View File

@ -2408,7 +2408,7 @@ static struct pios_rfm22b_dev *pios_rfm22_alloc(void)
{
struct pios_rfm22b_dev *rfm22b_dev;
rfm22b_dev = (struct pios_rfm22b_dev *)pvPortMalloc(sizeof(*rfm22b_dev));
rfm22b_dev = (struct pios_rfm22b_dev *)pios_malloc(sizeof(*rfm22b_dev));
rfm22b_dev->spi_id = 0;
if (!rfm22b_dev) {
return NULL;

2
flight/pios/common/pios_sbus.c
View File

@ -74,7 +74,7 @@ static struct pios_sbus_dev *PIOS_SBus_Alloc(void)
{
struct pios_sbus_dev *sbus_dev;
sbus_dev = (struct pios_sbus_dev *)pvPortMalloc(sizeof(*sbus_dev));
sbus_dev = (struct pios_sbus_dev *)pios_malloc(sizeof(*sbus_dev));
if (!sbus_dev) {
return NULL;
}

2
flight/pios/common/pios_task_monitor.c
View File

@ -46,7 +46,7 @@ int32_t PIOS_TASK_MONITOR_Initialize(uint16_t max_tasks)
return -1;
}
mTaskHandles = (xTaskHandle *)pvPortMalloc(max_tasks * sizeof(xTaskHandle));
mTaskHandles = (xTaskHandle *)pios_malloc(max_tasks * sizeof(xTaskHandle));
if (!mTaskHandles) {
return -1;
}

4
flight/pios/inc/pios_mem.h
View File

@ -29,7 +29,7 @@
#define PIOS_MEM_H
#ifdef PIOS_TARGET_PROVIDES_FAST_HEAP
// relies on pios_general_malloc to perform the allocation (i.e. pios_msheap.c)
extern void *pios_general_malloc(size_t size);
extern void *pios_general_malloc(size_t size, bool fastheap);
inline void *pios_fastheapmalloc(size_t size)
{
@ -44,7 +44,7 @@ inline void *pios_malloc(size_t size)
inline void *pios_free(void *p)
{
return vPortFree(p);
vPortFree(p);
}
#else

2
flight/pios/stm32f10x/pios_adc.c
View File

@ -93,7 +93,7 @@ static struct pios_adc_dev *PIOS_ADC_Allocate()
{
struct pios_adc_dev *adc_dev;
adc_dev = (struct pios_adc_dev *)pvPortMalloc(sizeof(*adc_dev));
adc_dev = (struct pios_adc_dev *)pios_malloc(sizeof(*adc_dev));
if (!adc_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_dsm.c
View File

@ -79,7 +79,7 @@ static struct pios_dsm_dev *PIOS_DSM_Alloc(void)
{
struct pios_dsm_dev *dsm_dev;
dsm_dev = (struct pios_dsm_dev *)pvPortMalloc(sizeof(*dsm_dev));
dsm_dev = (struct pios_dsm_dev *)pios_malloc(sizeof(*dsm_dev));
if (!dsm_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_flash_internal.c
View File

@ -76,7 +76,7 @@ static struct pios_internal_flash_dev *PIOS_Flash_Internal_alloc(void)
{
struct pios_internal_flash_dev *flash_dev;
flash_dev = (struct pios_internal_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
flash_dev = (struct pios_internal_flash_dev *)pios_malloc(sizeof(*flash_dev));
if (!flash_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_i2c.c
View File

@ -835,7 +835,7 @@ static struct pios_i2c_adapter *PIOS_I2C_alloc(void)
{
struct pios_i2c_adapter *i2c_adapter;
i2c_adapter = (struct pios_i2c_adapter *)pvPortMalloc(sizeof(*i2c_adapter));
i2c_adapter = (struct pios_i2c_adapter *)pios_malloc(sizeof(*i2c_adapter));
if (!i2c_adapter) {
return NULL;
}

2
flight/pios/stm32f10x/pios_ppm.c
View File

@ -97,7 +97,7 @@ static struct pios_ppm_dev *PIOS_PPM_alloc(void)
{
struct pios_ppm_dev *ppm_dev;
ppm_dev = (struct pios_ppm_dev *)pvPortMalloc(sizeof(*ppm_dev));
ppm_dev = (struct pios_ppm_dev *)pios_malloc(sizeof(*ppm_dev));
if (!ppm_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_ppm_out.c
View File

@ -73,7 +73,7 @@ static struct pios_ppm_out_dev *PIOS_PPM_OUT_alloc(void)
{
struct pios_ppm_out_dev *ppm_dev;
ppm_dev = (struct pios_ppm_out_dev *)pvPortMalloc(sizeof(*ppm_dev));
ppm_dev = (struct pios_ppm_out_dev *)pios_malloc(sizeof(*ppm_dev));
if (!ppm_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_pwm.c
View File

@ -72,7 +72,7 @@ static struct pios_pwm_dev *PIOS_PWM_alloc(void)
{
struct pios_pwm_dev *pwm_dev;
pwm_dev = (struct pios_pwm_dev *)pvPortMalloc(sizeof(*pwm_dev));
pwm_dev = (struct pios_pwm_dev *)pios_malloc(sizeof(*pwm_dev));
if (!pwm_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_spi.c
View File

@ -48,7 +48,7 @@ static bool PIOS_SPI_validate(__attribute__((unused)) struct pios_spi_dev *com_d
#if defined(PIOS_INCLUDE_FREERTOS)
static struct pios_spi_dev *PIOS_SPI_alloc(void)
{
return pvPortMalloc(sizeof(struct pios_spi_dev));
return pios_malloc(sizeof(struct pios_spi_dev));
}
#else
static struct pios_spi_dev pios_spi_devs[PIOS_SPI_MAX_DEVS];

2
flight/pios/stm32f10x/pios_tim.c
View File

@ -30,7 +30,7 @@ static struct pios_tim_dev *PIOS_TIM_alloc(void)
{
struct pios_tim_dev *tim_dev;
tim_dev = (struct pios_tim_dev *)malloc(sizeof(*tim_dev));
tim_dev = (struct pios_tim_dev *)pios_malloc(sizeof(*tim_dev));
if (!tim_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_usart.c
View File

@ -75,7 +75,7 @@ static struct pios_usart_dev *PIOS_USART_alloc(void)
{
struct pios_usart_dev *usart_dev;
usart_dev = (struct pios_usart_dev *)pvPortMalloc(sizeof(struct pios_usart_dev));
usart_dev = (struct pios_usart_dev *)pios_malloc(sizeof(struct pios_usart_dev));
if (!usart_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_usb.c
View File

@ -74,7 +74,7 @@ static struct pios_usb_dev *PIOS_USB_alloc(void)
{
struct pios_usb_dev *usb_dev;
usb_dev = (struct pios_usb_dev *)pvPortMalloc(sizeof(*usb_dev));
usb_dev = (struct pios_usb_dev *)pios_malloc(sizeof(*usb_dev));
if (!usb_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_usb_cdc.c
View File

@ -90,7 +90,7 @@ static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
{
struct pios_usb_cdc_dev *usb_cdc_dev;
usb_cdc_dev = (struct pios_usb_cdc_dev *)pvPortMalloc(sizeof(struct pios_usb_cdc_dev));
usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_malloc(sizeof(struct pios_usb_cdc_dev));
if (!usb_cdc_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_usb_hid.c
View File

@ -84,7 +84,7 @@ static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
{
struct pios_usb_hid_dev *usb_hid_dev;
usb_hid_dev = (struct pios_usb_hid_dev *)pvPortMalloc(sizeof(struct pios_usb_hid_dev));
usb_hid_dev = (struct pios_usb_hid_dev *)pios_malloc(sizeof(struct pios_usb_hid_dev));
if (!usb_hid_dev) {
return NULL;
}

2
flight/pios/stm32f10x/pios_usb_rctx.c
View File

@ -65,7 +65,7 @@ static struct pios_usb_rctx_dev *PIOS_USB_RCTX_alloc(void)
{
struct pios_usb_rctx_dev *usb_rctx_dev;
usb_rctx_dev = (struct pios_usb_rctx_dev *)pvPortMalloc(sizeof(*usb_rctx_dev));
usb_rctx_dev = (struct pios_usb_rctx_dev *)pios_malloc(sizeof(*usb_rctx_dev));
if (!usb_rctx_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_adc.c
View File

@ -238,7 +238,7 @@ static struct pios_adc_dev *PIOS_ADC_Allocate()
{
struct pios_adc_dev *adc_dev;
adc_dev = (struct pios_adc_dev *)pvPortMalloc(sizeof(*adc_dev));
adc_dev = (struct pios_adc_dev *)pios_malloc(sizeof(*adc_dev));
if (!adc_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_dsm.c
View File

@ -82,7 +82,7 @@ static struct pios_dsm_dev *PIOS_DSM_Alloc(void)
{
struct pios_dsm_dev *dsm_dev;
dsm_dev = (struct pios_dsm_dev *)pvPortMalloc(sizeof(*dsm_dev));
dsm_dev = (struct pios_dsm_dev *)pios_malloc(sizeof(*dsm_dev));
if (!dsm_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_flash_internal.c
View File

@ -141,7 +141,7 @@ static struct pios_internal_flash_dev *PIOS_Flash_Internal_alloc(void)
{
struct pios_internal_flash_dev *flash_dev;
flash_dev = (struct pios_internal_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
flash_dev = (struct pios_internal_flash_dev *)pios_malloc(sizeof(*flash_dev));
if (!flash_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_i2c.c
View File

@ -903,7 +903,7 @@ static struct pios_i2c_dev *PIOS_I2C_alloc(void)
{
struct pios_i2c_dev *i2c_adapter;
i2c_adapter = (struct pios_i2c_adapter *)malloc(sizeof(*i2c_adapter));
i2c_adapter = (struct pios_i2c_adapter *)pios_malloc(sizeof(*i2c_adapter));
if (!i2c_adapter) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_overo.c
View File

@ -98,7 +98,7 @@ static struct pios_overo_dev *PIOS_OVERO_alloc(void)
{
struct pios_overo_dev *overo_dev;
overo_dev = (struct pios_overo_dev *)pvPortMalloc(sizeof(*overo_dev));
overo_dev = (struct pios_overo_dev *)pios_malloc(sizeof(*overo_dev));
if (!overo_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_ppm.c
View File

@ -92,7 +92,7 @@ static struct pios_ppm_dev *PIOS_PPM_alloc(void)
{
struct pios_ppm_dev *ppm_dev;
ppm_dev = (struct pios_ppm_dev *)pvPortMalloc(sizeof(*ppm_dev));
ppm_dev = (struct pios_ppm_dev *)pios_malloc(sizeof(*ppm_dev));
if (!ppm_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_pwm.c
View File

@ -71,7 +71,7 @@ static struct pios_pwm_dev *PIOS_PWM_alloc(void)
{
struct pios_pwm_dev *pwm_dev;
pwm_dev = (struct pios_pwm_dev *)pvPortMalloc(sizeof(*pwm_dev));
pwm_dev = (struct pios_pwm_dev *)pios_malloc(sizeof(*pwm_dev));
if (!pwm_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_spi.c
View File

@ -53,7 +53,7 @@ static bool PIOS_SPI_validate(__attribute__((unused)) struct pios_spi_dev *com_d
#if defined(PIOS_INCLUDE_FREERTOS)
static struct pios_spi_dev *PIOS_SPI_alloc(void)
{
return pvPortMalloc(sizeof(struct pios_spi_dev));
return pios_malloc(sizeof(struct pios_spi_dev));
}
#else
static struct pios_spi_dev pios_spi_devs[PIOS_SPI_MAX_DEVS];

2
flight/pios/stm32f4xx/pios_usart.c
View File

@ -77,7 +77,7 @@ static struct pios_usart_dev *PIOS_USART_alloc(void)
{
struct pios_usart_dev *usart_dev;
usart_dev = (struct pios_usart_dev *)pvPortMalloc(sizeof(struct pios_usart_dev));
usart_dev = (struct pios_usart_dev *)pios_malloc(sizeof(struct pios_usart_dev));
if (!usart_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_usb.c
View File

@ -70,7 +70,7 @@ static struct pios_usb_dev *PIOS_USB_alloc(void)
{
struct pios_usb_dev *usb_dev;
usb_dev = (struct pios_usb_dev *)pvPortMalloc(sizeof(*usb_dev));
usb_dev = (struct pios_usb_dev *)pios_malloc(sizeof(*usb_dev));
if (!usb_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_usb_cdc.c
View File

@ -103,7 +103,7 @@ static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
{
struct pios_usb_cdc_dev *usb_cdc_dev;
usb_cdc_dev = (struct pios_usb_cdc_dev *)pvPortMalloc(sizeof(struct pios_usb_cdc_dev));
usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_malloc(sizeof(struct pios_usb_cdc_dev));
if (!usb_cdc_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_usb_hid.c
View File

@ -87,7 +87,7 @@ static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
{
struct pios_usb_hid_dev *usb_hid_dev;
usb_hid_dev = (struct pios_usb_hid_dev *)pvPortMalloc(sizeof(struct pios_usb_hid_dev));
usb_hid_dev = (struct pios_usb_hid_dev *)pios_malloc(sizeof(struct pios_usb_hid_dev));
if (!usb_hid_dev) {
return NULL;
}

2
flight/pios/stm32f4xx/pios_ws2811.c
View File

@ -175,7 +175,7 @@ void PIOS_WS2811_Init(const struct pios_ws2811_cfg *ws2811_cfg, const struct pio
dmaSource[i] = (ledbuf_t)pios_ws2811_pin_cfg->gpioInit.GPIO_Pin;
}
fb = (ledbuf_t *)pvPortMalloc(PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
fb = (ledbuf_t *)pios_malloc(PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
memset(fb, 0, PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
Color ledoff = { 0, 0, 0 };
for (uint8_t i = 0; i < PIOS_WS2811_NUMLEDS; i++) {

42
flight/targets/boards/coptercontrol/firmware/pios_board.c
View File

@ -302,8 +302,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -321,8 +321,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -341,7 +341,7 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
NULL, 0,
@ -375,8 +375,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -419,8 +419,8 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id,
@ -460,7 +460,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
PIOS_Assert(rx_buffer);
if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id,
rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@ -522,7 +522,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id,
NULL, 0,
@ -540,9 +540,9 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
PIOS_Assert(rx_buffer);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id,
rx_buffer, PIOS_COM_BRIDGE_RX_BUF_LEN,
@ -558,7 +558,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_HKOSD_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id,
NULL, 0,
@ -583,8 +583,8 @@ void PIOS_Board_Init(void)
if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id,
@ -602,8 +602,8 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id,
@ -620,7 +620,7 @@ void PIOS_Board_Init(void)
if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
PIOS_Assert(rx_buffer);
if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id,
rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@ -696,7 +696,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id,
NULL, 0,
@ -723,7 +723,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_HKOSD_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id,
NULL, 0,

22
flight/targets/boards/discoveryf4bare/firmware/pios_board.c
View File

@ -249,10 +249,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
PIOS_Assert(rx_buffer);
if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@ -483,8 +483,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -498,8 +498,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -514,7 +514,7 @@ void PIOS_Board_Init(void)
#if defined(PIOS_INCLUDE_COM)
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
NULL, 0,
@ -545,8 +545,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -740,8 +740,8 @@ void PIOS_Board_Init(void)
}
/* Configure the radio com interface */
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

16
flight/targets/boards/oplinkmini/firmware/pios_board.c
View File

@ -185,8 +185,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -203,8 +203,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_VCP_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_VCP_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_VCP_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_VCP_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -216,8 +216,8 @@ void PIOS_Board_Init(void)
#endif
/* Allocate the uart buffers. */
pios_uart_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RX_BUF_LEN);
pios_uart_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_TX_BUF_LEN);
pios_uart_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RX_BUF_LEN);
pios_uart_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_TX_BUF_LEN);
// Configure the main port
OPLinkSettingsData oplinkSettings;
@ -372,8 +372,8 @@ void PIOS_Board_Init(void)
}
// Configure the radio com interface
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_rfm22b_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

22
flight/targets/boards/osd/firmware/pios_board.c
View File

@ -260,8 +260,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -279,8 +279,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -314,8 +314,8 @@ void PIOS_Board_Init(void)
if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -343,7 +343,7 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *gps_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
uint8_t *gps_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
PIOS_Assert(gps_rx_buffer);
if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id,
gps_rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@ -361,8 +361,8 @@ void PIOS_Board_Init(void)
PIOS_DEBUG_Assert(0);
}
uint8_t *aux_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_AUX_RX_BUF_LEN);
uint8_t *aux_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_AUX_TX_BUF_LEN);
uint8_t *aux_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_AUX_RX_BUF_LEN);
uint8_t *aux_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_AUX_TX_BUF_LEN);
PIOS_Assert(aux_rx_buffer);
PIOS_Assert(aux_tx_buffer);
@ -383,8 +383,8 @@ void PIOS_Board_Init(void)
PIOS_Assert(0);
}
uint8_t *telem_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *telem_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
uint8_t *telem_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
uint8_t *telem_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
PIOS_Assert(telem_rx_buffer);
PIOS_Assert(telem_tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id,

22
flight/targets/boards/revolution/firmware/pios_board.c
View File

@ -251,10 +251,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
PIOS_Assert(rx_buffer);
if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@ -494,8 +494,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -509,8 +509,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -525,7 +525,7 @@ void PIOS_Board_Init(void)
#if defined(PIOS_INCLUDE_COM)
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
NULL, 0,
@ -556,8 +556,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -751,8 +751,8 @@ void PIOS_Board_Init(void)
}
/* Configure the radio com interface */
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_rf_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

22
flight/targets/boards/revoproto/firmware/pios_board.c
View File

@ -321,10 +321,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
PIOS_Assert(rx_buffer);
if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@ -529,8 +529,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -544,8 +544,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@ -560,7 +560,7 @@ void PIOS_Board_Init(void)
#if defined(PIOS_INCLUDE_COM)
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
NULL, 0,
@ -591,8 +591,8 @@ void PIOS_Board_Init(void)
case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@ -871,8 +871,8 @@ void PIOS_Board_Init(void)
PIOS_DEBUG_Assert(0);
}
const uint32_t PACKET_SIZE = 1024;
uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PACKET_SIZE);
uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PACKET_SIZE);
uint8_t *rx_buffer = (uint8_t *)pios_malloc(PACKET_SIZE);
uint8_t *tx_buffer = (uint8_t *)pios_malloc(PACKET_SIZE);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_overo_id, &pios_overo_com_driver, pios_overo_id,

2
flight/uavobjects/eventdispatcher.c
View File

@ -228,7 +228,7 @@ static int32_t eventPeriodicCreate(UAVObjEvent *ev, UAVObjEventCallback cb, xQue
}
}
// Create handle
objEntry = (PeriodicObjectList *)pvPortMalloc(sizeof(PeriodicObjectList));
objEntry = (PeriodicObjectList *)pios_malloc(sizeof(PeriodicObjectList));
if (objEntry == NULL) {
return -1;
}

8
flight/uavobjects/uavobjectmanager.c
View File

@ -278,7 +278,7 @@ static struct UAVOData *UAVObjAllocSingle(uint32_t num_bytes)
uint32_t object_size = sizeof(struct UAVOSingle) + num_bytes;
/* Allocate the object from the heap */
struct UAVOSingle *uavo_single = (struct UAVOSingle *)pvPortMalloc(object_size);
struct UAVOSingle *uavo_single = (struct UAVOSingle *)pios_malloc(object_size);
if (!uavo_single) {
return NULL;
@ -303,7 +303,7 @@ static struct UAVOData *UAVObjAllocMulti(uint32_t num_bytes)
uint32_t object_size = sizeof(struct UAVOMulti) + num_bytes;
/* Allocate the object from the heap */
struct UAVOMulti *uavo_multi = (struct UAVOMulti *)pvPortMalloc(object_size);
struct UAVOMulti *uavo_multi = (struct UAVOMulti *)pios_malloc(object_size);
if (!uavo_multi) {
return NULL;
@ -1802,7 +1802,7 @@ static InstanceHandle createInstance(struct UAVOData *obj, uint16_t instId)
/* Create the actual instance */
uint32_t size = sizeof(struct UAVOMultiInst) + obj->instance_size;
instEntry = (struct UAVOMultiInst *)pvPortMalloc(size);
instEntry = (struct UAVOMultiInst *)pios_malloc(size);
if (!instEntry) {
return NULL;
}
@ -1890,7 +1890,7 @@ static int32_t connectObj(UAVObjHandle obj_handle, xQueueHandle queue,
}
// Add queue to list
event = (struct ObjectEventEntry *)pvPortMalloc(sizeof(struct ObjectEventEntry));
event = (struct ObjectEventEntry *)pios_malloc(sizeof(struct ObjectEventEntry));
if (event == NULL) {
return -1;
}

6
flight/uavtalk/uavtalk.c
View File

@ -64,7 +64,7 @@ static void updateAck(UAVTalkConnectionData *connection, uint8_t type, uint32_t
UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
{
// allocate object
UAVTalkConnectionData *connection = pvPortMalloc(sizeof(UAVTalkConnectionData));
UAVTalkConnectionData *connection = pios_malloc(sizeof(UAVTalkConnectionData));
if (!connection) {
return 0;
@ -76,11 +76,11 @@ UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
connection->lock = xSemaphoreCreateRecursiveMutex();
connection->transLock = xSemaphoreCreateRecursiveMutex();
// allocate buffers
connection->rxBuffer = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
connection->rxBuffer = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
if (!connection->rxBuffer) {
return 0;
}
connection->txBuffer = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
connection->txBuffer = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
if (!connection->txBuffer) {
return 0;
}