Users » MRSa » Code » bc_ant

Ryoji Sakai / bc_ant

BC-ANT-SERIAL communication library.

Dependents: bc_ant-sample bc_ant-receiver

BeatcraftさんのBC-ANT-SERIAL を mbedで動かしてみました。

BC-ANT-SERIAL については、以下を参照ください。

http://labs.beatcraft.com/ja/index.php?ANT%2FBC-ANT-SERIAL%20%C0%E2%CC%C0%BD%F1

以下のような構成で、BC-ANT-SERIALを 9600bps に設定し、 BC-ANT-USB相手を相手に通信を行いました。（下図は受信例ですが、逆方向の送信も確認しました。）

/media/uploads/MRSa/bc-ant_mbed2.jpeg

なお、BC-ANT-SERIALを9600bpsの設定にする場合は、BR2をショートさせます。 /media/uploads/MRSa/bc-ant-serial9600.jpg

本ライブラリは、@ryuchi さんの　ANT/LPC1114用ライブラリをベタに持って来てmbed用にしました。

（UARTを使っている部分をSerialクラスに置き換えた程度で動いちゃいました。。。あんまり中身を見ていません。。）

ライブラリ使用例

受信で使用する場合

受信で使用する場合のmain.cpp例

#include "mbed.h"
#include "bc_ant.h"
 
DigitalOut myled(LED1);               // LEDチカチカ
 
Serial pc(USBTX, USBRX);           // USBへのデータ通信
bc_ant antPort(p13, p14, p15);    // for BC-ANT-SERIALの接続。(9600bps, p13, p14, ctsにp15)

/** ANT用の定数定義 **/
#define MAX_BUFSIZE   64          // 受信バッファサイズ用の定義
#define ANT_CH         0               // チャンネル番号
#define DEVICE_NUMBER 65      // デバイス番号
 
/**
 *  BC-ANT-SERIALでデータを受信した時の処理
 */
void receivedFromAnt()
{
    // 受信データを受け取る領域の確保
    uint8_t receivedLength = 0;
    uint8_t receivedBuffer[MAX_BUFSIZE];

    // データを受信する
    receivedLength = antPort.BC_ANT_RecvPacket(receivedBuffer, MAX_BUFSIZE);
 
   // 受信したデータを printf()して、PCのターミナルに表示する。
    printf("RX(%3d):", receivedLength);
    for (int index = 0; index < receivedLength; index++)
    {
        printf("%02x ", receivedBuffer[index]);
    }
    printf("\r\n");
}

/**
 *   BC-ANT-SERIALの(受信)初期化処理
 */
int initialize_ANTport()
{
    antPort.ANT_ResetSystem();
    antPort.ANT_AssignChannel(ANT_CH, ANT_Bidirectional_Slave, 0);   // チャンネルタイプの設定
    antPort.ANT_SetChannelId(ANT_CH,  DEVICE_NUMBER, 1, 1);          // チャンネルIDの設定
    antPort.ANT_SetChannelPeriod_Hz(ANT_CH, 4);                                // チャンネルピリオドの設定
    antPort.ANT_SetChannelRFFreq(ANT_CH, 4);                                    // 通信周波数の設定： 2404 MHz
    antPort.ANT_OpenChannel(ANT_CH);

    // コールバック関数の設定 （データを受信したら receivedFromAnt() を呼び出してもらうよう設定する）
    antPort.attach(&receivedFromAnt);

    return (0);
}
 
/**
 *    メイン処理
 */
