mirror of
https://github.com/pascallanger/DIY-Multiprotocol-TX-Module.git
synced 2025-02-04 15:58:12 +00:00
603 lines
14 KiB
C++
603 lines
14 KiB
C++
/*
|
|
This project is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Multiprotocol is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Multiprotocol. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
// Compatible with CADET PRO V4 TX
|
|
|
|
#if defined(PELIKAN_A7105_INO)
|
|
|
|
#include "iface_a7105.h"
|
|
|
|
//#define PELIKAN_FORCE_ID
|
|
//#define PELIKAN_LITE_FORCE_ID
|
|
#define PELIKAN_LITE_FORCE_HOP // hop sequence creation is unknown
|
|
//#define PELIKAN_SCX24_FORCE_ID
|
|
//#define PELIKAN_SCX24_FORCE_HOP // hop sequence creation is unknown
|
|
|
|
#define PELIKAN_BIND_COUNT 400 // 3sec
|
|
#define PELIKAN_BIND_RF 0x3C
|
|
#define PELIKAN_NUM_RF_CHAN 0x1D
|
|
#define PELIKAN_PACKET_PERIOD 7980
|
|
#define PELIKAN_LITE_PACKET_PERIOD 18000
|
|
#define PELIKAN_SCX24_PACKET_PERIOD 15069
|
|
#define PELIKAN_SCX_HOP_LIMIT 90
|
|
|
|
static void __attribute__((unused)) pelikan_build_packet()
|
|
{
|
|
static boolean upper=false;
|
|
uint8_t sum;
|
|
uint16_t channel;
|
|
|
|
#ifndef MULTI_AIR
|
|
if(sub_protocol == PELIKAN_SCX24)
|
|
packet[0] = 0x11;
|
|
else //PELIKAN_PRO & PELIKAN_LITE
|
|
#endif
|
|
packet[0] = 0x15;
|
|
if(IS_BIND_IN_PROGRESS)
|
|
{
|
|
packet[2] = rx_tx_addr[0];
|
|
packet[3] = rx_tx_addr[1];
|
|
packet[4] = rx_tx_addr[2];
|
|
packet[5] = rx_tx_addr[3];
|
|
|
|
#ifndef MULTI_AIR
|
|
if(sub_protocol == PELIKAN_SCX24)
|
|
{
|
|
packet[1] = 0x65; //??
|
|
packet[6] = 0x55; //??
|
|
packet[7] = 0xAA; //??
|
|
}
|
|
else
|
|
#endif
|
|
{//PELIKAN_PRO & PELIKAN_LITE
|
|
packet[1] = 0x04; //version??
|
|
if(sub_protocol==PELIKAN_PRO)
|
|
packet[6] = 0x05; //sub version??
|
|
else //PELIKAN_LITE
|
|
packet[6] = 0x03; //sub version??
|
|
packet[7] = 0x00; //??
|
|
}
|
|
packet[8] = 0x55; //??
|
|
packet_length = 10;
|
|
}
|
|
else
|
|
{
|
|
//ID
|
|
packet[1] = rx_tx_addr[0];
|
|
#ifndef MULTI_AIR
|
|
if(sub_protocol == PELIKAN_SCX24)
|
|
{
|
|
//ID
|
|
packet[4] = rx_tx_addr[1];
|
|
//Channels
|
|
channel = Channel_data[0]; //STEERING: 1B1..23B..2C5 ???
|
|
packet[2] = channel >> 9;
|
|
packet[3] = channel >> 1;
|
|
channel = Channel_data[1]; //THROTTLE: 0DB..1FF..30E
|
|
packet[5] = channel >> 9;
|
|
packet[6] = channel >> 1;
|
|
channel = Channel_data[2]; //CH3: 055..3AA
|
|
packet[7] = channel >> 9;
|
|
packet[8] = channel >> 1;
|
|
//Hopping counters
|
|
if(++packet_count>2)
|
|
{
|
|
packet_count=0;
|
|
if(++hopping_frequency_no>=PELIKAN_NUM_RF_CHAN)
|
|
hopping_frequency_no=0;
|
|
}
|
|
//Length
|
|
packet_length = 14;
|
|
}
|
|
else
|
|
#endif
|
|
{//PELIKAN_PRO & PELIKAN_LITE
|
|
//ID
|
|
packet[7] = rx_tx_addr[1];
|
|
//Channels
|
|
uint8_t offset=upper?4:0;
|
|
channel=convert_channel_16b_nolimit(CH_AETR[offset++], 153, 871,false);
|
|
uint8_t top=(channel>>2) & 0xC0;
|
|
packet[2] = channel;
|
|
channel=convert_channel_16b_nolimit(CH_AETR[offset++], 153, 871,false);
|
|
top|=(channel>>4) & 0x30;
|
|
packet[3] = channel;
|
|
channel=convert_channel_16b_nolimit(CH_AETR[offset++], 153, 871,false);
|
|
top|=(channel>>6) & 0x0C;
|
|
packet[4] = channel;
|
|
channel=convert_channel_16b_nolimit(CH_AETR[offset], 153, 871,false);
|
|
top|=(channel>>8) & 0x03;
|
|
packet[5] = channel;
|
|
packet[6] = top;
|
|
//Check
|
|
sum=0x00;
|
|
for(uint8_t i=0;i<8;i++)
|
|
sum+=packet[i];
|
|
packet[8]=sum;
|
|
//Low/Up channel flag
|
|
packet[9]=upper?0xAA:0x00;
|
|
upper=!upper;
|
|
//Hopping counters
|
|
if(sub_protocol==PELIKAN_LITE || ++packet_count>4)
|
|
{
|
|
packet_count=0;
|
|
if(++hopping_frequency_no>=PELIKAN_NUM_RF_CHAN)
|
|
hopping_frequency_no=0;
|
|
}
|
|
//Length
|
|
packet_length = 15;
|
|
}
|
|
//Hopping
|
|
packet[packet_length-5] = hopping_frequency_no;
|
|
packet[packet_length-4] = packet_count;
|
|
//ID
|
|
packet[packet_length-3] = rx_tx_addr[2];
|
|
packet[packet_length-2] = rx_tx_addr[3];
|
|
}
|
|
|
|
//Check
|
|
sum=0x00;
|
|
for(uint8_t i=0; i<packet_length-1 ;i++)
|
|
sum+=packet[i];
|
|
packet[packet_length-1] = sum;
|
|
|
|
//Send
|
|
#ifdef DEBUG_SERIAL
|
|
debug("C: %02X P(%d):",IS_BIND_IN_PROGRESS?PELIKAN_BIND_RF:hopping_frequency[hopping_frequency_no],packet_length);
|
|
for(uint8_t i=0;i<packet_length;i++)
|
|
debug(" %02X",packet[i]);
|
|
debugln("");
|
|
#endif
|
|
A7105_WriteData(packet_length, IS_BIND_IN_PROGRESS?PELIKAN_BIND_RF:hopping_frequency[hopping_frequency_no]);
|
|
A7105_SetPower();
|
|
}
|
|
|
|
uint16_t PELIKAN_callback()
|
|
{
|
|
#ifdef MULTI_AIR
|
|
if(sub_protocol == PELIKAN_SCX24)
|
|
{
|
|
SUB_PROTO_INVALID;
|
|
return 10000;
|
|
}
|
|
#endif
|
|
if(phase==0)
|
|
{
|
|
#ifndef FORCE_PELIKAN_TUNING
|
|
A7105_AdjustLOBaseFreq(1);
|
|
#endif
|
|
if(IS_BIND_IN_PROGRESS)
|
|
{
|
|
bind_counter--;
|
|
if (bind_counter==0)
|
|
{
|
|
BIND_DONE;
|
|
A7105_Strobe(A7105_STANDBY);
|
|
if(sub_protocol==PELIKAN_PRO)
|
|
A7105_WriteReg(A7105_03_FIFOI,0x28); //????
|
|
else if(sub_protocol==PELIKAN_LITE)
|
|
A7105_WriteID(MProtocol_id);
|
|
#ifndef MULTI_AIR
|
|
else // PELIKAN_SCX24
|
|
A7105_WriteReg(A7105_03_FIFOI,0x0D);
|
|
#endif
|
|
}
|
|
}
|
|
#ifdef MULTI_SYNC
|
|
telemetry_set_input_sync(packet_period);
|
|
#endif
|
|
pelikan_build_packet();
|
|
if(IS_BIND_IN_PROGRESS || sub_protocol != PELIKAN_LITE)
|
|
return packet_period;
|
|
//PELIKAN_LITE
|
|
phase++;
|
|
return 942;
|
|
}
|
|
//PELIKAN_LITE
|
|
A7105_Strobe(A7105_TX);
|
|
phase++;
|
|
if(phase==1)
|
|
return 942;
|
|
phase=0;
|
|
return PELIKAN_LITE_PACKET_PERIOD-942-942;
|
|
}
|
|
|
|
static uint8_t pelikan_firstCh(uint8_t u, uint8_t l)
|
|
{
|
|
int16_t i;
|
|
i = u * 10 + l - 23;
|
|
do
|
|
{
|
|
if (i > 24)
|
|
i -= 24;
|
|
if (i <= 0)
|
|
return 10;
|
|
else if ((i > 0) && (i < 13))
|
|
return 10 + 12 + (i * 4);
|
|
else if ((i > 12) && (i < 24))
|
|
return 10 - 2 + ((i - 12) * 4);
|
|
}
|
|
while (i > 24);
|
|
return 0;
|
|
}
|
|
|
|
static uint8_t pelikan_firstCh_scx(uint8_t i, uint8_t j)
|
|
{
|
|
uint8_t ch;
|
|
switch (j) {
|
|
case 0:
|
|
ch = 30;
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
ch = (i * 4) + 42;
|
|
break;
|
|
case 3:
|
|
ch = (i * 2) + 36;
|
|
break;
|
|
case 4:
|
|
ch = (i * 8) + 54;
|
|
break;
|
|
case 5:
|
|
ch = 30;
|
|
break;
|
|
}
|
|
|
|
if (ch > PELIKAN_SCX_HOP_LIMIT)
|
|
{
|
|
do
|
|
{
|
|
ch -= 62;
|
|
} while (ch > PELIKAN_SCX_HOP_LIMIT);
|
|
}
|
|
|
|
switch (ch) {
|
|
case 48:
|
|
if (j == 3)
|
|
ch += 18;
|
|
else if (j == 4)
|
|
ch += 20;
|
|
else
|
|
ch += 40;
|
|
break;
|
|
case 40:
|
|
if (j == 4)
|
|
ch += 18;
|
|
break;
|
|
case 52:
|
|
if (j < 3)
|
|
ch -= 20;
|
|
else if (j == 4)
|
|
ch -= 10;
|
|
break;
|
|
case 66:
|
|
if (j < 3)
|
|
ch += 18;
|
|
else if (j == 4)
|
|
ch -= 22;
|
|
break;
|
|
case 72:
|
|
if (j < 3)
|
|
ch -= 10;
|
|
else if (j ==3)
|
|
ch -= 20;
|
|
else if (j == 4)
|
|
ch -= 36;
|
|
break;
|
|
case 74:
|
|
if (j == 4)
|
|
ch -= 20;
|
|
break;
|
|
case 86:
|
|
if (j == 4)
|
|
ch -= 48;
|
|
break;
|
|
}
|
|
|
|
return ch;
|
|
}
|
|
|
|
static uint8_t pelikan_adjust_value(uint8_t value, uint8_t addition, uint8_t limit)
|
|
{
|
|
uint8_t i;
|
|
do
|
|
{
|
|
i = 0;
|
|
if (value > limit) {
|
|
value -= 62;
|
|
i++;
|
|
}
|
|
if (value == 24) {
|
|
value += addition;
|
|
i++;
|
|
}
|
|
if (value == 48) {
|
|
value += addition;
|
|
i++;
|
|
}
|
|
if (value == 72) {
|
|
value += addition;
|
|
i++;
|
|
}
|
|
}
|
|
while (i > 0);
|
|
|
|
return value;
|
|
}
|
|
|
|
static uint8_t pelikan_add(uint8_t pfrq,uint8_t a, uint8_t limit)
|
|
{
|
|
uint8_t nfrq;
|
|
nfrq = pfrq + a;
|
|
|
|
nfrq = pelikan_adjust_value(nfrq, a, limit);
|
|
|
|
return nfrq;
|
|
}
|
|
|
|
static void __attribute__((unused)) pelikan_init_hop()
|
|
{
|
|
#define PELIKAN_HOP_LIMIT 70
|
|
rx_tx_addr[0] = 0;
|
|
rx_tx_addr[1]+= RX_num;
|
|
uint8_t high = (rx_tx_addr[1]>>4) % 3; // 0..2
|
|
uint8_t low = rx_tx_addr[1] & 0x0F;
|
|
if(high==2)
|
|
low %= 0x04; // 0..3
|
|
else if(high)
|
|
low %= 0x0E; // 0..D
|
|
else
|
|
low %= 0x0F; // 0..E
|
|
rx_tx_addr[1] = (high<<4) + low;
|
|
uint8_t addition = (20 * high)+ (2 * low) + 8;
|
|
|
|
uint8_t first_channel = pelikan_firstCh(high, low);
|
|
first_channel = pelikan_adjust_value(first_channel, addition, PELIKAN_HOP_LIMIT);
|
|
hopping_frequency[0] = first_channel;
|
|
debug("%02X", first_channel);
|
|
for (uint8_t i = 1; i < PELIKAN_NUM_RF_CHAN; i++)
|
|
{
|
|
hopping_frequency[i] = pelikan_add(hopping_frequency[i-1], addition, PELIKAN_HOP_LIMIT);
|
|
debug(" %02X", hopping_frequency[i]);
|
|
}
|
|
debugln("");
|
|
}
|
|
|
|
#ifndef MULTI_AIR
|
|
|
|
const uint8_t PROGMEM scx_ch_map[4][PELIKAN_NUM_RF_CHAN] =
|
|
{
|
|
{0,1,2,26,27,28,23,24,25,20,21,22,17,18,19,14,15,16,11,12,13,8,9,10,5,6,7,4,3},
|
|
{0,1,2,28,25,26,27,24,21,22,23,20,17,18,19,16,13,14,15,12,9,10,11,8,5,6,7,3,4},
|
|
{0,1,27,28,25,26,23,24,21,22,19,20,17,18,15,16,13,14,11,12,9,10,7,8,5,6,3,4,2},
|
|
{0,1,28,1,4,2,23,26,22,24,27,25,17,20,16,18,21,19,11,14,10,12,15,13,27,8,6,7,9}
|
|
};
|
|
|
|
static void pelikan_shuffle(uint8_t j)
|
|
{
|
|
uint8_t temp[PELIKAN_NUM_RF_CHAN];
|
|
for (uint8_t i = 0; i < PELIKAN_NUM_RF_CHAN; i++)
|
|
temp[i] = hopping_frequency[pgm_read_byte_near(&scx_ch_map[j-1][i])];
|
|
|
|
for (uint8_t i = 0; i < PELIKAN_NUM_RF_CHAN; i++)
|
|
hopping_frequency[i] = temp[i];
|
|
}
|
|
|
|
static void __attribute__((unused)) pelikan_init_hop_scx()
|
|
{
|
|
rx_tx_addr[0] = 0x10;
|
|
rx_tx_addr[1] = (rx_tx_addr[1] + RX_num) % 192;
|
|
debugln("TX[0]: %02X TX[1]: %02X", rx_tx_addr[0], rx_tx_addr[1]);
|
|
|
|
uint8_t high = (rx_tx_addr[1]>>4);
|
|
uint8_t low = rx_tx_addr[1] & 0x0F;
|
|
int16_t i = (high * 10) + low - 23;
|
|
uint8_t j = 0;
|
|
|
|
if (i > 0)
|
|
j = 1;
|
|
|
|
if (i > 24)
|
|
{
|
|
do
|
|
{
|
|
i -= 24;
|
|
j++;
|
|
} while (i > 24);
|
|
}
|
|
|
|
debugln("H: %02X L: %02X I: %02X J: %02X", high, low, i, j);
|
|
|
|
uint8_t first_channel;
|
|
uint8_t last_channel;
|
|
uint8_t addition;
|
|
|
|
first_channel = pelikan_firstCh_scx(i, j);
|
|
|
|
if (j == 0)
|
|
last_channel = 42 - (high * 10) - low;
|
|
else
|
|
last_channel = 42 - i + 1;
|
|
|
|
if (last_channel == 24)
|
|
last_channel += 9;
|
|
|
|
if (last_channel == 36)
|
|
last_channel -= 10;
|
|
|
|
if (j == 0)
|
|
addition = (2 * i) + 54;
|
|
else if (j == 5)
|
|
addition = (2 * i) + 6;
|
|
else
|
|
addition = 56 - (2 * i);
|
|
|
|
hopping_frequency[0] = first_channel;
|
|
for (uint8_t i = 1; i < PELIKAN_NUM_RF_CHAN; i++)
|
|
{
|
|
hopping_frequency[i] = pelikan_add(hopping_frequency[i-1], addition, PELIKAN_SCX_HOP_LIMIT);
|
|
}
|
|
|
|
if (j > 0 && j < 5)
|
|
pelikan_shuffle(j);
|
|
|
|
if (j == 2)
|
|
{
|
|
hopping_frequency[PELIKAN_NUM_RF_CHAN - 2] = last_channel;
|
|
} else if (j == 4)
|
|
{
|
|
uint8_t t = (2 * i) + 36;
|
|
if (t == 48)
|
|
t += 18;
|
|
if (t == 72)
|
|
t -= 20;
|
|
|
|
hopping_frequency[1] = t;
|
|
hopping_frequency[PELIKAN_NUM_RF_CHAN - 5] = last_channel;
|
|
}
|
|
else
|
|
{
|
|
hopping_frequency[PELIKAN_NUM_RF_CHAN - 1] = last_channel;
|
|
}
|
|
|
|
#ifdef DEBUG_SERIAL
|
|
for (uint8_t i = 0; i < PELIKAN_NUM_RF_CHAN; i++)
|
|
debug("%02X ", hopping_frequency[i]);
|
|
debugln("");
|
|
#endif
|
|
}
|
|
|
|
#ifdef PELIKAN_SCX24_FORCE_HOP
|
|
const uint8_t PROGMEM pelikan_scx24_hopp[][PELIKAN_NUM_RF_CHAN] = {
|
|
/*TX1*/ { 0x1E,0x32,0x46,0x5A,0x44,0x58,0x2E,0x42,0x56,0x2C,0x40,0x54,0x2A,0x3E,0x52,0x28,0x3C,0x50,0x26,0x3A,0x4E,0x24,0x38,0x4C,0x22,0x36,0x4A,0x20,0x1A },
|
|
/*TX2*/ { 0x2C,0x44,0x1E,0x52,0x56,0x22,0x3A,0x3E,0x34,0x4C,0x26,0x5A,0x50,0x2A,0x42,0x38,0x2E,0x46,0x20,0x54,0x4A,0x24,0x3C,0x32,0x28,0x40,0x58,0x1B,0x4E },
|
|
/*TX3*/ { 0x3C,0x4C,0x1E,0x4A,0x5A,0x2C,0x58,0x2A,0x3A,0x56,0x28,0x38,0x26,0x36,0x46,0x34,0x44,0x54,0x42,0x52,0x24,0x50,0x22,0x32,0x4E,0x20,0x40,0x3E,0x17 },
|
|
/*TX4*/ { 0x46,0x32,0x1E,0x58,0x44,0x5A,0x56,0x42,0x2E,0x54,0x40,0x2C,0x52,0x3E,0x2A,0x50,0x3C,0x28,0x4E,0x3A,0x26,0x4C,0x38,0x24,0x4A,0x36,0x22,0x20,0x1A }
|
|
};
|
|
#endif //PELIKAN_SCX24_FORCE_HOP
|
|
|
|
#endif //MULTI_AIR
|
|
|
|
#ifdef PELIKAN_FORCE_ID
|
|
const uint8_t PROGMEM pelikan_hopp[][PELIKAN_NUM_RF_CHAN] = {
|
|
{ 0x5A,0x46,0x32,0x6E,0x6C,0x58,0x44,0x42,0x40,0x6A,0x56,0x54,0x52,0x3E,0x68,0x66,0x64,0x50,0x3C,0x3A,0x38,0x62,0x4E,0x4C,0x5E,0x4A,0x36,0x5C,0x34 }
|
|
};
|
|
#endif
|
|
|
|
#ifdef PELIKAN_LITE_FORCE_HOP
|
|
const uint8_t PROGMEM pelikan_lite_hopp[][PELIKAN_NUM_RF_CHAN] = {
|
|
{ 0x46,0x2A,0x3E,0x5A,0x5C,0x24,0x4E,0x32,0x54,0x26,0x2C,0x34,0x56,0x1E,0x3A,0x3C,0x50,0x4A,0x2E,0x42,0x20,0x52,0x28,0x22,0x44,0x58,0x36,0x38,0x4C }
|
|
};
|
|
#endif
|
|
|
|
void PELIKAN_init()
|
|
{
|
|
A7105_Init();
|
|
if(IS_BIND_IN_PROGRESS || sub_protocol==PELIKAN_LITE)
|
|
A7105_WriteReg(A7105_03_FIFOI,0x10);
|
|
|
|
bind_counter = PELIKAN_BIND_COUNT;
|
|
|
|
if(sub_protocol==PELIKAN_PRO)
|
|
{
|
|
pelikan_init_hop();
|
|
//ID from dump
|
|
#if defined(PELIKAN_FORCE_ID)
|
|
rx_tx_addr[0]=0x0D; // hopping freq
|
|
rx_tx_addr[1]=0xF4; // hopping freq
|
|
rx_tx_addr[2]=0x50; // ID
|
|
rx_tx_addr[3]=0x18; // ID
|
|
// Fill frequency table
|
|
for(uint8_t i=0;i<PELIKAN_NUM_RF_CHAN;i++)
|
|
hopping_frequency[i]=pgm_read_byte_near(&pelikan_hopp[0][i]);
|
|
#endif
|
|
packet_period = PELIKAN_PACKET_PERIOD;
|
|
}
|
|
else
|
|
{
|
|
bind_counter >>= 1;
|
|
if(sub_protocol==PELIKAN_LITE)
|
|
{
|
|
#if defined(PELIKAN_LITE_FORCE_HOP)
|
|
// Hop frequency table
|
|
rx_tx_addr[0]=0x04; // hopping freq
|
|
rx_tx_addr[1]=0x63; // hopping freq
|
|
for(uint8_t i=0;i<PELIKAN_NUM_RF_CHAN;i++)
|
|
hopping_frequency[i]=pgm_read_byte_near(&pelikan_lite_hopp[0][i]);
|
|
#endif
|
|
#if defined(PELIKAN_LITE_FORCE_ID)
|
|
// ID
|
|
rx_tx_addr[2]=0x60;
|
|
rx_tx_addr[3]=0x18;
|
|
#endif
|
|
MProtocol_id = ((uint32_t)rx_tx_addr[0]<<24)|((uint32_t)rx_tx_addr[1]<<16)|((uint32_t)rx_tx_addr[2]<<8)|(rx_tx_addr[3]);
|
|
if(IS_BIND_DONE)
|
|
A7105_WriteID(MProtocol_id);
|
|
packet_period = PELIKAN_LITE_PACKET_PERIOD;
|
|
}
|
|
#ifndef MULTI_AIR
|
|
else// if(sub_protocol==PELIKAN_SCX24)
|
|
{
|
|
pelikan_init_hop_scx();
|
|
#if defined(PELIKAN_SCX24_FORCE_HOP)
|
|
// Hop frequency table
|
|
uint8_t num=rx_tx_addr[3] & 0x03;
|
|
switch(num)
|
|
{
|
|
case 1:
|
|
rx_tx_addr[0]=0x10; // hopping freq TX2
|
|
rx_tx_addr[1]=0x63; // hopping freq TX2
|
|
break;
|
|
case 2:
|
|
rx_tx_addr[0]=0x81; // hopping freq TX3
|
|
rx_tx_addr[1]=0x63; // hopping freq TX3
|
|
break;
|
|
case 3:
|
|
rx_tx_addr[0]=0x36; // hopping freq TX4
|
|
rx_tx_addr[1]=0x5C; // hopping freq TX4
|
|
break;
|
|
default:
|
|
rx_tx_addr[0]=0x12; // hopping freq TX1
|
|
rx_tx_addr[1]=0x46; // hopping freq TX1
|
|
break;
|
|
}
|
|
for(uint8_t i=0;i<PELIKAN_NUM_RF_CHAN;i++)
|
|
hopping_frequency[i]=pgm_read_byte_near(&pelikan_scx24_hopp[num][i]);
|
|
#endif
|
|
#if defined(PELIKAN_SCX24_FORCE_ID)
|
|
// ID
|
|
rx_tx_addr[2]=0x80; // TX1
|
|
rx_tx_addr[3]=0x19; // TX1
|
|
rx_tx_addr[2]=0x80; // TX2
|
|
rx_tx_addr[3]=0x22; // TX2
|
|
rx_tx_addr[2]=0x30; // TX3
|
|
rx_tx_addr[3]=0x18; // TX3
|
|
rx_tx_addr[2]=0x30; // TX4
|
|
rx_tx_addr[3]=0x17; // TX4
|
|
#endif
|
|
A7105_WriteReg(A7105_0E_DATA_RATE,0x03);
|
|
if(IS_BIND_DONE)
|
|
A7105_WriteReg(A7105_03_FIFOI,0x0D);
|
|
packet_period = PELIKAN_SCX24_PACKET_PERIOD;
|
|
}
|
|
#endif //MULTI_AIR
|
|
}
|
|
|
|
hopping_frequency_no = PELIKAN_NUM_RF_CHAN;
|
|
packet_count = 5;
|
|
phase = 0;
|
|
bind_counter = PELIKAN_BIND_COUNT;
|
|
}
|
|
#endif
|