dev.h

MANTIS是由科罗拉多大学开发的传感器网络嵌入式操作系统。 这是mantis的0.9.5版本的源码。

//  This file is part of MANTIS OS, Operating System
//  See http://mantis.cs.colorado.edu/
//
//  Copyright (C) 2003,2004,2005 University of Colorado, Boulder
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the mos license (see file LICENSE)


/** @file dev.h
 * @brief Device Layer generic routines.
 * @author Adam Torgerson
 * @author Modified: Brian Shucker
 * @date Modified 04/13/2004
 */

#ifndef _DEV_H_
#define _DEV_H_

#include <stdarg.h>
#include <stddef.h>
#include "mutex.h"

#ifdef SCONS
#include "optsconfig.h"
#endif

typedef enum {
   DEV_ADC = 0,
   DEV_AVR_EEPROM,
   DEV_AVR_RSSI,
   DEV_AVR_I2C,
   DEV_MICA2_LIGHT,
   DEV_MICA2_TEMP,
   DEV_MICA2_MIC,
   DEV_MICA2_SOUNDER,
   DEV_MICA2_ACCEL_X,
   DEV_MICA2_ACCEL_Y,
   DEV_MICA2_MAGNET_X,
   DEV_MICA2_MAGNET_Y,
   DEV_MICA2_BATTERY,
   DEV_MICA2_ULTRASOUND,
   DEV_MICA2_ID,
   DEV_ATMEL_FLASH,
   DEV_MSP_HUMIDITY,
   DEV_TELOS_FLASH,
   NUM_DEVICES
} dev_id_t;

/* #define DEV_ADC              0 */
/* #define DEV_AVR_EEPROM       1 */
/* #define DEV_AVR_RSSI         2 */
/* #define DEV_AVR_I2C          3 */
/* #define DEV_MICA2_LIGHT      4 */
/* #define DEV_MICA2_TEMP       5 */
/* #define DEV_MICA2_MIC        6 */
/* #define DEV_MICA2_SOUNDER    7 */
/* #define DEV_MICA2_ACCEL_X    8 */
/* #define DEV_MICA2_ACCEL_Y    9 */
/* #define DEV_MICA2_MAGNET_X   10 */
/* #define DEV_MICA2_MAGNET_Y   11 */
/* #define DEV_MICA2_BATTERY    12 */
/* #define DEV_MICA2_ULTRASOUND 13 */
/* #define DEV_MICA2_ID         14 */
/* #define DEV_ATMEL_FLASH      15 */
/* #define DEV_MSP_HUMIDITY 16 */
/* #define NUM_DEVICES 17 */

typedef uint16_t (*dev_read_func_t)(void *buf, uint16_t count);
typedef uint16_t (*dev_write_func_t)(const void *buf, uint16_t count);
typedef uint8_t (*dev_mode_func_t)(uint8_t md);
typedef uint8_t (*dev_ioctl_func_t)(int8_t request, ...);