int main()
{
    pc.baud(9600);                    // mbed と PCの間の通信速度を 9600bpsに設定する。
    initialize_ANTport();             // BC-ANT-SERIALを受信用に初期化する。
    printf("--- READY ----\r\n");  // 準備が出来たことを PCのターミナルに通知する。

    // 以下は、LEDチカチカ。 （デフォルトで生成される処理をそのまま残してます）
    while(1) {
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

送信で使用する場合

送信で使用する場合は、受信と比較して antPort.ANT_AssignChannel() と ANT_OpenChannel()のあとの処理が異なるぐらいです。

送受信で、antPort.ANT_SetChannelId(), antPort.ANT_SetChannelPeriod_Hz(), antPort.ANT_SetChannelRFFreq() の設定は合わせておく必要がありそうです。

送信で使用する場合のmain.cpp例

#include "mbed.h"
#include "bc_ant.h"

DigitalOut myled(LED1);               // LEDチカチカ

Serial pc(USBTX, USBRX);           // USBへのデータ通信
bc_ant antPort(p13, p14, p15);    // for BC-ANT-SERIALの接続。(9600bps, p13, p14, ctsにp15)

/** ANT用の定数定義 **/
#define MAX_BUFSIZE   64          // 受信バッファサイズ用の定義
#define ANT_CH         0               // チャンネル番号
#define DEVICE_NUMBER 65      // デバイス番号


/**
 *    PCのターミナルからキー入力された時の処理
 *    (キー入力の情報をAntポートに送る)
 */
void receivedPc()
{
    uint8_t buffer[MAX_BUFSIZE] =
    {
        0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff
    };
    while (pc.readable())
    {
        // データを取り出して、それをAntに送る
        unsigned char receivedChar =  (pc.getc() & 0xff);
        buffer[0] = receivedChar;
        antPort.ANT_SendAcknowledgedData(0, buffer);
    }
}

/**
 *   初期化処理
 */
int initialize_ANTport()
{
    antPort.ANT_ResetSystem();
    antPort.ANT_AssignChannel(ANT_CH, ANT_Bidirectional_Slave, 0);   // チャンネルタイプの設定
    antPort.ANT_SetChannelId(ANT_CH,  DEVICE_NUMBER, 1, 1);          // チャンネルIDの設定
    antPort.ANT_SetChannelPeriod_Hz(ANT_CH, 4);                                // チャンネルピリオドの設定
    antPort.ANT_SetChannelRFFreq(ANT_CH, 4);                                    // 通信周波数の設定： 2404 MHz
    antPort.ANT_OpenChannel(ANT_CH);
    {
        uint8_t buffer[MAX_BUFSIZE] =
        {
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
        };
        antPort.ANT_SendBroadcastData(0, buffer);  // データ送信？
    }
    return (0);
}

/**
 *   メイン処理
 */
int main()
{
    pc.baud(9600);                                      // PCとの通信速度を 9600bps に設定する
    pc.attach(&receivedPc,Serial::RxIrq);    // PCからデータが送られてきた場合、receviedPc() 関数を呼び出す用に設定する

    initialize_ANTport()   // BC-ANT-SERIALの初期化を行う

    printf("--- READY ----\r\n");  // 準備が出来たことを PCのターミナルに通知する。
    
    // 以下は、LEDチカチカ。 （デフォルトで生成される処理をそのまま残してます）
    while(1) {
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

参考:BC-ANT-USB側

動作確認をした BC-ANT-USB 側は、ANT/BCA_Lib のページにある BCA_Lib.zipのSendCB.exe, RecvCB.exe を利用させて頂きました。

ただし、BCA_OpenChannel() の引数は以下のように変更しました。

SendCB.cppで変更した箇所(SendCB.cpp:52行目あたり)

	res = BCA_OpenChannel(dev,						//	device
						  0,						//	channel no
						  BCA_CHANNEL_TYPE_MASTER,	//	channel type
						  BCA_CHANNEL_NOSHARED,		//	shared channel
						  65,						//	device no
						  1,						//	device type
						  1,						//	trans type
						  4,						//	freq
						  4);						//	hz

RecvCB.cppで変更した箇所(RecvCB.cpp:54行目あたり)

	res = BCA_OpenChannel(dev,						//	device
						  0,						//	channel no
						  BCA_CHANNEL_TYPE_SLAVE,	//	channel type
						  BCA_CHANNEL_NOSHARED,     //	shared channel
						  0,						//	device no
						  0,						//	device type
						  0,						//	trans type
						  4,						//	freq
						  4.0);						//	hz

備忘録

ほんとにベタ移植で動いた、という段階なので、中身を確認して理解しないといけない。
きれいにクラス化したい。
ちゃんとコードに説明を書きたい。

bc_ant.cpp

Committer:: MRSa
Date:: 2013-03-17
Revision:: 1:b166aab45b3f
Parent:: 0:97c748c69103

File content as of revision 1:b166aab45b3f:

/*
 * ant.c
 *
 *  Created on: 2012/10/12
 *      Author: ryuchi
 *
 *      Adapted for mbed by MRSa (17.Mar.2013)
 */

#include "bc_ant.h"

using namespace mbed;

bc_ant::bc_ant(PinName tx, PinName rx, PinName cts, int baudRate) : _serialPort(tx, rx), _cts(cts)
{
    _serialPort.baud(baudRate);
}

void bc_ant::attach(void(*fptr)(void), Serial::IrqType type)
{
   _serialPort.attach(fptr, type);
}

uint32_t bc_ant::BC_ANT_RecvPacket(uint8_t *buffer, uint32_t size)
{
    uint8_t checksum;
    uint32_t length, mesg_len;

    if (_serialPort.readable() == false)
    {
        return (0);
    }

    while (!(_serialPort.getc() == ANT_SYNCBYTE));

    *buffer++ = ANT_SYNCBYTE;
    checksum = ANT_SYNCBYTE;
    length = 1;

    mesg_len = _serialPort.getc();
    *buffer++ = mesg_len;
    checksum ^= mesg_len;
    length++;

    *buffer  = _serialPort.getc();
    checksum ^= *buffer++;
    length++;

    while(mesg_len--)
    {
        *buffer = _serialPort.getc();
        checksum ^= *buffer++;
        length++;
        if (size < length)
        {
            return 0;
        }
    }
    *buffer = _serialPort.getc();
    
    return (length + 1);
}

uint32_t bc_ant::BC_ANT_SendPacket(uint8_t *packet, uint32_t size)
{
    while (_cts.read() != 0);
    for (int index = 0; index < size; index++)
    {
        _serialPort.putc(*(packet + index));
    }
    //_serialPort.write(packet, size);

    return 0;
}

uint32_t bc_ant::BC_ANT_build_packet( uint8_t *source, uint32_t size, uint8_t *dist ) {

    uint8_t checksum;
    uint8_t *p = dist;
    uint32_t i;

    *p++ =     ANT_SYNCBYTE;
    checksum = ANT_SYNCBYTE;

    size &= 63;
    *p++ = size;
    checksum ^= size;
    i = size + 1;

    while( i-- ) {
        checksum = checksum ^ *source;
        *p++ = *source++;
    }

    *p++ = checksum;
    *p++ = 0x00;
    *p++ = 0x00;

    return size + 6;

}

uint32_t bc_ant::ANT_UnAssignChannel( uint8_t Channel ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_UNASSIGN_CHANNEL;
    *p = Channel;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_AssignChannel(
        uint8_t Channel,
        uint8_t ChannelType,
        uint8_t NetworkNumber ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ASSIGN_CHANNEL;
    *p++ = Channel;
    *p++ = ChannelType;
    *p++ = NetworkNumber;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_AssignChannelExt(
        uint8_t Channel,
        uint8_t ChannelType,
        uint8_t NetworkNumber,
        uint8_t ExtendAssignment ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ASSIGN_CHANNEL;
    *p++ = Channel;
    *p++ = ChannelType;
    *p++ = NetworkNumber;
    *p++ = ExtendAssignment;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 4, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SetChannelId(
        uint8_t Channel,
        uint16_t DeviceNum,
        uint8_t DeviceType,
        uint8_t TransmissionType ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_SET_CHANNEL_ID;
    *p++ = Channel;
    *p++ = DeviceNum & 0xff;
    *p++ = DeviceNum >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 5, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SetChannelPeriod(
        uint8_t Channel,
        uint16_t MessagePeriod ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CHANNEL_MESSAGING_PREIOD;
    *p++ = Channel;
    *p++ = MessagePeriod & 0xff;
    *p++ = MessagePeriod >> 8;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;


}

uint32_t bc_ant::ANT_SetChannelPeriod_Hz(
        uint8_t Channel,
        uint16_t Period ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;
    uint16_t MessagePeriod;

    MessagePeriod = 32768 / Period;

    *p++ = ANT_CHANNEL_MESSAGING_PREIOD;
    *p++ = Channel;
    *p++ = MessagePeriod & 0xff;
    *p++ = MessagePeriod >> 8;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;


}

uint32_t bc_ant::ANT_SetChannelSearchTimeout(
        uint8_t ChannelNum,
        uint8_t SearchTimeout ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CHANNEL_SEARCH_TIMEOUT;
    *p++ = ChannelNum;
    *p++ = SearchTimeout;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;


}
uint32_t bc_ant::ANT_SetChannelRFFreq(
        uint8_t Channel,
        uint8_t RFFreq ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CHANNEL_RF_FREQUENCY;
    *p++ = Channel;
    *p++ = RFFreq;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_SetNetworkKey(
        uint8_t NetworkNumber,
        uint8_t *pubKey) {

    uint8_t *p = BC_ANT_buffer, *key = pubKey;
    uint32_t i, psize;

    *p++ = ANT_SET_NETWORK_KEY;
    *p++ = NetworkNumber;
    for ( i = 0; i < 7; i++ ) {
        *p++ = *key++;
    }

    psize = BC_ANT_build_packet( BC_ANT_buffer, 9, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_SetTransmitPower(
        uint8_t TransmitPower ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_TRANSMIT_POWER;
    *p++ = 0;
    *p++ = TransmitPower & 0x03;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_AddChannelID(
        uint8_t Channel,
        uint16_t DeviceNum,
        uint8_t DeviceTypeId,
        uint8_t TransmissionType,
        uint8_t ListIndex ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ADD_CHANNEL_ID;
    *p++ = Channel;
    *p++ = DeviceNum & 0xff;
    *p++ = DeviceNum >> 8;
    *p++ = DeviceTypeId;
    *p++ = TransmissionType;
    *p++ = ListIndex & 0x03;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 5, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_ConfigList(
        uint8_t Channel,
        uint8_t ListSize,
        uint8_t Exclude ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CONFIG_LIST_ID;
    *p++ = Channel;
    *p++ = ListSize & 0x07;
    *p++ = Exclude & 0x01;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_SetChannelTxPower(
        uint8_t Channel,
        uint8_t TxPower ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_SET_CHANNEL_TX_POWER;
    *p++ = Channel;
    *p++ = TxPower & 0x03;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_SetLowPriorityChannelSearchTimeout(
        uint8_t ChannelNum,
        uint8_t SearchTimeout ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CHANNEL_LOW_PRIORITY_SERARCH_TIMEOUT;
    *p++ = ChannelNum;
    *p++ = SearchTimeout;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;


}
uint32_t bc_ant::ANT_SetSerialNumChannelId(
        uint8_t Channel,
        uint8_t DeviceType,
        uint8_t TransmissionType ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_SERIAL_NUMBER_CHANNEL_ID;
    *p++ = Channel;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_RxExtMesgsEnable( uint8_t Enable ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ENABLE_EXTENDED_MESSAGGES;
    *p++ = 0;
    *p++ = Enable;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_EnableLED( uint8_t Enable ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ENABLE_LED;
    *p++ = 0;
    *p++ = Enable;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_CrystalEnable( uint8_t Enable ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_ENABLE_CRYSTAL;
    *p++ = 0;
    *p++ = Enable;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;


}
uint32_t bc_ant::ANT_ConfigFrequencyAgility(
        uint8_t Channel,
        uint8_t Frequency1,
        uint8_t Frequency2,
        uint8_t Frequency3 ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_FREQUENCY_AGILITY;
    *p++ = Channel;
    *p++ = Frequency1;
    *p++ = Frequency2;
    *p++ = Frequency3;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 4, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}
uint32_t bc_ant::ANT_SetProximitySearch(
        uint8_t Channel,
        uint8_t SearchThreshold ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_PROXIMITY_SEARCH;
    *p++ = Channel;
    *p++ = SearchThreshold;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SetUSBDescriptorString(
        uint8_t StringNum,
        uint8_t *pubDescString,
        uint8_t StringSize ) {

    uint8_t *p = BC_ANT_buffer, *d = pubDescString;
    uint32_t psize, i;

    *p++ = ANT_SET_USB_DESCRIPTOR_STRING;
    *p++ = StringNum;

    i = StringSize;
    if ( i > 32)
        i = 32;

    while( i-- ) {
        *p++ = *d++;
    }
    *p++ = StringSize;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_ResetSystem ( void ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_RESET_SYSTEM;
    *p++ = 0;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;
}

uint32_t bc_ant::ANT_OpenChannel(uint32_t Channel ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_OPEN_CHANNEL;
    *p++ = Channel;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_CloseChannel(uint32_t Channel ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CLOSE_CHANNEL;
    *p++ = Channel;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;
}

uint32_t bc_ant::ANT_RequestMessage(uint32_t Channel, uint8_t MessageID ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_REQUEST_MESSAGE;
    *p++ = Channel;
    *p++ = MessageID;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 2, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_OpenRxScanMode( void ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_OPEN_RX_SCAN_MODE;
    *p++ = 0;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SleepMessage( void ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_SLEEP_MESSAGE;
    *p++ = 0;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendBroadcastData(
        uint8_t Channel,
        uint8_t * BroadcastData ) {

    uint8_t *p = BC_ANT_buffer, *d = BroadcastData;
    uint32_t psize, i;

    *p++ = ANT_BROADCAST_DATA;
    *p++ = Channel;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 9, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendBroadcastDataExt(
        uint8_t Channel,
        uint8_t *BroadcastData,
        uint16_t DeviceNumber,
        uint8_t DeviceType,
        uint8_t TransmissionType ) {

    uint8_t *p = BC_ANT_buffer, *d = BroadcastData;
    uint32_t psize, i;

    *p++ = ANT_BROADCAST_DATA;
    *p++ = Channel;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    *p++ = 0x80;
    *p++ = DeviceNumber & 0xff;
    *p++ = DeviceNumber >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 14, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendAcknowledgedData(
        uint8_t Channel,
        uint8_t *BroadcastData ) {

    uint8_t *p = BC_ANT_buffer, *d = BroadcastData;
    uint32_t psize, i;

    *p++ = ANT_ACKNOWLEDGED_DATA;
    *p++ = Channel;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 9, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendAcknowledgedDataExt(
        uint8_t Channel,
        uint8_t *BroadcastData,
        uint16_t DeviceNumber,
        uint8_t DeviceType,
        uint8_t TransmissionType ) {

    uint8_t *p = BC_ANT_buffer, *d = BroadcastData;
    uint32_t psize, i;

    *p++ = ANT_ACKNOWLEDGED_DATA;
    *p++ = Channel;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    *p++ = 0x80;
    *p++ = DeviceNumber & 0xff;
    *p++ = DeviceNumber >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 14, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendBurstTransferPacket(
        uint8_t ChannelSeq,
        uint8_t *BurstData ) {

    uint8_t *p = BC_ANT_buffer, *d = BurstData;
    uint32_t psize, i;

    *p++ = ANT_BURST_DATA;
    *p++ = ChannelSeq;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 9, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;
}

uint32_t bc_ant::ANT_InitCWTestMode( void ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_INIT_CW_TEST_MODE;
    *p++ = 0;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 1, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SetCWTestMode(
        uint8_t TransmitPower,
        uint8_t RFChannel ) {

    uint8_t *p = BC_ANT_buffer;
    uint32_t psize;

    *p++ = ANT_CW_TEST_MODE;
    *p++ = 0;
    *p++ = TransmitPower;
    *p++ = RFChannel;

    psize = BC_ANT_build_packet( BC_ANT_buffer, 3, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendExtBroadcastData(
        uint8_t Channel,
        uint16_t DeviceNum,
        uint8_t DeviceType,
        uint8_t TransmissionType,
        uint8_t *Data ) {

    uint8_t *p = BC_ANT_buffer, *d = Data;
    uint32_t psize, i;

    *p++ = ANT_EXTENDED_BROADCAST_DATA;
    *p++ = Channel;
    *p++ = DeviceNum & 0xff;
    *p++ = DeviceNum >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 13, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendExtAcknowledgedData(
        uint8_t Channel,
        uint16_t DeviceNum,
        uint8_t DeviceType,
        uint8_t TransmissionType,
        uint8_t *Data ) {

    uint8_t *p = BC_ANT_buffer, *d = Data;
    uint32_t psize, i;

    *p++ = ANT_EXTENDED_ACKNOWLEDGED_DATA;
    *p++ = Channel;
    *p++ = DeviceNum & 0xff;
    *p++ = DeviceNum >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 13, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;

}

uint32_t bc_ant::ANT_SendExtBurstData(
        uint8_t ChannelSeq,
        uint16_t DeviceNum,
        uint8_t DeviceType,
        uint8_t TransmissionType,
        uint8_t *Data ) {

    uint8_t *p = BC_ANT_buffer, *d = Data;
    uint32_t psize, i;

    *p++ = ANT_EXTENDED_BURST_DATA;
    *p++ = ChannelSeq;
    *p++ = DeviceNum & 0xff;
    *p++ = DeviceNum >> 8;
    *p++ = DeviceType;
    *p++ = TransmissionType;

    for( i = 0; i < 8; i++ ) {
        *p++ = *d++;
    }
    psize = BC_ANT_build_packet( BC_ANT_buffer, 13, BC_ANT_raw_buffer );
    BC_ANT_SendPacket( BC_ANT_raw_buffer, psize);

    return 0;
}

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	17 Mar 2013
Imports:	38
Forks:	0
Commits:	2
Dependents:	2
Dependencies:	0
Followers:	1