void to_rx_mode(void)
{
write(0x07, 0x01); // to ready mode
sbi(PORTD, RXANT);
cbi(PORTD, TXANT);
delay_ms(50);
rx_reset();
}
void to_rx_mode(void)
{
writeRfm(0x07, 0x01); // to ready mode
gpioWrite(RXANT, 1);
gpioWrite(TXANT, 0);
//sbi(PORTD, RXANT);
//cbi(PORTD, TXANT);
rx_reset();
}
int main(void)
{
unsigned char i, chksum;
ioinit();
init_SPI();
sbi(CSPORT,CS);
printf("********RFM22 Communication Test********\n");
//====================//
//Communications Test
printf("Reading DTYPE register, should be 0x08: %d", read(DTYPE));
printf("\n*****************************************\n\n");
init_RFM22(); // Initialize all RFM22 registers
printf("Entering RX Mode...\n");
to_rx_mode();
while(1)
{
if((PIND & (1<<NIRQ)) == 0) //Interrupt will be generated if data is recieved
{
// Read 18-byte packet into RF_RXBUF[]:
for(i=0; i<17; i++)
{
RF_RXBUF[i] = read(0x7F);
}
// Check that the checksum matches up:
chksum = 0;
for(i=0; i<16; i++)
chksum += RF_RXBUF[i];
// If checksum is good, print out what was received into the terminal
if(chksum == RF_RXBUF[16])
{
write(0x07, 0x01); // To ready mode
printf("Received: ");
for(i=0; i<17; i++)
printf("%c", RF_RXBUF[i]); // Print characters if passed the checksum
printf("\n");
//printf("To Ready mode\n");
}
// otherwise reset and start listening again
else
{
rx_reset();
//printf("Bad checksum RX RESET...Listening again\n");
}
delay_ms(50);
}
}
}
void to_rx_mode(void)
{
write_RFM(0x07, 0x01); // to ready mode
sbi(PORTD, RXANT);
//printf("a");
cbi(PORTD, TXANT);
printf("b");
delay_ms(50);
printf("bb");
rx_reset();
}
void detect_errors(){
if ( (error & END_OF_PLAYLIST) && !(error_last & END_OF_PLAYLIST) ) {
info_end_of_playlist();
}
else if ( (error & PLAYLIST_EMPTY) && !(error_last & PLAYLIST_EMPTY) ) {
info_playlist_empty();
} else if ( (error & MPD_DEAD) && !(error_last & MPD_DEAD) ) {
/*We try to solve the communication error by resetting our
radio reception to a sane state.
*/
rx_reset();
info_mpd_dead();
} else if ( (error_last & MPD_DEAD) && !(error & MPD_DEAD) ) {
// MPD recovered from an error
show_new_screen(PLAYING_SCREEN);
};
error_last=error;
};
t_stat rx_wr (int32 data, int32 PA, int32 access)
{
int32 drv;
switch ((PA >> 1) & 1) { /* decode PA<1> */
/* Writing RXCS, three cases:
1. Writing INIT, reset device
2. Idle and writing new function
- clear error, done, transfer ready, int req
- save int enable, function, drive
- start new function
3. Otherwise, write IE and update interrupts
*/
case 0: /* RXCS */
rx_csr = rx_csr & RXCS_IMP; /* clear junk */
if (access == WRITEB) data = (PA & 1)? /* write byte? */
(rx_csr & 0377) | (data << 8): (rx_csr & ~0377) | data;
if (data & RXCS_INIT) { /* initialize? */
rx_reset (&rx_dev); /* reset device */
return SCPE_OK; } /* end if init */
if ((data & CSR_GO) && (rx_state == IDLE)) { /* new function? */
rx_csr = data & (CSR_IE + RXCS_DRV + RXCS_FUNC);
bptr = 0; /* clear buf pointer */
switch ((data >> RXCS_V_FUNC) & RXCS_M_FUNC) {
case RXCS_FILL:
rx_state = FILL; /* state = fill */
rx_csr = rx_csr | RXCS_TR; /* xfer is ready */
break;
case RXCS_EMPTY:
rx_state = EMPTY; /* state = empty */
sim_activate (&rx_unit[0], rx_xwait);
break;
case RXCS_READ: case RXCS_WRITE: case RXCS_WRDEL:
rx_state = RWDS; /* state = get sector */
rx_csr = rx_csr | RXCS_TR; /* xfer is ready */
rx_esr = rx_esr & RXES_ID; /* clear errors */
break;
default:
rx_state = CMD_COMPLETE; /* state = cmd compl */
drv = (data & RXCS_DRV) > 0; /* get drive number */
sim_activate (&rx_unit[drv], rx_cwait);
break; } /* end switch func */
return SCPE_OK; } /* end if GO */
if ((data & CSR_IE) == 0) int_req = int_req & ~INT_RX;
else if ((rx_csr & (RXCS_DONE + CSR_IE)) == RXCS_DONE)
int_req = int_req | INT_RX;
rx_csr = (rx_csr & ~RXCS_RW) | (data & RXCS_RW);
return SCPE_OK; /* end case RXCS */
/* Accessing RXDB, two cases:
1. Write idle, write
2. Write not idle and TR set, state dependent
*/
case 1: /* RXDB */
if ((PA & 1) || ((rx_state != IDLE) && ((rx_csr & RXCS_TR) == 0)))
return SCPE_OK; /* if ~IDLE, need tr */
rx_dbr = data & 0377; /* save data */
if ((rx_state == FILL) || (rx_state == RWDS)) { /* fill or sector? */
sim_activate (&rx_unit[0], rx_xwait); /* sched event */
rx_csr = rx_csr & ~RXCS_TR; } /* clear xfer */
if (rx_state == RWDT) { /* track? */
drv = (rx_csr & RXCS_DRV) > 0; /* get drive number */
sim_activate (&rx_unit[drv], /* sched done */
rx_swait * abs (rx_track - rx_unit[drv].TRACK));
rx_csr = rx_csr & ~RXCS_TR; } /* clear xfer */
return SCPE_OK; /* end case RXDB */
} /* end switch PA */
void bindMode(void)
{
uint32_t prevsend = millis();
uint8_t tx_buf[sizeof(bind_data) + 1];
bool sendBinds = 1;
init_rfm(1);
while (serialAvailable()) {
serialRead(); // flush serial
}
Red_LED_OFF;
while (1) {
if (sendBinds & (millis() - prevsend > 200)) {
prevsend = millis();
Green_LED_ON;
buzzerOn(BZ_FREQ);
tx_buf[0] = 'b';
memcpy(tx_buf + 1, &bind_data, sizeof(bind_data));
tx_packet(tx_buf, sizeof(bind_data) + 1);
Green_LED_OFF;
buzzerOff();
RF_Mode = Receive;
rx_reset();
delay(50);
if (RF_Mode == Received) {
RF_Mode = Receive;
spiSendAddress(0x7f); // Send the package read command
if ('B' == spiReadData()) {
sendBinds = 0;
}
}
}
if (!digitalRead(BTN)) {
sendBinds = 1;
}
while (serialAvailable()) {
Red_LED_ON;
Green_LED_ON;
switch (serialRead()) {
case '\n':
case '\r':
printStrLn("Enter menu...");
handleCLI();
init_rfm(1);
break;
case '#':
scannerMode();
break;
default:
break;
}
Red_LED_OFF;
Green_LED_OFF;
}
}
}
void setup(void)
{
watchdogConfig(WATCHDOG_OFF);
setupSPI();
#ifdef SDN_pin
pinMode(SDN_pin, OUTPUT); //SDN
digitalWrite(SDN_pin, 0);
#endif
//LED and other interfaces
pinMode(Red_LED, OUTPUT); //RED LED
pinMode(Green_LED, OUTPUT); //GREEN LED
#ifdef Red_LED2
pinMode(Red_LED2, OUTPUT); //RED LED
pinMode(Green_LED2, OUTPUT); //GREEN LED
#endif
// pinMode(BTN, INPUT); //Button
pinMode(SLAVE_SELECT, INPUT);
digitalWrite(SLAVE_SELECT, HIGH); // enable pullup for TX:s with open collector output
buzzerInit();
serialInit(115200,SERIAL_8N1);
checkOperatingMode();
printStr("OpenLRSng DL starting ");
printVersion(version);
printStr(" on HW ");
printUL(BOARD_TYPE);
printStr(" (");
printUL(RFMTYPE);
printStr("MHz) MDOE=");
buzzerOn(BZ_FREQ);
digitalWrite(BTN, HIGH);
Red_LED_ON ;
sei();
delay(50);
if (!slaveMode) {
printStrLn("MASTER");
if (!bindReadEeprom()) {
printStrLn("eeprom bogus reinit....");
bindInitDefaults();
bindWriteEeprom();
}
if (!digitalRead(BTN)) {
bindMode();
}
} else {
printStrLn("SLAVE");
if (!digitalRead(BTN) || !bindReadEeprom()) {
bindRX(false);
} else {
bindRX(true);
}
}
packetInterval = getInterval(&bind_data);
printStrLn("Entering normal mode");
serialFlush();
serialInit(bind_data.serial_baudrate, bind_data.serial_mode);
Red_LED_OFF;
buzzerOff();
init_rfm(0);
rfmSetChannel(RF_channel);
rx_reset();
if (slaveMode) {
to_rx_mode();
RF_Mode = Receive;
}
watchdogConfig(WATCHDOG_2S);
lastReceived=micros();
}
int main()
{
uint8_t i;
Init();
if (service_mode_rx) ServiceMode(); //enter service mode
//Hop to first frequency from Carrier
#ifdef FREQUENCY_HOPPING
Hopping();
#endif
RF_Mode = Receive;
Red_LED_OFF;
time = millis();
last_pack_time = time; // reset the last pack receiving time for first usage
last_hopping_time = time; // reset hopping timer
// quality_check_time = time;
//-------------- MAIN LOOP -------------------------------------------------------------------------------------------
while(1)
{
time = millis();
if (_spi_read(0x0C)==0) // detect the locked module and reboot
{
RF22B_init_parameter();
to_rx_mode();
}
SignalLostProcedure();
if(RF_Mode == Received) // RFM22B INT pin Enabled by received Data
{
last_pack_time = time; // record last package time
Red_LED_OFF;
Green_LED_ON;
send_read_address(0x7f); // Send the package read command
//read all buffer
for(i = 0; i<DATA_PACKAGE_SIZE; i++) RF_Rx_Buffer[i] = read_8bit_data();
rx_reset();
if (RF_Rx_Buffer[0] == 'S') // servo control data
{
for(i = 0; i<8; i++) //Write into the Servo Buffer
{
temp_int = (256*RF_Rx_Buffer[1+(2*i)]) + RF_Rx_Buffer[2+(2*i)];
if ((temp_int>1500) && (temp_int<4500)) Servo_Position[i] = temp_int;
}
}
// sum_rssi += _spi_read(0x26); // Read the RSSI value
//binding mode
if (bind) if (Bind()) break;
#ifdef FREQUENCY_HOPPING
ChannelHopping(1);
#endif
last_ok_channel = hopping_channel;
last_hopping_time = time;
RF_Mode = Receive;
}
else Green_LED_OFF;
}
//----------------------------------------------------------------------------------------------------------------------
if (bind) //binding finished, now you have to restart RX
{
Red_LED_ON;
Green_LED_ON;
while(1);
}
}