extern mos_mutex_t adc_mutex;
uint16_t dev_read_DEV_ADC(void *buf, uint16_t count);
uint16_t dev_write_DEV_ADC(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_ADC(uint8_t md);
uint8_t dev_ioctl_DEV_ADC(int8_t request, ...);
#define dev_open_DEV_ADC() mos_mutex_lock(&adc_mutex)
#define dev_close_DEV_ADC() mos_mutex_unlock(&adc_mutex)

extern mos_mutex_t eeprom_mutex;
uint16_t dev_read_DEV_AVR_EEPROM(void *buf, uint16_t count);
uint16_t dev_write_DEV_AVR_EEPROM(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_AVR_EEPROM(uint8_t md);
uint8_t dev_ioctl_DEV_AVR_EEPROM(int8_t request, ...);
#define dev_open_DEV_AVR_EEPROM() mos_mutex_lock(&eeprom_mutex)
#define dev_close_DEV_AVR_EEPROM() mos_mutex_unlock(&eeprom_mutex)

extern mos_mutex_t rssi_mutex;
uint16_t dev_read_DEV_AVR_RSSI(void *buf, uint16_t count);
uint16_t dev_write_DEV_AVR_RSSI(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_AVR_RSSI(uint8_t md);
uint8_t dev_ioctl_DEV_AVR_RSSI(int8_t request, ...);
#define dev_open_DEV_AVR_RSSI() mos_mutex_lock(&rssi_mutex)
#define dev_close_DEV_AVR_RSSI() mos_mutex_unlock(&rssi_mutex)

uint16_t dev_read_DEV_AVR_I2C(void *buf, uint16_t count);
uint16_t dev_write_DEV_AVR_I2C(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_AVR_I2C(uint8_t md);
uint8_t dev_ioctl_DEV_AVR_I2C(int8_t request, ...);

//light/temp driver share the same mutex because they are on the same
//adc line
extern mos_mutex_t lt_mutex;
uint16_t dev_read_DEV_MICA2_LIGHT(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_LIGHT(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_LIGHT(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_LIGHT(int8_t request, ...);
#define dev_open_DEV_MICA2_LIGHT() mos_mutex_lock(&lt_mutex)
#define dev_close_DEV_MICA2_LIGHT() mos_mutex_unlock(&lt_mutex)

uint16_t dev_read_DEV_MICA2_TEMP(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_TEMP(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_TEMP(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_TEMP(int8_t request, ...);
#define dev_open_DEV_MICA2_TEMP() mos_mutex_lock(&lt_mutex)
#define dev_close_DEV_MICA2_TEMP() mos_mutex_unlock(&lt_mutex)

extern mos_mutex_t mic_mutex;
uint16_t dev_read_DEV_MICA2_MIC(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_MIC(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_MIC(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_MIC(int8_t request, ...);
#define dev_open_DEV_MICA2_MIC() mos_mutex_lock(&mic_mutex)
#define dev_close_DEV_MICA2_MIC() mos_mutex_unlock(&mic_mutex)

extern mos_mutex_t sounder_mutex;
uint16_t dev_read_DEV_MICA2_SOUNDER(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_SOUNDER(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_SOUNDER(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_SOUNDER(int8_t request, ...);
#define dev_open_DEV_MICA2_SOUNDER() mos_mutex_lock(&sounder_mutex)
#define dev_close_DEV_MICA2_SOUNDER() mos_mutex_unlock(&sounder_mutex)

extern mos_mutex_t accel_mutex;
uint16_t dev_read_DEV_MICA2_ACCEL_X(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_ACCEL_X(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_ACCEL_X(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_ACCEL_X(int8_t request, ...);
#define dev_open_DEV_MICA2_ACCEL_X() mos_mutex_lock(&accel_mutex)
#define dev_close_DEV_MICA2_ACCEL_X() mos_mutex_unlock(&accel_mutex)

uint16_t dev_read_DEV_MICA2_ACCEL_Y(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_ACCEL_Y(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_ACCEL_Y(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_ACCEL_Y(int8_t request, ...);
#define dev_open_DEV_MICA2_ACCEL_Y() mos_mutex_lock(&accel_mutex)
#define dev_close_DEV_MICA2_ACCEL_Y() mos_mutex_unlock(&accel_mutex)

extern mos_mutex_t magnet_x_mutex;
uint16_t dev_read_DEV_MICA2_MAGNET_X(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_MAGNET_X(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_MAGNET_X(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_MAGNET_X(int8_t request, ...);
#define dev_open_DEV_MICA2_MAGNET_X() mos_mutex_lock(&magnet_x_mutex)
#define dev_close_DEV_MICA2_MAGNET_X() mos_mutex_unlock(&magnet_x_mutex)

extern mos_mutex_t magnet_y_mutex;
uint16_t dev_read_DEV_MICA2_MAGNET_Y(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_MAGNET_Y(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_MAGNET_Y(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_MAGNET_Y(int8_t request, ...);
#define dev_open_DEV_MICA2_MAGNET_Y() mos_mutex_lock(&magnet_y_mutex)
#define dev_close_DEV_MICA2_MAGNET_Y() mos_mutex_unlock(&magnet_y_mutex)

extern mos_mutex_t battery_mutex;
uint16_t dev_read_DEV_MICA2_BATTERY(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_BATTERY(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_BATTERY(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_BATTERY(int8_t request, ...);
#define dev_open_DEV_MICA2_BATTERY(void) mos_mutex_lock(&battery_mutex)
#define dev_close_DEV_MICA2_BATTERY(void) mos_mutex_unlock(&battery_mutex)

uint16_t dev_read_DEV_MICA2_ULTRASOUND(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_ULTRASOUND(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_ULTRASOUND(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_ULTRASOUND(int8_t request, ...);

extern mos_mutex_t id_mutex;
uint16_t dev_read_DEV_MICA2_ID(void *buf, uint16_t count);
uint16_t dev_write_DEV_MICA2_ID(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MICA2_ID(uint8_t md);
uint8_t dev_ioctl_DEV_MICA2_ID(int8_t request, ...);
#define dev_open_DEV_MICA2_ID(void) mos_mutex_lock(&id_mutex)
#define dev_close_DEV_MICA2_ID(void) mos_mutex_unlock(&id_mutex)

extern mos_mutex_t atmel_flash_mutex;
uint16_t dev_read_DEV_ATMEL_FLASH(void *buf, uint16_t count);
uint16_t dev_write_DEV_ATMEL_FLASH(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_ATMEL_FLASH(uint8_t md);
uint8_t dev_ioctl_DEV_ATMEL_FLASH(int8_t request, ...);
#define dev_open_DEV_ATMEL_FLASH(void) mos_mutex_lock(&atmel_flash_mutex)
#define dev_close_DEV_ATMEL_FLASH(void) mos_mutex_unlock(&atmel_flash_mutex)

extern mos_mutex_t loopback_mutex;
uint16_t dev_read_DEV_LOOPBACK(void *buf, uint16_t count);
uint16_t dev_write_DEV_LOOPBACK(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_LOOPBACK(uint8_t md);
uint8_t dev_ioctl_DEV_LOOPBACK(int8_t request, ...);
#define dev_open_DEV_LOOPBACK(void) mos_mutex_lock(&loopback_mutex)
#define dev_close_DEV_LOOPBACK(void) mos_mutex_unlock(&loopback_mutex)

#ifdef PLATFORM_TELOSB
extern mos_mutex_t msp_temp_mutex;
uint8_t dev_read_DEV_MSP_HUMIDITY(void *buf, uint16_t count);
uint8_t dev_write_DEV_MSP_HUMIDITY(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_MSP_HUMIDITY(uint8_t md);
uint8_t dev_ioctl_DEV_MSP_HUMIDITY(int8_t request, ...);
#define dev_open_DEV_MSP_HUMIDITY(void) mos_mutex_lock(&msp_temp_mutex)
#define dev_close_DEV_MSP_HUMIDITY(void) mos_mutex_unlock(&msp_temp_mutex)

uint8_t dev_read_DEV_MSP_TEMPERATURE(void *buf, uint16_t count);
uint8_t dev_write_DEV_MSP_TEMPERATURE(const void *buf, uint16_t count);
#define dev_mode_DEV_MSP_TEMPERTURE(newMode)   dev_mode_DEV_MSP_HUMIDITY(newMode)
#define dev_ioctl_DEV_MSP_TEMPERATURE(request) dev_ioctl_DEV_MSP_HUMIDITY(request)
#define dev_open_DEV_MSP_TEMPERATURE(void) mos_mutex_lock(&msp_temp_mutex)
#define dev_close_DEV_MSP_TEMPERATURE(void) mos_mutex_unlock(&msp_temp_mutex)

extern mos_mutex_t telos_flash_mutex;
uint8_t dev_read_DEV_TELOS_FLASH(void *buf, uint16_t count);
uint8_t dev_write_DEV_TELOS_FLASH(const void *buf, uint16_t count);
uint8_t dev_mode_DEV_TELOS_FLASH(uint8_t md);
uint8_t dev_ioctl_DEV_TELOS_FLASH(int8_t request, ...);
#define dev_open_DEV_TELOS_FLASH(void) mos_mutex_lock(&telos_flash_mutex)
#define dev_close_DEV_TELOS_FLASH(void) mos_mutex_unlock(&telos_flash_mutex)

#endif // PLATFORM_TELOSB

/** @brief Reads count bytes from a device and stores the result in the 
 * provided buffer.
 */
#define dev_read(dev,buf,count) dev_read_##dev(buf, count)

/** @brief Writes count bytes to a device from the provided buffer. 
 */
#define dev_write(dev,buf,count) dev_write_##dev(buf, count)

/** @brief Set the mode of a device.
 */
#define dev_mode(dev,mode) dev_mode_##dev(mode)

/** @brief A pass-through to send arbitrary commands
    to a device (meaning is defined by device driver).
*/
#define dev_ioctl(dev,request,args...) dev_ioctl_##dev(request, ##args)

#define dev_open(dev) dev_open_##dev()
#define dev_close(dev) dev_close_##dev()

/*mode definitions*/
/** @brief Powered down. */
#define DEV_MODE_OFF     0 
/** @brief Device is idle (low-power mode). */
#define DEV_MODE_IDLE    1 
/** @brief Device is on. */
#define DEV_MODE_ON      2 

/*some ioctl definitions*/
/** @brief Device is connected. */
#define DEV_SEEK 1
#define DEV_FLUSH 2
#define DEV_LOCK 3
#define DEV_UNLOCK 4

#define DEV_OK 0
#define DEV_UNSUPPORTED -1
#define DEV_NOT_REGISTERED -2
#define DEV_OUT_OF_RANGE -3
#define DEV_BAD_IOCTL -4
#define DEV_BAD_MODE -5

#endif