int read_status(libusb_device_handle *usbdev, unsigned char* data) {
int read;
int ret = libusb_interrupt_transfer(usbdev, MOS_EP_INT, data, 4, &read, HZ*5);
DBG("libusb_interrupt_transfer(endpoint:0x%X, data:0x%X, length:4, actual_read:0x%X, timeout:HZ*5) ret:%u\n",MOS_EP_INT,(uint32_t)*data,read,ret);
DBG("read: %u : %s %s %s %s\n",read,byte_to_binary(data[3]),byte_to_binary(data[2]),byte_to_binary(data[1]),byte_to_binary(data[0]));
return read;
}
int main()
{
//Remettre a 0 ICANON
int icanon = ICANON;
printf("%s\n", byte_to_binary(icanon));
icanon &= ~(ICANON);
printf("%s\n", byte_to_binary(icanon));
/*==============================================*/
// Inscrire la valeur de ICANON
icanon = 0;
printf("%s\n", byte_to_binary(icanon));
icanon |= ICANON;
printf("%s\n", byte_to_binary(icanon));
icanon |= ECHO;
printf("%s\n", byte_to_binary(icanon));
}
// given a packet, looks at the length field (4-5th bytes) and returns
// its corresponding decimal value as unsigned long
unsigned long retrieveLength(char* packet)
{
char firstBin[17]; char secondBin[9];
byte_to_binary(packet[4], firstBin);
byte_to_binary(packet[5], secondBin);
strcat(firstBin, secondBin);
return strtoul(firstBin, NULL, 2);
}
void pos_bit_to_1(int byte)
{
unsigned int bit = 0xA;
bit = bit & 0;
printf("%s\n", byte_to_binary(bit));
bit = 1u << (byte - 1);
printf("%s\n", byte_to_binary(bit));
}
void simple(void)
{
/**
* 10 = 2^3 + 2^1 so at pos 4 there is a one and at pos 2 too so 10 = 1010
* 11 = 2^3 + 2^1 + 2^0 so at pos 4 theres is a one, at pos 2 too and at pos 1 too so 10 = 1011
*
*/
printf("10 = %s\n", byte_to_binary(10));
printf("11 = %s\n", byte_to_binary(11));
}
void mos7715_change_mode(libusb_device_handle *device, int m)
{
unsigned char data;
data = 0x00;
DBG("change mode intended: %s\n",byte_to_binary(m));
SendMosCmd(device,MOS_READ,0,0x0A, &data);
DBG("change mode original mode: %s\n",byte_to_binary(data));
data = (data & 0b00011111) | (m<<5);
SendMosCmd(device,MOS_WRITE,0,0x0A, &data);
DBG("change mode new mode: %s\n",byte_to_binary(data));
}
// Adapted from send_8bit_serial_data()
void send_616bit_serial_data(struct uint640_t * data_full) {
unsigned char data; // data byte
// p_data points to the most significant byte in data_full
unsigned char * p_data = (unsigned char *) data_full;
p_data += (sizeof(struct uint640_t) - 1);
int i;
int delay;
// ?
output_low(SR_OUT);
// select device
output_high(SR_EN);
// send bits 640..(640-616)
for (i=0; i<616; i++) {
// Move to next byte after 8 bits
if ((i & 0x07) == 0) { // faster equivalence of (i % 8 == 0)
data = *p_data;
--p_data;
printf("Write byte: 0x%02x (0b%s).\n", data, byte_to_binary(data));
}
// consider leftmost bit
// set line high if bit is 1, low if bit is 0
if (data & 0x80)
output_high(SR_IN);
else
output_low(SR_IN);
// pulse clock to indicate that bit value should be read
output_low(SR_CK);
printf("-- write to register: 0x%02x (0b%s)\n", dest_register[0], byte_to_binary(dest_register[0]));
write_to_register();
for (delay = 0; delay < LED_DELAY; delay++);
// pulse clock to indicate that bit value should be read
output_high(SR_CK);
printf("-- write to register: 0x%02x (0b%s)\n", dest_register[0], byte_to_binary(dest_register[0]));
write_to_register();
for (delay = 0; delay < LED_DELAY; delay++);
// shift byte left so next bit will be leftmost
data <<= 1;
}
// deselect device
output_low(SR_EN);
}
void pos_first_bit_to_1()
{
/*
* Je mets a 0 la variable et je place a 1 le premier bit de la variable
*/
unsigned int bit = 0xA;
bit = bit & 0;
printf("%s\n", byte_to_binary(bit));
bit = 1u << 0;
printf("%s\n", byte_to_binary(bit));
}
void test(int byte)
{
unsigned int bit = 0xA;
unsigned int temp = 0x0;
printf("%s\n", byte_to_binary(bit));
temp = 1u << byte;
printf("%s\n", byte_to_binary(bit));
if (temp & bit)
printf("Le byte [%i] vaut 0", byte);
else
printf("Le byte [%i] vaut 1", byte);
}
void pos_first_bit_to_0()
{
/*
* Je remplie de 1 la variable et je fait un decalage de 1
*/
unsigned int bit = 0xA;
bit = ~(bit & 1);
printf("%s\n", byte_to_binary(bit));
bit = bit << 1;
printf("%s\n", byte_to_binary(bit));
}
void pos_bit_to_0(int byte)
{
/* Je mets la variable a 0, je mets le 1 a la place du 0 puis j'inverse tout
*/
unsigned int bit = 0xA;
bit = bit & 0;
printf("%s\n", byte_to_binary(bit));
bit = 1u << (byte - 1);
printf("%s\n", byte_to_binary(bit));
bit = ~bit;
printf("%s\n", byte_to_binary(bit));
}
unsigned char mos7715_read_dpr(libusb_device_handle* device) {
unsigned char data = 0x00;
SendMosCmd(device,MOS_READ,0,0x00, &data);
reg[1] = data;
DBG( "read dpr: %s\n", byte_to_binary(data) );
return data;
}
void ip_to_binary(const char *ip, const int cidr, char *dest) {
size_t i_ = 0;
size_t j_ = 0;
char *ip_ = NULL;
int ip_block_ = 0;
char *ip_block_str_ = NULL;
char bin_ip_block_[4][9];
const size_t ip_size_ = strlen(ip);
ip_ = (char*) kmalloc(ip_size_ + NULL_BYTE_SIZE, GFP_ATOMIC);
strcpy(ip_, ip);
tok_str(&ip_, '.');
for (i_ = 0, j_ = 0; j_ < 4; ++i_, ++j_) {
ip_block_str_ = ip_ + i_;
sscanf(ip_block_str_, "%d", &ip_block_);
byte_to_binary(ip_block_, bin_ip_block_[j_]);
i_ += strlen(ip_block_str_);
}
kfree(ip_);
snprintf(
dest,
cidr + NULL_BYTE_SIZE,
"%s%s%s%s",
bin_ip_block_[0],
bin_ip_block_[1],
bin_ip_block_[2],
bin_ip_block_[3]);
}
int calculationDecoderLine()
{
char DEC_PORT = 0b10000001;
char lineBits = 0;
char lineNo = 0;
for(lineNo = 0;lineNo < 8;lineNo++)
{
DEC_PORT &= ~(0b111 << 3); // clear bit positions
lineBits = ((lineNo) << 3); // shift number on first pin position
DEC_PORT |= lineBits; // set new bits
printf("lineNo: %d --> %s\n", lineNo, byte_to_binary(DEC_PORT));
/*
A0(4), A1(5), A2(6)
## #
0 --> 0b0000 0000 : 0x00
1 --> 0b0000 1000 : 0x08
2 --> 0b0001 0000 : 0x10
3 --> 0b0001 1000 : 0x18
4 --> 0b0010 0000 : 0x20
5 --> 0b0010 1000 : 0x28
6 --> 0b0011 0000 : 0x30
7 --> 0b0011 1000 : 0x38
*/
}
return 0;
}
void BPRED::UpdatePredictor(uint32_t PC, bool resolveDir, bool predDir) {
uint16_t XOR_result;
XOR_result = (g_BHR ^ (uint16_t)(PC & 0x0FFF)) & 0x0FFF;
if(resolveDir)
g_PHT[XOR_result] = SatIncrement(g_PHT[XOR_result], 3);
else
g_PHT[XOR_result] = SatDecrement(g_PHT[XOR_result]);
g_BHR = g_BHR << 1 | resolveDir;
#if 0
printf("PC= %s,", byte_to_binary(PC));
printf("BHR= %s\n", byte_to_binary(g_BHR));
printf("XOR_result: %s, g_PHT[XOR_result]: %d\n", byte_to_binary(XOR_result), g_PHT[XOR_result]);
#endif
}
void mos7715_write_dsr(libusb_device_handle* device, unsigned char data) {
SendMosCmd(device,MOS_WRITE,0,0x01, &data);
DBG( "wrote dsr: %s\n", byte_to_binary(data) );
DBG( "\tbusy: %s\n", (data & 0b10000000) ? "ready for data, pin low" : "not ready for data, pin high" );
DBG( "\tack: %s\n", (data & 0b01000000) ? "ack high" : "ack low" );
DBG( "\tpe: %s\n", (data & 0b00100000) ? "normal, pin low" : "initializing, pin high" );
DBG( "\tslct: %s\n", (data & 0b00010000) ? "printer online" : "printer offline" );
DBG( "\tfault: %s\n", (data & 0b00001000) ? "normal op" : "printer reports error" );
}
void mos7715_write_dcr(libusb_device_handle* device, unsigned char data) {
SendMosCmd(device,MOS_WRITE,0,0x02, &data);
DBG( "wrote dcr: %s\n", byte_to_binary(data) );
DBG( "\tdirection: %s\n", (data & 0b00100000) ? "input mode" : "output mode" );
DBG( "\tselect in: %s\n", (data & 0b00001000) ? "selected, pin low" : "not selected, pin high" );
DBG( "\tinit: %s\n", (data & 0b00000100) ? "normal, pin low" : "initializing, pin high" );
DBG( "\tautofeed: %s\n", (data & 0b00000010) ? "autofeed on, pin low" : "none, pin high" );
DBG( "\tstrobe: %s\n", (data & 0b00000001) ? "dpr latched, pin low" : "dpr unlatched, pin high" );
}
/*
typedef struct
{
uint8_t frameType; // 0x21 nonstandard
uint8_t keys; // Bit 0: left key (user button), Bit 1: right key (power button), Bit 2: reed relay
uint8_t lux[2]; // raw optical sensor data, BE
uint8_t gyroX[2]; // gyroscope X axis reading
uint8_t gyroY[2]; // gyroscope Y axis reading
uint8_t gyroZ[2]; // gyroscope Z axis reading
uint8_t accelX[2]; // acceleration X axis reading
uint8_t accelY[2]; // acceleration Y axis reading
uint8_t accelZ[2]; // acceleration Z axis reading
...
} eddystoneMisc_t;
*/
static void printMisc(ad_structure misc) {
uint8_t *data = misc.data;
int index = 3;
// Key state
printf("keys: %s\n", byte_to_binary(data[index]));
index ++;
// Light sensor
uint16_t lux = (data[index]<<8) + data[index+1];
printf("lux: %.2f\n", sensorOpt3001Convert(lux));
}
// Transmit byte serially, MSB first
// from: https://en.wikipedia.org/wiki/Bit_banging
void send_8bit_serial_data(unsigned char data) {
int i;
int delay;
// ?
output_low(SR_OUT);
// select device
output_high(SR_EN);
// send bits 7..0
for (i=0; i<8; i++) {
// consider leftmost bit
// set line high if bit is 1, low if bit is 0
if (data & 0x80)
output_high(SR_IN);
else
output_low(SR_IN);
// pulse clock to indicate that bit value should be read
output_low(SR_CK);
printf("-- write to register: 0x%02x (0b%s)\n", dest_register[0], byte_to_binary(dest_register[0]));
write_to_register();
for (delay = 0; delay < LED_DELAY; delay++);
// pulse clock to indicate that bit value should be read
output_high(SR_CK);
printf("-- write to register: 0x%02x (0b%s)\n", dest_register[0], byte_to_binary(dest_register[0]));
write_to_register();
for (delay = 0; delay < LED_DELAY; delay++);
// shift byte left so next bit will be leftmost
data <<= 1;
}
// deselect device
output_low(SR_EN);
}
unsigned char mos7715_read_dcr(libusb_device_handle* device) {
unsigned char data = 0x00;
SendMosCmd(device,MOS_READ,0,0x02, &data);
reg[1] = data;
DBG( "read dcr: %s\n", byte_to_binary(data) );
DBG( "\tdirection: %s\n", (data & 0b00100000) ? "input mode" : "output mode" );
DBG( "\tselect in: %s\n", (data & 0b00001000) ? "selected, pin low" : "not selected, pin high" );
DBG( "\tinit: %s\n", (data & 0b00000100) ? "normal, pin low" : "initializing, pin high" );
DBG( "\tautofeed: %s\n", (data & 0b00000010) ? "autofeed on, pin low" : "none, pin high" );
DBG( "\tstrobe: %s\n", (data & 0b00000001) ? "dpr latched, pin low" : "dpr unlatched, pin high" );
return data;
}
unsigned char mos7715_read_dsr(libusb_device_handle* device) {
unsigned char data = 0x00;
SendMosCmd(device,MOS_READ,0,0x01, &data);
reg[1] = data;
DBG( "read dsr: %s\n", byte_to_binary(data) );
DBG( "\tbusy: %s\n", (data & 0b10000000) ? "ready for data, pin low" : "not ready for data, pin high" );
DBG( "\tack: %s\n", (data & 0b01000000) ? "ack high" : "ack low" );
DBG( "\tpe: %s\n", (data & 0b00100000) ? "normal, pin low" : "initializing, pin high" );
DBG( "\tslct: %s\n", (data & 0b00010000) ? "printer online" : "printer offline" );
DBG( "\tfault: %s\n", (data & 0b00001000) ? "normal op" : "printer reports error" );
return data;
}
int main(int argc, char *argv[])
{
int n = atoi(argv[1]);
int c = atoi(argv[2]);
long long l = 1ULL<< n;
int i;
long long cnt = 0;
for (i = 0; i < l; i++) {
//printf("%s", byte_to_binary(i));
if (find_ones(byte_to_binary(i)) == c) {
// printf("%s:%d\n", byte_to_binary(i), i);
cnt++;
}
// printf("\n");
}
printf("%d:%d: %lld\n", n, c, cnt);
}
int main()
{
char PORTD;
Motor right;
Motor_Init(&right, RIGHT_MOTOR, &PORTD);
Motor_AddPosition(&right, 0, 0b00001000);
Motor_AddPosition(&right, 1, 0b00000100);
Motor_AddPosition(&right, 2, 0b00000010);
Motor_AddPosition(&right, 3, 0b00000001);
PORTD = 0b10101010;
while(1)
{
printf("PORTD=%s ", byte_to_binary(PORTD));
system("PAUSE");
Motor_Move(&right, FORWARD_MOTOR);
}
printf("Hello world!\n");
return 0;
}
void lightCallback( const clothoid_msgs::LightStatusConstPtr &light_msg)
{
ROS_INFO("light received : %s",byte_to_binary(light_msg.get()->lightOn));
pub_msg.TrafficLight =0;
if(light_msg.get()->lightOn == clothoid_msgs::LightStatus::RED ){
pub_msg.TrafficLight |= clothoid_msgs::LightStatus::RED;
pub_vel.vehicle_speed=clothoid_msgs::katech_KCAN::VEHICLE_SPEED_0KPH;
}
if(light_msg.get()->lightOn == clothoid_msgs::LightStatus::LEFT ){
pub_msg.TrafficLight |= clothoid_msgs::LightStatus::LEFT;}
if(light_msg.get()->lightOn == clothoid_msgs::LightStatus::RIGHT ){
pub_msg.TrafficLight |= clothoid_msgs::LightStatus::RIGHT;}
if(light_msg.get()->lightOn == clothoid_msgs::LightStatus::GREEN ){
pub_msg.TrafficLight |= clothoid_msgs::LightStatus::GREEN;}
speed_pub.publish(pub_vel);
rcg_pub.publish(pub_msg);
pub_msg.TrafficLight =0;
}
int main(void)
{
{
/* binary string to int */
char *tmp;
char *b = "0101";
printf("%ld\n", strtol(b, &tmp, 2));
}
{
/* byte to binary string */
printf("%s\n", byte_to_binary(538));
}
return 0;
}
void sp5K_readFunction(void)
{
u08 devId, address, regValue, pin, channel, pcbChannel, adcChannel;
u08 length = 10;
s08 retS;
u08 mcp_address;
RtcTimeType rtcDateTime;
u08 i;
u16 adcRetValue;
char eeRdBuffer[EERDBUFLENGHT];
u16 eeAddress;
u08 pos;
frameDataType rdFrame;
u16 recCount;
double I,M,D;
u08 bdGetStatus;
u16 rcdIndex;
u08 b[9];
memset( cmd_printfBuff, NULL, CHAR128);
makeargv();
// RTC
// Lee la hora del RTC.
if (!strcmp_P( strupr(argv[1]), PSTR("RTC\0"))) {
retS = rtcGetTime(&rtcDateTime);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d/%02d/%04d "),rtcDateTime.day,rtcDateTime.month, rtcDateTime.year );
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d:%02d:%02d\r\n\0"),rtcDateTime.hour,rtcDateTime.min, rtcDateTime.sec );
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DCD
if (!strcmp_P( strupr(argv[1]), PSTR("DCD\0"))) {
retS = MCP_queryDcd(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// RI
if (!strcmp_P( strupr(argv[1]), PSTR("RI\0"))) {
retS = MCP_queryRi(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN0
if (!strcmp_P( strupr(argv[1]), PSTR("DIN0\0"))) {
retS = MCP_queryDin0(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN0 %d\r\n\0"), pin);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN1
if (!strcmp_P( strupr(argv[1]), PSTR("DIN1\0"))) {
retS = MCP_queryDin1(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN1 %d\r\n\0"), pin);
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(cmd_printfBuff);
return;
}
// TERMSW
if (!strcmp_P( strupr(argv[1]), PSTR("TERMSW\0"))) {
retS = MCP_queryTermPwrSw(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW OFF\r\n\0")); }
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MCP
// read mcp 0|1|2 addr
if (!strcmp_P( strupr(argv[1]), PSTR("MCP\0"))) {
devId = atoi(argv[2]);
address = atoi(argv[3]);
if ( devId == 0 ) { mcp_address = MCP_ADDR0; }
if ( devId == 1 ) { mcp_address = MCP_ADDR1; }
if ( devId == 2 ) { mcp_address = MCP_ADDR2; }
retS = MCP_read( address, mcp_address, 1, ®Value);
if (retS ) {
// Convierto el resultado a binario.
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
strcpy(b,byte_to_binary(regValue));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("mcp %d: reg=[%d] data=[0X%03x] [%s] \r\n\0"),devId, address,regValue, b);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// *****************************************************************************************************
// SOLO PARA USO EN MODO SERVICE.
if ( systemVars.wrkMode != WK_SERVICE) {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("WARNING: Debe pasar a modo SERVICE !!!\r\n"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// ADC
// read adc channel
// El canal es de 0..3/0..7 y representa el canal fisico en el conector, NO
// EL PROPIO CANAL DEL A/D
if (!strcmp_P( strupr(argv[1]), PSTR("ADC\0"))) {
pcbChannel = atoi(argv[2]);
if ( NRO_CHANNELS == 3 ) {
switch (pcbChannel ) {
case 0:
adcChannel = 3;
break;
case 1:
adcChannel = 5;
break;
case 2:
adcChannel = 7;
break;
case 3:
adcChannel = 1; // Bateria
break;
}
}
retS = ADS7828_convert( adcChannel, &adcRetValue );
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("adc_%d(%d)=[%d]\r\n\0"),pcbChannel, adcChannel, adcRetValue);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// FRAME
// Lee todos los canales y presenta el frame.
if (!strcmp_P( strupr(argv[1]), PSTR("FRAME\0"))) {
SIGNAL_tkDataReadFrame();
return;
}
// EEPROM
// read ee addr length
if (!strcmp_P( strupr(argv[1]), PSTR("EE\0"))) {
eeAddress = atol(argv[2]);
length = atoi(argv[3]);
// Buffer control.
if (length > EERDBUFLENGHT) {
length = EERDBUFLENGHT;
}
retS = EE_read( eeAddress, length, &eeRdBuffer);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("addr=[%d] data=[%s]\r\n\0"),eeAddress,eeRdBuffer);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MEMORY DUMP
if (!strcmp_P( strupr(argv[1]), PSTR("MEMORY\0"))) {
recCount = 0;
for (;;) {
vTaskDelay( (portTickType)(50 / portTICK_RATE_MS) );
rcdIndex = BD_getRDptr();
bdGetStatus = BD_get( &rdFrame, rcdIndex);
// BD vacia
if (bdGetStatus == 0) {
break;
}
recCount++;
// Armo el frame
memset( cmd_printfBuff, NULL, CHAR128);
pos = 0;
pos = snprintf_P( &cmd_printfBuff, CHAR128, PSTR("(%d/%d)>" ), recCount, rcdIndex);
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%04d%02d%02d,"),rdFrame.rtc.year,rdFrame.rtc.month, rdFrame.rtc.day );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%02d%02d%02d,"),rdFrame.rtc.hour,rdFrame.rtc.min, rdFrame.rtc.sec );
// Valores analogicos
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f"),systemVars.aChName[channel],rdFrame.analogIn[channel] );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(","));
}
// Valores digitales.
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f,"), systemVars.dChName[0], rdFrame.din0_pCount );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%s=%.2f"), systemVars.dChName[1], rdFrame.din0_pCount );
#ifdef CHANNELS_3
// Bateria
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(",bt=%.2f"), rdFrame.batt );
#endif
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR("<\r\n\0") );
// Imprimo
sp5K_printStr(&cmd_printfBuff);
BD_delete(-1);
taskYIELD();
}
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n\0"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// CMD NOT FOUND
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "ERROR\r\n");
rprintfProgStrM(CMD_UART, "CMD NOT DEFINED\r\n");
xSemaphoreGive( sem_CmdUart );
}
return;
}
static void ezradio_int_callback()
{
//DPRINT("ezradio ISR");
ezradio_cmd_reply_t ezradioReply;
ezradio_cmd_reply_t radioReplyLocal;
ezradio_get_int_status(0x0, 0x0, 0x0, &ezradioReply);
//ezradio_frr_a_read(3, &ezradioReply);
//DPRINT(" - INT_PEND %s", byte_to_binary(ezradioReply.FRR_A_READ.FRR_A_VALUE));
DPRINT(" - INT_PEND %s", byte_to_binary(ezradioReply.GET_INT_STATUS.INT_PEND));
// DPRINT(" - INT_STATUS %s", byte_to_binary(ezradioReply.GET_INT_STATUS.INT_STATUS));
// DPRINT(" - PH_PEND %s", byte_to_binary(ezradioReply.GET_INT_STATUS.PH_PEND));
//DPRINT(" - PH_STATUS %s", byte_to_binary(ezradioReply.GET_INT_STATUS.PH_STATUS));
//DPRINT(" - PH_STATUS %s", byte_to_binary(ezradioReply.FRR_A_READ.FRR_B_VALUE));
// DPRINT(" - MODEM_PEND %s", byte_to_binary(ezradioReply.GET_INT_STATUS.MODEM_PEND));
// DPRINT(" - MODEM_STATUS %s", byte_to_binary(ezradioReply.GET_INT_STATUS.MODEM_STATUS));
// DPRINT(" - CHIP_PEND %s", byte_to_binary(ezradioReply.GET_INT_STATUS.CHIP_PEND));
// DPRINT(" - CHIP_STATUS %s", byte_to_binary(ezradioReply.GET_INT_STATUS.CHIP_STATUS));
//if (ezradioReply.FRR_A_READ.FRR_A_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_INT_PEND_PH_INT_PEND_BIT)
if (ezradioReply.GET_INT_STATUS.INT_PEND & EZRADIO_CMD_GET_INT_STATUS_REP_INT_PEND_PH_INT_PEND_BIT)
{
//DPRINT("PH ISR");
switch(current_state)
{
case HW_RADIO_STATE_RX:
if ((ezradioReply.GET_INT_STATUS.PH_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_PACKET_RX_BIT) ||
(ezradioReply.GET_INT_STATUS.PH_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_RX_FIFO_ALMOST_FULL_BIT))
{
//DPRINT("PACKET_RX IRQ");
if(rx_packet_callback != NULL)
{
/* Check how many bytes we received. */
ezradio_fifo_info(0, &radioReplyLocal);
DPRINT("RX ISR packetLength: %d", radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT);
if (rx_fifo_data_lenght == 0)
{
DPRINT("RX FIFO: %d", radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT);
uint8_t buffer[4];
ezradio_read_rx_fifo(4, buffer);
if (current_rx_cfg.channel_id.channel_header.ch_coding == PHY_CODING_FEC_PN9)
{
uint8_t fec_buffer[4];
memcpy(fec_buffer, buffer, 4);
fec_decode_packet(fec_buffer, 4, 4);
expected_data_length = fec_calculated_decoded_length(fec_buffer[0]+1);
DPRINT("RX Packet Length: %d / %d", fec_buffer[0], expected_data_length);
} else {
expected_data_length = buffer[0] + 1;
}
rx_packet = alloc_packet_callback(expected_data_length);
memcpy(rx_packet->data, buffer, 4);
rx_fifo_data_lenght += 4;
radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT-=4;
}
if (ezradioReply.GET_INT_STATUS.PH_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_PACKET_RX_BIT)
{
/* Read out the RX FIFO content. */
ezradio_read_rx_fifo(radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT, &(rx_packet->data[rx_fifo_data_lenght]));
//ezradio_read_rx_fifo(radioReplyLocal2.PACKET_INFO.LENGTH, packet->data);
ezradio_handle_end_of_packet();
return;
}
if (ezradioReply.GET_INT_STATUS.PH_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_RX_FIFO_ALMOST_FULL_BIT)
{
while (radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT > 0)
{
DPRINT("RX FIFO: %d", radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT);
/* Read out the FIFO Count bytes of RX FIFO */
ezradio_read_rx_fifo(radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT, &(rx_packet->data[rx_fifo_data_lenght]));
rx_fifo_data_lenght += radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT;
//DPRINT("%d of %d bytes collected", rx_fifo_data_lenght, rx_packet->data[0]+1);
ezradio_fifo_info(0, &radioReplyLocal);
if (rx_fifo_data_lenght >= expected_data_length)
{
ezradio_handle_end_of_packet();
return;
}
}
ezradio_int_callback();
return;
}
}
} else if (ezradioReply.GET_INT_STATUS.PH_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_CRC_ERROR_BIT)
//} else if ( ezradioReply.FRR_A_READ.FRR_B_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_PH_STATUS_CRC_ERROR_BIT)
{
DPRINT("- PACKET_RX CRC_ERROR IRQ");
/* Check how many bytes we received. */
ezradio_fifo_info(0, &radioReplyLocal);
DPRINT("RX ISR packetLength: %d", radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT);
//ezradio_cmd_reply_t radioReplyLocal2;
//ezradio_get_packet_info(0, 0, 0, &radioReplyLocal2);
if (rx_fifo_data_lenght == 0)
{
rx_packet = alloc_packet_callback(radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT);
}
/* Read out the RX FIFO content. */
ezradio_read_rx_fifo(radioReplyLocal.FIFO_INFO.RX_FIFO_COUNT, &(rx_packet->data[rx_fifo_data_lenght]));
rx_packet->rx_meta.crc_status = HW_CRC_INVALID;
rx_packet->length = rx_packet->data[0] + 1;
DPRINT_DATA(rx_packet->data, rx_packet->length);
DEBUG_RX_END();
if(rx_packet_callback != NULL)
rx_packet_callback(rx_packet);
else
release_packet_callback(rx_packet);
if(current_state == HW_RADIO_STATE_RX)
{
start_rx(¤t_rx_cfg);
}
} else {
DPRINT((" - OTHER RX IRQ"));
}
break;
case HW_RADIO_STATE_TX:
if (ezradioReply.GET_INT_STATUS.PH_PEND & EZRADIO_CMD_GET_INT_STATUS_REP_PH_PEND_PACKET_SENT_PEND_BIT)
//if (ezradioReply.FRR_A_READ.FRR_C_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_PH_PEND_PACKET_SENT_PEND_BIT)
{
DPRINT("PACKET_SENT IRQ");
DEBUG_TX_END();
if(tx_packet_callback != 0)
{
current_packet->tx_meta.timestamp = timer_get_counter_value();
DPRINT_DATA(current_packet->data, current_packet->length);
tx_packet_callback(current_packet);
}
/* We can't switch back to Rx since the Rx callbacks are modified
* during CCA, so we systematically go to idle
*/
switch_to_idle_mode();
// } else if (ezradioReply.FRR_A_READ.FRR_C_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_PH_PEND_TX_FIFO_ALMOST_EMPTY_PEND_BIT)
// {
// DPRINT(" - TX FIFO Almost empty IRQ ");
//
// ezradio_fifo_info(0, &radioReplyLocal);
// DPRINT("TX FIFO Space: %d", radioReplyLocal.FIFO_INFO.TX_FIFO_SPACE);
//
// //Fill fifo
// #ifdef HAL_RADIO_USE_HW_CRC
// int16_t new_length = current_packet->length-1 - tx_fifo_data_length;
// #else
// int16_t new_length = current_packet->length+1 - tx_fifo_data_length;
// #endif
// if (new_length > radioReplyLocal.FIFO_INFO.TX_FIFO_SPACE) new_length = radioReplyLocal.FIFO_INFO.TX_FIFO_SPACE;
//
// while (new_length > 0)
// {
// ezradio_write_tx_fifo(new_length, &(current_packet->data[tx_fifo_data_length]));
// tx_fifo_data_length += new_length;
// DPRINT ("%d added -> %d", new_length, tx_fifo_data_length);
//
// #ifdef HAL_RADIO_USE_HW_CRC
// new_length = current_packet->length-1 - tx_fifo_data_length;
// #else
// new_length = current_packet->length+1 - tx_fifo_data_length;
// #endif
// if (new_length > radioReplyLocal.FIFO_INFO.TX_FIFO_SPACE) new_length = radioReplyLocal.FIFO_INFO.TX_FIFO_SPACE;
// }
//
// if (new_length == 0)
// {
// DPRINT("reprocess callback");
// ezradio_int_callback();
// return;
// }
//
// DPRINT ("%d added -> %d", new_length, tx_fifo_data_length);
} else {
DPRINT(" - OTHER IRQ");
}
break;
default:
//assert(false);
DPRINT("State: %d", current_state);
}
}
// if (ezradioReply.FRR_A_READ.FRR_A_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_INT_PEND_MODEM_INT_PEND_BIT)
// {
// DPRINT("MODEM ISR");
// }
// if (ezradioReply.FRR_A_READ.FRR_A_VALUE & EZRADIO_CMD_GET_INT_STATUS_REP_INT_PEND_CHIP_INT_PEND_BIT)
// {
// DPRINT("CHIP ISR");
//
// if (current_state != HW_RADIO_STATE_IDLE)
// {
// if (ezradioReply.GET_INT_STATUS.CHIP_STATUS & EZRADIO_CMD_GET_INT_STATUS_REP_CHIP_STATUS_STATE_CHANGE_BIT)
// {
// ezradio_request_device_state(&radioReplyLocal);
// DPRINT(" - Current State %d", radioReplyLocal.REQUEST_DEVICE_STATE.CURR_STATE);
// DPRINT(" - Current channel %d", radioReplyLocal.REQUEST_DEVICE_STATE.CURRENT_CHANNEL);
// }else {
// DPRINT(" - OTHER IRQ");
// }
// }
// }
}
static void configure_channel(const channel_id_t* channel_id)
{
// only change settings if channel_id changed compared to current config
// TODO: check if only channel number changes
if((channel_id->channel_header_raw != current_channel_id.channel_header_raw))
{
DPRINT("configure_channel: %s", byte_to_binary(channel_id->channel_header_raw));
if (channel_id->channel_header.ch_coding != current_channel_id.channel_header.ch_coding)
{
if (has_hardware_crc && channel_id->channel_header.ch_coding != PHY_CODING_FEC_PN9)
{
// use HW CRC
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_LEN_ADJUST_HW_CRC);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_FIELD_1_CRC_CONFIG_HW_CRC);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_FIELD_2_CRC_CONFIG_HW_CRC);
} else {
// use SW CRC
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_LEN_ADJUST_SW_CRC);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_FIELD_1_CRC_CONFIG_SW_CRC);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PKT_FIELD_2_CRC_CONFIG_SW_CRC);
}
}
// TODO assert valid center freq index
memcpy(¤t_channel_id, channel_id, sizeof(channel_id_t)); // cache new settings
// TODO preamble size depends on channel class
// set freq band
DPRINT("Set frequency band index: %d", channel_id->channel_header.ch_freq_band);
switch(channel_id->channel_header.ch_class)
{
case PHY_CLASS_LO_RATE:
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPFF_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPINT_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT3_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT2_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT1_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DATA_RATE_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_TX_NCO_MODE_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PA_TC_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_WAIT_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_SPIKE_DET_LR);
break;
case PHY_CLASS_NORMAL_RATE:
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPFF_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPINT_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT3_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT2_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT1_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DATA_RATE_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_TX_NCO_MODE_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PA_TC_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_WAIT_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_SPIKE_DET_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DECIMATION_CFG1_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_OSR_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_GAIN_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_LIMITER_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_RFPD_DECAY_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_IFPD_DECAY_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_RAW_EYE_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DSA_QUAL_NR);
break;
case PHY_CLASS_HI_RATE:
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPFF_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_PFDCP_CPINT_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT3_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT2_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_SYNTH_LPFILT1_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_TX_NCO_MODE_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_PA_TC_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_WAIT_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_SPIKE_DET_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DECIMATION_CFG1_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_OSR_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_GAIN_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_LIMITER_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_RFPD_DECAY_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_IFPD_DECAY_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_RAW_EYE_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DSA_QUAL_HR);
//assert(false);
break;
default:
assert(false);
break;
}
// TODO validate
switch(channel_id->channel_header.ch_freq_band)
{
// TODO calculate depending on rate and channr
case PHY_BAND_433:
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CLKGEN_BAND_433);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_VCOCNT_RX_ADJ_433);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_IF_FREQ_433);
if(channel_id->channel_header.ch_class == PHY_CLASS_LO_RATE)
{
assert(channel_id->center_freq_index <= 68);
ez_channel_id = channel_id->center_freq_index;
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DECIMATION_CFG1_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_OSR_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_GAIN_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_LIMITER_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_RFPD_DECAY_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_IFPD_DECAY_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_RAW_EYE_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DSA_QUAL_433_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_433_LR);
}
else if(channel_id->channel_header.ch_class == PHY_CLASS_NORMAL_RATE)
{
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 270);
ez_channel_id = channel_id->center_freq_index / 8;
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_433_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_433_NR);
}
else if(channel_id->channel_header.ch_class == PHY_CLASS_HI_RATE)
{
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 56);
ez_channel_id = channel_id->center_freq_index / 8;
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DATA_RATE_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_433_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_433_HR);
}
DPRINT("Set channel freq index: %d", channel_id->center_freq_index);
break;
case PHY_BAND_868:
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CLKGEN_BAND_868);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_VCOCNT_RX_ADJ_868);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_IF_FREQ_868);
if(channel_id->channel_header.ch_class == PHY_CLASS_LO_RATE)
{
assert(channel_id->center_freq_index <= 279);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_868_LR);
ez_channel_id = channel_id->center_freq_index % 255;
if ((uint8_t) (channel_id->center_freq_index / 255) == 0)
{
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_LR_01);
} else
{
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_LR_02);
}
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DECIMATION_CFG1_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_OSR_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_GAIN_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_LIMITER_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_RFPD_DECAY_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AGC_IFPD_DECAY_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_RAW_EYE_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DSA_QUAL_868_LR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_868_LR);
}
else if(channel_id->channel_header.ch_class == PHY_CLASS_NORMAL_RATE)
{
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 270);
ez_channel_id = channel_id->center_freq_index / 8;
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_868_NR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_868_NR);
} else {
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 270);
ez_channel_id = channel_id->center_freq_index / 8;
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_DATA_RATE_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_FREQ_DEV_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_BCR_NCO_OFFSET_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_AFC_GAIN_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_0_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX1_CHFLT_COE_1_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_0_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_MODEM_CHFLT_RX2_CHFLT_COE_1_868_HR);
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_CHANNEL_STEP_SIZE_868_HR);
}
DPRINT("Set channel freq index: %d", channel_id->center_freq_index);
break;
case PHY_BAND_915:
assert(false);
break;
}
} else if (channel_id->center_freq_index != current_channel_id.center_freq_index)
{
DPRINT("configure center_freq_index: %d", channel_id->center_freq_index);
switch(channel_id->channel_header.ch_freq_band)
{
// TODO calculate depending on rate and channr
case PHY_BAND_433:
if(channel_id->channel_header.ch_class == PHY_CLASS_LO_RATE)
{
assert(channel_id->center_freq_index <= 68);
ez_channel_id = channel_id->center_freq_index;
}
else
{
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 56);
ez_channel_id = channel_id->center_freq_index / 8;
}
DPRINT("Set channel freq index: %d", channel_id->center_freq_index);
break;
case PHY_BAND_868:
if(channel_id->channel_header.ch_class == PHY_CLASS_LO_RATE)
{
assert(channel_id->center_freq_index <= 279);
ez_channel_id = channel_id->center_freq_index % 255;
if ((uint8_t) (channel_id->center_freq_index / 255) == 0)
{
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_LR_01);
} else
{
ezradio_set_property(RADIO_CONFIG_SET_PROPERTY_FREQ_CONTROL_FRAC_868_LR_02);
}
}
else {
assert(channel_id->center_freq_index % 8 == 0 && channel_id->center_freq_index <= 272);
ez_channel_id = channel_id->center_freq_index / 8;
}
DPRINT("Set channel freq index: %d", channel_id->center_freq_index);
break;
case PHY_BAND_915:
assert(false);
break;
}
current_channel_id.center_freq_index = channel_id->center_freq_index;
}
}
char *getStatus(CPU *c){
return byte_to_binary(c->regs[STATUS]);
}
// Main function
int main()
{
int i;
int debug;
int delay;
int uio0_fd;
const char *uio0_d = "/dev/uio0";
void *uio0_ptr;
printf("-- Example program begins --\n");
// Debug
debug = 0;
if (debug) {
printf("[debug] CHAR_BIT: %d\n", CHAR_BIT);
printf("[debug] BITNSLOTS(8): %d\n", BITNSLOTS(8));
for (i=0; i<CHAR_BIT; i++) {
dest_register[0] = 0x0;
printf("[debug] BITSET(register,%d): 0x%02x\n", i, BITSET(dest_register,i));
}
printf("[debug] sizeof uint640_t: %d\n", sizeof(struct uint640_t));
}
// Open the UIO devices
uio0_fd = open(uio0_d, O_RDWR);
if (uio0_fd < 1) {
printf("Invalid UIO device file:%s.\n", uio0_d);
exit(-1);
}
// mmap() the UIO devices
uio0_ptr = mmap(NULL, UIO0_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, uio0_fd, 0);
if (uio0_ptr == MAP_FAILED) {
printf("mmap call failure.\n");
exit(-1);
}
// Write
debug = 0;
if (debug) {
destination = (unsigned *) uio0_ptr;
dest_register[0] = 0xFF;
printf("\n");
printf("Writing 0x%02x (0b%s).\n", dest_register[0], byte_to_binary(dest_register[0]));
gpio_write(destination, 0, dest_register[0]);
for (delay = 0; delay < LED_DELAY; delay++);
printf("Write finish\n");
}
// Write
debug = 0;
if (debug) {
destination = (unsigned *) uio0_ptr;
dest_register[0] = 0x0;
int test_data[8] = {0, 255, 127, 128, 13, 82, 148, 223};
for (i=0; i<8; i++) {
printf("\n");
printf("Writing 0x%02x (0b%s) by bit-banging via 4 lines, MSB first.\n", test_data[i], byte_to_binary(test_data[i]));
printf("line 0 : sr_out\n");
printf("line 1 : sr_en\n");
printf("line 2 : sr_ck\n");
printf("line 3 : sr_in\n");
printf("lines 4-7: not connected\n");
send_8bit_serial_data(test_data[i]);
printf("Write finish\n");
}
}
// Write
{
destination = (unsigned *) uio0_ptr;
dest_register[0] = 0x0;
struct uint640_t control_register;
//control_register.data[0] = 0x00000000;
//control_register.data[1] = 0x11111111;
//control_register.data[2] = 0x22222222;
//control_register.data[3] = 0x33333333;
//control_register.data[4] = 0x44444444;
//control_register.data[5] = 0x55555555;
//control_register.data[6] = 0x66666666;
//control_register.data[7] = 0x77777777;
//control_register.data[8] = 0x88888888;
//control_register.data[9] = 0x99999999;
//control_register.data[10] = 0xAAAAAAAA;
//control_register.data[11] = 0xBBBBBBBB;
//control_register.data[12] = 0xCCCCCCCC;
//control_register.data[13] = 0xDDDDDDDD;
//control_register.data[14] = 0xEEEEEEEE;
//control_register.data[15] = 0xFFFFFFFF;
//control_register.data[16] = 0x00000000;
//control_register.data[17] = 0x11111111;
//control_register.data[18] = 0x22222222;
//control_register.data[19] = 0x33333333;
//const char * string = "33333333 22222222 11111111 00000000 FFFFFFFF "
// "EEEEEEEE DDDDDDDD CCCCCCCC BBBBBBBB AAAAAAAA "
// "99999999 88888888 77777777 66666666 55555555 "
// "44444444 33333333 22222222 11111111 00000000";
const char * string = "FFEEDDCC BBAA9988 77665544 33221100 FFFFFFFF "
"EEEEEEEE DDDDDDDD CCCCCCCC BBBBBBBB AAAAAAAA "
"99999999 88888888 77777777 66666666 55555555 "
"44444444 33333333 22222222 11111111 00000000";
string_to_uint640(string, &control_register);
// Sanity check
{
char string2[200];
uint640_to_string(&control_register, string2);
}
send_616bit_serial_data(&control_register);
printf("Write finish\n");
}
printf("-- Example program ends --\n");
// Unmap the UIO devices
munmap(uio0_ptr, UIO0_SIZE);
return 0;
}
