fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-21 04:43:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Support for building more modules with Linux

Browse Source 
Added more queue support to linux/px4_layer.

Use virt char devices for ms5611, and mavlink.

Added more HRT functionality. uORB latency test
now fails. Likely due to bad HRT impl for Linux.

Signed-off-by: Mark Charlebois <charlebm@gmail.com>
This commit is contained in:
Mark Charlebois
2015-04-20 11:07:00 -07:00
parent 2abfb7a5be
commit d013ac0927
53 changed files with 8455 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/drivers/device/cdev.cpp → src/drivers/device/cdev_nuttx.cpp
View File
src/drivers/device/device.cpp
+16 -143
View File
@@ -34,64 +34,24 @@
/**
* @file device.cpp
*
* Fundamental driver base class for the device framework.
* Fundamental driver base class for the virtual device framework.
*/
#include "device.h"
#include <nuttx/arch.h>
#include <px4_defines.h>
#include <px4_posix.h>
#include <stdio.h>
#include <unistd.h>
#include <drivers/drv_device.h>
namespace device
{
/**
* Interrupt dispatch table entry.
*/
struct irq_entry {
int irq;
Device *owner;
};
static const unsigned irq_nentries = 8; /**< size of the interrupt dispatch table */
static irq_entry irq_entries[irq_nentries]; /**< interrupt dispatch table (XXX should be a vector) */
/**
* Register an interrupt to a specific device.
*
* @param irq The interrupt number to register.
* @param owner The device receiving the interrupt.
* @return OK if the interrupt was registered.
*/
static int register_interrupt(int irq, Device *owner);
/**
* Unregister an interrupt.
*
* @param irq The previously-registered interrupt to be de-registered.
*/
static void unregister_interrupt(int irq);
/**
* Handle an interrupt.
*
* @param irq The interrupt being invoked.
* @param context The interrupt register context.
* @return Always returns OK.
*/
static int interrupt(int irq, void *context);
Device::Device(const char *name,
int irq) :
Device::Device(const char *name) :
// public
// protected
_name(name),
_debug_enabled(false),
// private
_irq(irq),
_irq_attached(false)
_debug_enabled(false)
{
sem_init(&_lock, 0, 1);
@@ -107,9 +67,6 @@ Device::Device(const char *name,
Device::~Device()
{
sem_destroy(&_lock);
if (_irq_attached)
unregister_interrupt(_irq);
}
int
@@ -117,45 +74,9 @@ Device::init()
{
int ret = OK;
// If assigned an interrupt, connect it
if (_irq) {
/* ensure it's disabled */
up_disable_irq(_irq);
/* register */
ret = register_interrupt(_irq, this);
if (ret != OK)
goto out;
_irq_attached = true;
}
out:
return ret;
}
void
Device::interrupt_enable()
{
if (_irq_attached)
up_enable_irq(_irq);
}
void
Device::interrupt_disable()
{
if (_irq_attached)
up_disable_irq(_irq);
}
void
Device::interrupt(void *context)
{
// default action is to disable the interrupt so we don't get called again
interrupt_disable();
}
void
Device::log(const char *fmt, ...)
{
@@ -184,74 +105,26 @@ Device::debug(const char *fmt, ...)
}
}
static int
register_interrupt(int irq, Device *owner)
int
Device::dev_read(unsigned offset, void *data, unsigned count)
{
int ret = -ENOMEM;
// look for a slot where we can register the interrupt
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == 0) {
// great, we could put it here; try attaching it
ret = irq_attach(irq, &interrupt);
if (ret == OK) {
irq_entries[i].irq = irq;
irq_entries[i].owner = owner;
}
break;
}
}
return ret;
}
static void
unregister_interrupt(int irq)
{
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == irq) {
irq_entries[i].irq = 0;
irq_entries[i].owner = nullptr;
}
}
}
static int
interrupt(int irq, void *context)
{
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == irq) {
irq_entries[i].owner->interrupt(context);
break;
}
}
return OK;
return -ENODEV;
}
int
Device::read(unsigned offset, void *data, unsigned count)
Device::dev_write(unsigned offset, void *data, unsigned count)
{
return -ENODEV;
return -ENODEV;
}
int
Device::write(unsigned offset, void *data, unsigned count)
Device::dev_ioctl(unsigned operation, unsigned &arg)
{
return -ENODEV;
}
int
Device::ioctl(unsigned operation, unsigned &arg)
{
switch (operation) {
case DEVIOCGDEVICEID:
return (int)_device_id.devid;
}
return -ENODEV;
switch (operation) {
case PX4_DEVIOCGDEVICEID:
return (int)_device_id.devid;
}
return -ENODEV;
}
} // namespace device
src/drivers/device/device_nuttx.cpp
+257
View File
@@ -0,0 +1,257 @@
/****************************************************************************
*
* Copyright (c) 2012-2014 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file device.cpp
*
* Fundamental driver base class for the device framework.
*/
#include "device.h"
#include <nuttx/arch.h>
#include <stdio.h>
#include <unistd.h>
#include <drivers/drv_device.h>
namespace device
{
/**
* Interrupt dispatch table entry.
*/
struct irq_entry {
int irq;
Device *owner;
};
static const unsigned irq_nentries = 8; /**< size of the interrupt dispatch table */
static irq_entry irq_entries[irq_nentries]; /**< interrupt dispatch table (XXX should be a vector) */
/**
* Register an interrupt to a specific device.
*
* @param irq The interrupt number to register.
* @param owner The device receiving the interrupt.
* @return OK if the interrupt was registered.
*/
static int register_interrupt(int irq, Device *owner);
/**
* Unregister an interrupt.
*
* @param irq The previously-registered interrupt to be de-registered.
*/
static void unregister_interrupt(int irq);
/**
* Handle an interrupt.
*
* @param irq The interrupt being invoked.
* @param context The interrupt register context.
* @return Always returns OK.
*/
static int interrupt(int irq, void *context);
Device::Device(const char *name,
int irq) :
// public
// protected
_name(name),
_debug_enabled(false),
// private
_irq(irq),
_irq_attached(false)
{
sem_init(&_lock, 0, 1);
/* setup a default device ID. When bus_type is UNKNOWN the
other fields are invalid */
_device_id.devid = 0;
_device_id.devid_s.bus_type = DeviceBusType_UNKNOWN;
_device_id.devid_s.bus = 0;
_device_id.devid_s.address = 0;
_device_id.devid_s.devtype = 0;
}
Device::~Device()
{
sem_destroy(&_lock);
if (_irq_attached)
unregister_interrupt(_irq);
}
int
Device::init()
{
int ret = OK;
// If assigned an interrupt, connect it
if (_irq) {
/* ensure it's disabled */
up_disable_irq(_irq);
/* register */
ret = register_interrupt(_irq, this);
if (ret != OK)
goto out;
_irq_attached = true;
}
out:
return ret;
}
void
Device::interrupt_enable()
{
if (_irq_attached)
up_enable_irq(_irq);
}
void
Device::interrupt_disable()
{
if (_irq_attached)
up_disable_irq(_irq);
}
void
Device::interrupt(void *context)
{
// default action is to disable the interrupt so we don't get called again
interrupt_disable();
}
void
Device::log(const char *fmt, ...)
{
va_list ap;
printf("[%s] ", _name);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
}
void
Device::debug(const char *fmt, ...)
{
va_list ap;
if (_debug_enabled) {
printf("<%s> ", _name);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
}
}
static int
register_interrupt(int irq, Device *owner)
{
int ret = -ENOMEM;
// look for a slot where we can register the interrupt
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == 0) {
// great, we could put it here; try attaching it
ret = irq_attach(irq, &interrupt);
if (ret == OK) {
irq_entries[i].irq = irq;
irq_entries[i].owner = owner;
}
break;
}
}
return ret;
}
static void
unregister_interrupt(int irq)
{
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == irq) {
irq_entries[i].irq = 0;
irq_entries[i].owner = nullptr;
}
}
}
static int
interrupt(int irq, void *context)
{
for (unsigned i = 0; i < irq_nentries; i++) {
if (irq_entries[i].irq == irq) {
irq_entries[i].owner->interrupt(context);
break;
}
}
return OK;
}
int
Device::read(unsigned offset, void *data, unsigned count)
{
return -ENODEV;
}
int
Device::write(unsigned offset, void *data, unsigned count)
{
return -ENODEV;
}
int
Device::ioctl(unsigned operation, unsigned &arg)
{
switch (operation) {
case DEVIOCGDEVICEID:
return (int)_device_id.devid;
}
return -ENODEV;
}
} // namespace device
src/drivers/device/i2c.h
+3 -3
View File
@@ -42,7 +42,7 @@
#include "device.h"
#include <nuttx/i2c.h>
#include <px4_i2c.h>
namespace device __EXPORT
{
@@ -124,7 +124,7 @@ protected:
* @return OK if the transfer was successful, -errno
* otherwise.
*/
int transfer(i2c_msg_s *msgv, unsigned msgs);
int transfer(px4_i2c_msg_t *msgv, unsigned msgs);
/**
* Change the bus address.
@@ -142,7 +142,7 @@ protected:
private:
uint16_t _address;
uint32_t _frequency;
struct i2c_dev_s *_dev;
px4_i2c_dev_t *_dev;
I2C(const device::I2C &);
I2C operator=(const device::I2C &);
src/drivers/device/i2c_linux.cpp
+257
View File
@@ -0,0 +1,257 @@
/****************************************************************************
*
* Copyright (c) 2012-2015 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file i2c.cpp
*
* Base class for devices attached via the I2C bus.
*
* @todo Bus frequency changes; currently we do nothing with the value
* that is supplied. Should we just depend on the bus knowing?
*/
#include "i2c.h"
namespace device
{
unsigned int I2C::_bus_clocks[3] = { 100000, 100000, 100000 };
I2C::I2C(const char *name,
const char *devname,
int bus,
uint16_t address,
uint32_t frequency,
int irq) :
// base class
CDev(name, devname),
// public
// protected
_retries(0),
// private
_bus(bus),
_address(address),
_frequency(frequency),
_dev(nullptr)
{
// fill in _device_id fields for a I2C device
_device_id.devid_s.bus_type = DeviceBusType_I2C;
_device_id.devid_s.bus = bus;
_device_id.devid_s.address = address;
// devtype needs to be filled in by the driver
_device_id.devid_s.devtype = 0;
}
I2C::~I2C()
{
if (_dev) {
px4_i2cuninitialize(_dev);
_dev = nullptr;
}
}
int
I2C::set_bus_clock(unsigned bus, unsigned clock_hz)
{
int index = bus - 1;
if (index < 0 || index >= static_cast<int>(sizeof(_bus_clocks) / sizeof(_bus_clocks[0]))) {
return -EINVAL;
}
if (_bus_clocks[index] > 0) {
// debug("overriding clock of %u with %u Hz\n", _bus_clocks[index], clock_hz);
}
_bus_clocks[index] = clock_hz;
return PX4_OK;
}
int
I2C::init()
{
int ret = PX4_OK;
unsigned bus_index;
// attach to the i2c bus
_dev = px4_i2cinitialize(_bus);
if (_dev == nullptr) {
debug("failed to init I2C");
ret = -ENOENT;
goto out;
}
// the above call fails for a non-existing bus index,
// so the index math here is safe.
bus_index = _bus - 1;
// abort if the max frequency we allow (the frequency we ask)
// is smaller than the bus frequency
if (_bus_clocks[bus_index] > _frequency) {
(void)px4_i2cuninitialize(_dev);
_dev = nullptr;
log("FAIL: too slow for bus #%u: %u KHz, device max: %u KHz)",
_bus, _bus_clocks[bus_index] / 1000, _frequency / 1000);
ret = -EINVAL;
goto out;
}
// set the bus frequency on the first access if it has
// not been set yet
if (_bus_clocks[bus_index] == 0) {
_bus_clocks[bus_index] = _frequency;
}
// set frequency for this instance once to the bus speed
// the bus speed is the maximum supported by all devices on the bus,
// as we have to prioritize performance over compatibility.
// If a new device requires a lower clock speed, this has to be
// manually set via "fmu i2c <bus> <clock>" before starting any
// drivers.
// This is necessary as automatically lowering the bus speed
// for maximum compatibility could induce timing issues on
// critical sensors the adopter might be unaware of.
I2C_SETFREQUENCY(_dev, _bus_clocks[bus_index]);
// call the probe function to check whether the device is present
ret = probe();
if (ret != PX4_OK) {
debug("probe failed");
goto out;
}
// do base class init, which will create device node, etc
ret = CDev::init();
if (ret != PX4_OK) {
debug("cdev init failed");
goto out;
}
// tell the world where we are
log("on I2C bus %d at 0x%02x (bus: %u KHz, max: %u KHz)",
_bus, _address, _bus_clocks[bus_index] / 1000, _frequency / 1000);
out:
if ((ret != PX4_OK) && (_dev != nullptr)) {
px4_i2cuninitialize(_dev);
_dev = nullptr;
}
return ret;
}
int
I2C::probe()
{
// Assume the device is too stupid to be discoverable.
return PX4_OK;
}
int
I2C::transfer(const uint8_t *send, unsigned send_len, uint8_t *recv, unsigned recv_len)
{
px4_i2c_msg_t msgv[2];
unsigned msgs;
int ret;
unsigned retry_count = 0;
do {
// debug("transfer out %p/%u in %p/%u", send, send_len, recv, recv_len);
msgs = 0;
if (send_len > 0) {
msgv[msgs].addr = _address;
msgv[msgs].flags = 0;
msgv[msgs].buffer = const_cast<uint8_t *>(send);
msgv[msgs].length = send_len;
msgs++;
}
if (recv_len > 0) {
msgv[msgs].addr = _address;
msgv[msgs].flags = I2C_M_READ;
msgv[msgs].buffer = recv;
msgv[msgs].length = recv_len;
msgs++;
}
if (msgs == 0)
return -EINVAL;
ret = I2C_TRANSFER(_dev, &msgv[0], msgs);
/* success */
if (ret == PX4_OK)
break;
/* if we have already retried once, or we are going to give up, then reset the bus */
if ((retry_count >= 1) || (retry_count >= _retries))
px4_i2creset(_dev);
} while (retry_count++ < _retries);
return ret;
}
int
I2C::transfer(px4_i2c_msg_t *msgv, unsigned msgs)
{
int ret;
unsigned retry_count = 0;
/* force the device address into the message vector */
for (unsigned i = 0; i < msgs; i++)
msgv[i].addr = _address;
do {
ret = I2C_TRANSFER(_dev, msgv, msgs);
/* success */
if (ret == PX4_OK)
break;
/* if we have already retried once, or we are going to give up, then reset the bus */
if ((retry_count >= 1) || (retry_count >= _retries))
px4_i2creset(_dev);
} while (retry_count++ < _retries);
return ret;
}
} // namespace device
src/drivers/device/i2c.cpp → src/drivers/device/i2c_nuttx.cpp
View File
src/drivers/device/module.mk
+6 -5
View File
@@ -37,14 +37,15 @@
ifeq ($(PX4_TARGET_OS),nuttx)
SRCS = \
device.cpp \
cdev.cpp \
i2c.cpp \
device_nuttx.cpp \
cdev_nuttx.cpp \
i2c_nuttx.cpp \
pio.cpp \
spi.cpp
endif
ifeq ($(PX4_TARGET_OS),linux)
SRCS = vcdev.cpp \
vdevice.cpp \
vcdev_posix.cpp
device.cpp \
vcdev_posix.cpp \
i2c_linux.cpp
endif
src/drivers/device/ringbuffer.h
+1 -1
View File
@@ -503,7 +503,7 @@ RingBuffer::resize(unsigned new_size)
void
RingBuffer::print_info(const char *name)
{
printf("%s %u/%u (%u/%u @ %p)\n",
printf("%s %u/%lu (%u/%u @ %p)\n",
name,
_num_items,
_num_items * _item_size,
src/drivers/device/spi.h
+1 -1
View File
@@ -42,7 +42,7 @@
#include "device.h"
#include <nuttx/spi.h>
#include <px4_spi.h>
namespace device __EXPORT
{
src/drivers/device/vdevice.cpp
-107
View File
@@ -1,107 +0,0 @@
/****************************************************************************
*
* Copyright (c) 2012-2014 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file device.cpp
*
* Fundamental driver base class for the virtual device framework.
*/
#include "device.h"
#include <px4_defines.h>
#include <stdio.h>
#include <unistd.h>
namespace device
{
Device::Device(const char *name) :
// public
// protected
_name(name),
_debug_enabled(false)
{
sem_init(&_lock, 0, 1);
/* setup a default device ID. When bus_type is UNKNOWN the
other fields are invalid */
_device_id.devid = 0;
_device_id.devid_s.bus_type = DeviceBusType_UNKNOWN;
_device_id.devid_s.bus = 0;
_device_id.devid_s.address = 0;
_device_id.devid_s.devtype = 0;
}
Device::~Device()
{
sem_destroy(&_lock);
}
int
Device::init()
{
int ret = OK;
return ret;
}
void
Device::log(const char *fmt, ...)
{
va_list ap;
printf("[%s] ", _name);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
}
void
Device::debug(const char *fmt, ...)
{
va_list ap;
if (_debug_enabled) {
printf("<%s> ", _name);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
}
}
} // namespace device
src/drivers/device/vdevice.h
+33
View File
@@ -97,6 +97,39 @@ public:
*/
virtual int init();
/**
* Read directly from the device.
*
* The actual size of each unit quantity is device-specific.
*
* @param offset The device address at which to start reading
* @param data The buffer into which the read values should be placed.
* @param count The number of items to read.
* @return The number of items read on success, negative errno otherwise.
*/
int dev_read(unsigned address, void *data, unsigned count);
/**
* Write directly to the device.
*
* The actual size of each unit quantity is device-specific.
*
* @param address The device address at which to start writing.
* @param data The buffer from which values should be read.
* @param count The number of items to write.
* @return The number of items written on success, negative errno otherwise.
*/
int dev_write(unsigned address, void *data, unsigned count);
/**
* Perform a device-specific operation.
*
* @param operation The operation to perform.
* @param arg An argument to the operation.
* @return Negative errno on error, OK or positive value on success.
*/
int dev_ioctl(unsigned operation, unsigned &arg);
/*
device bus types for DEVID
*/
src/drivers/drv_accel.h
+1 -1
View File
@@ -94,7 +94,7 @@ ORB_DECLARE(sensor_accel);
*/
#define _ACCELIOCBASE (0x2100)
#define _ACCELIOC(_n) (_IOC(_ACCELIOCBASE, _n))
#define _ACCELIOC(_n) (_PX4_IOC(_ACCELIOCBASE, _n))
/** set the accel internal sample rate to at least (arg) Hz */
src/drivers/drv_airspeed.h
+1 -1
View File
@@ -59,7 +59,7 @@
*/
#define _AIRSPEEDIOCBASE (0x7700)
#define __AIRSPEEDIOC(_n) (_IOC(_AIRSPEEDIOCBASE, _n))
#define __AIRSPEEDIOC(_n) (_PX4_IOC(_AIRSPEEDIOCBASE, _n))
#define AIRSPEEDIOCSSCALE __AIRSPEEDIOC(0)
#define AIRSPEEDIOCGSCALE __AIRSPEEDIOC(1)
src/drivers/drv_baro.h
+2 -1
View File
@@ -40,6 +40,7 @@
#ifndef _DRV_BARO_H
#define _DRV_BARO_H
#include <px4_defines.h>
#include <stdint.h>
#include <sys/ioctl.h>
@@ -71,7 +72,7 @@ ORB_DECLARE(sensor_baro);
*/
#define _BAROIOCBASE (0x2200)
#define _BAROIOC(_n) (_IOC(_BAROIOCBASE, _n))
#define _BAROIOC(_n) (_PX4_IOC(_BAROIOCBASE, _n))
/** set corrected MSL pressure in pascals */
#define BAROIOCSMSLPRESSURE _BAROIOC(0)
src/drivers/drv_device.h
+1 -1
View File
@@ -51,7 +51,7 @@
*/
#define _DEVICEIOCBASE (0x100)
#define _DEVICEIOC(_n) (_IOC(_DEVICEIOCBASE, _n))
#define _DEVICEIOC(_n) (_PX4_IOC(_DEVICEIOCBASE, _n))
/** ask device to stop publishing */
#define DEVIOCSPUBBLOCK _DEVICEIOC(0)
src/drivers/drv_gyro.h
+1 -1
View File
@@ -91,7 +91,7 @@ ORB_DECLARE(sensor_gyro);
*/
#define _GYROIOCBASE (0x2300)
#define _GYROIOC(_n) (_IOC(_GYROIOCBASE, _n))
#define _GYROIOC(_n) (_PX4_IOC(_GYROIOCBASE, _n))
/** set the gyro internal sample rate to at least (arg) Hz */
#define GYROIOCSSAMPLERATE _GYROIOC(0)
src/drivers/drv_mag.h
+1 -1
View File
@@ -91,7 +91,7 @@ ORB_DECLARE(sensor_mag);
*/
#define _MAGIOCBASE (0x2400)
#define _MAGIOC(_n) (_IOC(_MAGIOCBASE, _n))
#define _MAGIOC(_n) (_PX4_IOC(_MAGIOCBASE, _n))
/** set the mag internal sample rate to at least (arg) Hz */
#define MAGIOCSSAMPLERATE _MAGIOC(0)
src/drivers/drv_sensor.h
+2 -1
View File
@@ -40,6 +40,7 @@
#ifndef _DRV_SENSOR_H
#define _DRV_SENSOR_H
#include <px4_defines.h>
#include <stdint.h>
#include <sys/ioctl.h>
@@ -69,7 +70,7 @@
*/
#define _SENSORIOCBASE (0x2000)
#define _SENSORIOC(_n) (_IOC(_SENSORIOCBASE, _n))
#define _SENSORIOC(_n) (_PX4_IOC(_SENSORIOCBASE, _n))
/**
* Set the driver polling rate to (arg) Hz, or one of the SENSOR_POLLRATE
src/drivers/ms5611/module.mk
+5 -1
View File
@@ -37,6 +37,10 @@
MODULE_COMMAND = ms5611
SRCS = ms5611.cpp ms5611_spi.cpp ms5611_i2c.cpp
ifeq ($(PX4_TARGET_OS),nuttx)
SRCS = ms5611_nuttx.cpp ms5611_spi.cpp ms5611_i2c.cpp
else
SRCS = ms5611_linux.cpp ms5611_spi.cpp ms5611_i2c.cpp
endif
MAXOPTIMIZATION = -Os
src/drivers/ms5611/ms5611.h
+3 -3
View File
@@ -80,6 +80,6 @@ extern bool crc4(uint16_t *n_prom);
} /* namespace */
/* interface factories */
extern device::Device *MS5611_spi_interface(ms5611::prom_u &prom_buf, uint8_t busnum) weak_function;
extern device::Device *MS5611_i2c_interface(ms5611::prom_u &prom_buf, uint8_t busnum) weak_function;
typedef device::Device *(*MS5611_constructor)(ms5611::prom_u &prom_buf, uint8_t busnum);
extern device::Device *MS5611_spi_interface(ms5611::prom_u &prom_buf, uint8_t busnum) __attribute__((weak));
extern device::Device *MS5611_i2c_interface(ms5611::prom_u &prom_buf, uint8_t busnum) __attribute__((weak));
typedef device::Device* (*MS5611_constructor)(ms5611::prom_u &prom_buf, uint8_t busnum);
src/drivers/ms5611/ms5611_i2c.cpp
+16 -15
View File
@@ -39,12 +39,13 @@
/* XXX trim includes */
#include <px4_config.h>
#include <px4_defines.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include <debug.h>
//#include <debug.h>
#include <errno.h>
#include <unistd.h>
@@ -70,8 +71,8 @@ public:
virtual ~MS5611_I2C();
virtual int init();
virtual int read(unsigned offset, void *data, unsigned count);
virtual int ioctl(unsigned operation, unsigned &arg);
virtual int dev_read(unsigned offset, void *data, unsigned count);
virtual int dev_ioctl(unsigned operation, unsigned &arg);
protected:
virtual int probe();
@@ -98,7 +99,7 @@ private:
/**
* Read the MS5611 PROM
*
* @return OK if the PROM reads successfully.
* @return PX4_OK if the PROM reads successfully.
*/
int _read_prom();
@@ -128,7 +129,7 @@ MS5611_I2C::init()
}
int
MS5611_I2C::read(unsigned offset, void *data, unsigned count)
MS5611_I2C::dev_read(unsigned offset, void *data, unsigned count)
{
union _cvt {
uint8_t b[4];
@@ -139,7 +140,7 @@ MS5611_I2C::read(unsigned offset, void *data, unsigned count)
/* read the most recent measurement */
uint8_t cmd = 0;
int ret = transfer(&cmd, 1, &buf[0], 3);
if (ret == OK) {
if (ret == PX4_OK) {
/* fetch the raw value */
cvt->b[0] = buf[2];
cvt->b[1] = buf[1];
@@ -151,7 +152,7 @@ MS5611_I2C::read(unsigned offset, void *data, unsigned count)
}
int
MS5611_I2C::ioctl(unsigned operation, unsigned &arg)
MS5611_I2C::dev_ioctl(unsigned operation, unsigned &arg)
{
int ret;
@@ -176,14 +177,14 @@ MS5611_I2C::probe()
{
_retries = 10;
if ((OK == _probe_address(MS5611_ADDRESS_1)) ||
(OK == _probe_address(MS5611_ADDRESS_2))) {
if ((PX4_OK == _probe_address(MS5611_ADDRESS_1)) ||
(PX4_OK == _probe_address(MS5611_ADDRESS_2))) {
/*
* Disable retries; we may enable them selectively in some cases,
* but the device gets confused if we retry some of the commands.
*/
_retries = 0;
return OK;
return PX4_OK;
}
return -EIO;
@@ -196,14 +197,14 @@ MS5611_I2C::_probe_address(uint8_t address)
set_address(address);
/* send reset command */
if (OK != _reset())
if (PX4_OK != _reset())
return -EIO;
/* read PROM */
if (OK != _read_prom())
if (PX4_OK != _read_prom())
return -EIO;
return OK;
return PX4_OK;
}
@@ -254,7 +255,7 @@ MS5611_I2C::_read_prom()
for (int i = 0; i < 8; i++) {
uint8_t cmd = ADDR_PROM_SETUP + (i * 2);
if (OK != transfer(&cmd, 1, &prom_buf[0], 2))
if (PX4_OK != transfer(&cmd, 1, &prom_buf[0], 2))
break;
/* assemble 16 bit value and convert from big endian (sensor) to little endian (MCU) */
@@ -264,5 +265,5 @@ MS5611_I2C::_read_prom()
}
/* calculate CRC and return success/failure accordingly */
return ms5611::crc4(&_prom.c[0]) ? OK : -EIO;
return ms5611::crc4(&_prom.c[0]) ? PX4_OK : -EIO;
}
src/drivers/ms5611/ms5611_linux.cpp
+1215
View File
File diff suppressed because it is too large Load Diff
src/drivers/ms5611/ms5611.cpp → src/drivers/ms5611/ms5611_nuttx.cpp
View File
src/drivers/ms5611/ms5611_spi.cpp
+1 -1
View File
@@ -44,7 +44,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include <debug.h>
//#include <debug.h>
#include <errno.h>
#include <unistd.h>