rearranged api examples

examples/c/main.c → examples/c_api/main.c

@@ -12,42 +12,41 @@ int main ()
     // board detection
     bool detected = cariboulite_detect_connected_board(&hw_ver, hw_name, hw_uuid);
     if (detected) printf("Detection: %d, HWVer: %d, HWName: %s, UUID: %s\n", detected, hw_ver, hw_name, hw_uuid);
-    else 
+    else
     {
         printf("No board detection, Exiting\n");
         return 0;
     }
-    
+
     // library version
     cariboulite_get_lib_version(&version);
     printf("Version: %02d.%02d.%02d\n", version.major_version, version.minor_version, version.revision);
-    
+
     // init
-	cariboulite_init(false, cariboulite_log_level_none);
-    
+    cariboulite_init(false, cariboulite_log_level_none);
+
     // board serial number
     serial_number = cariboulite_get_sn();
     printf("Serial Number: %08X\n", serial_number);
-    
+
     // channels names and freqs
     char ch_name[64];
     int ch_num_ranges;
     float low_freq_vec[3];      // the actual size determined by ch_num_ranges but here we just statically allocated
     float high_freq_vec[3];
     int channels[2] = {cariboulite_channel_s1g, cariboulite_channel_hif};
-    
+
     for (int ch_ind = 0; ch_ind < 2; ch_ind ++)
     {
         cariboulite_get_channel_name(channels[ch_ind], ch_name, sizeof(ch_name));
         ch_num_ranges = cariboulite_get_num_frequency_ranges(channels[ch_ind]);
         printf("Channel: %d, Name: %s, Num. Freq. Ranges: %d\n", channels[ch_ind], ch_name, ch_num_ranges);
         cariboulite_get_frequency_limits(channels[ch_ind], low_freq_vec, high_freq_vec, NULL);
         for (int i = 0; i < ch_num_ranges; i++)
-        {       
+        {
             printf("   Range %d:  [%.2f, %.2f]\n", i, low_freq_vec[i], high_freq_vec[i]);
         }
     }
-
     cariboulite_close();
-	return 0;
+    return 0;
 }

examples/cpp_api/main.cpp → examples/cpp_api/async_rx_api/main.cpp

@@ -21,29 +21,29 @@ void detectBoard()
     CaribouLite::SysVersion ver;
     std::string name;
     std::string guid;
-    
+
     if (CaribouLite::DetectBoard(&ver, name, guid))
     {
         std::cout << "Detected Version: " << CaribouLite::GetSystemVersionStr(ver) << ", Name: " << name << ", GUID: " << guid << std::endl;
     }
     else
     {
         std::cout << "Undetected CaribouLite!" << std::endl;
-    }    
+    }
 }
 
 // Calculate the RSSI
 float RSSI(const std::complex<float>* signal, size_t num_of_samples)
 {
-    if (num_of_samples == 0) 
+    if (num_of_samples == 0)
     {
         return 0.0f;
     }
 
     float sum_of_squares = 0.0f;
-    for (size_t i = 0; i < num_of_samples && i < num_of_samples; ++i) 
+    for (size_t i = 0; i < num_of_samples && i < num_of_samples; ++i)
     {
-        float vrms = std::norm(signal[i]);        
+        float vrms = std::norm(signal[i]);
         sum_of_squares += vrms * vrms / 100.0;
     }
 
@@ -61,10 +61,9 @@ void receivedSamples(CaribouLiteRadio* radio, const std::complex<float>* samples
         std::cout << "[" << samples[i].real() << ", " << samples[i].imag() << "]";
     }
     std::cout << std::endl;*/
-    
+
     std::cout << "Radio: " << radio->GetRadioName() << " Received " << std::dec << num_samples << " samples"
               << "RSSI: " << RSSI(samples, num_samples) << " dBm" << std::endl;
-
 }
 
 
@@ -73,35 +72,35 @@ int main ()
 {
     // try detecting the board before getting the instance
     detectBoard();
-    
+
     // get driver instance - use "CaribouLite&" rather than "CaribouLite" (ref)
     CaribouLite &cl = CaribouLite::GetInstance();
-    
+
     // print the info after connecting
     printInfo(cl);
-        
+
     // get the radios
     CaribouLiteRadio *s1g = cl.GetRadioChannel(CaribouLiteRadio::RadioType::S1G);
     CaribouLiteRadio *hif = cl.GetRadioChannel(CaribouLiteRadio::RadioType::HiF);
-    
+
     // write radio information
     std::cout << "First Radio Name: " << s1g->GetRadioName() << "  MtuSize: " << std::dec << s1g->GetNativeMtuSample() << " Samples" << std::endl;
     std::cout << "First Radio Name: " << hif->GetRadioName() << "  MtuSize: " << std::dec << hif->GetNativeMtuSample() << " Samples" << std::endl;
-    
+
     std::vector<CaribouLiteFreqRange> range_s1g = s1g->GetFrequencyRange();
     std::vector<CaribouLiteFreqRange> range_hif = hif->GetFrequencyRange();
     std::cout << "S1G Frequency Regions:" << std::endl;
     for (int i = 0; i < range_s1g.size(); i++)
     {
         std::cout << "  " << i << ": " << range_s1g[i] << std::endl;
     }
-    
+
     std::cout << "HiF Frequency Regions:" << std::endl;
     for (int i = 0; i < range_hif.size(); i++)
     {
         std::cout << "  " << i << ": " << range_hif[i] << std::endl;
     }
-    
+
     // start receiving until enter pressed on 900MHz
     int num = 2;
     while (num --)
@@ -115,13 +114,12 @@ int main ()
         {
             std::cout << "The specified freq couldn't be used" << std::endl;
         }
-
         s1g->SetRxGain(0);
         s1g->SetAgc(false);
         s1g->StartReceiving(receivedSamples);
 
         getchar();
-        
+
         try
         {
             hif->SetFrequency(2400000000);
@@ -134,11 +132,10 @@ int main ()
         hif->SetRxGain(0);
         hif->SetAgc(false);
         hif->StartReceiving(receivedSamples);
-        
+
         getchar();
     }
-
     hif->StopReceiving();
-    
+
     return 0;
 }

examples/cpp_api/sync_rx_api/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.2)
+project(test_app)
+
+# Find the package using pkg-config
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(CARIBOULITE REQUIRED cariboulite)
+
+# Add the executable
+add_executable(test_app main.cpp)
+
+# Include directories from the cariboulite package
+target_include_directories(test_app PRIVATE ${CARIBOULITE_INCLUDE_DIRS})
+
+# Link against the cariboulite library
+target_link_libraries(test_app PRIVATE ${CARIBOULITE_LIBRARIES} -lcariboulite)

examples/cpp_api/sync_rx_api/main.cpp

@@ -0,0 +1,151 @@
+#include <iostream>
+#include <string>
+#include <CaribouLite.hpp>
+#include <thread>
+#include <complex>
+#include <unistd.h>
+#include <cmath>
+
+// Print Board Information
+void printInfo(CaribouLite& cl)
+{
+    std::cout << "Initialized CaribouLite: " << cl.IsInitialized() << std::endl;
+    std::cout << "API Versions: " << cl.GetApiVersion() << std::endl;
+    std::cout << "Hardware Serial Number: " << std::hex << cl.GetHwSerialNumber() << std::endl;
+    std::cout << "System Type: " << cl.GetSystemVersionStr() << std::endl;
+    std::cout << "Hardware Unique ID: " << cl.GetHwGuid() << std::endl;
+}
+
+// Detect the board before instantiating it
+void detectBoard()
+{
+    CaribouLite::SysVersion ver;
+    std::string name;
+    std::string guid;
+
+    if (CaribouLite::DetectBoard(&ver, name, guid))
+    {
+        std::cout << "Detected Version: " << CaribouLite::GetSystemVersionStr(ver) << ", Name: " << name << ", GUID: " << guid << std::endl;
+    }
+    else
+    {
+        std::cout << "Undetected CaribouLite!" << std::endl;
+    }
+}
+
+// Calculate the RSSI
+float RSSI(const std::complex<float>* signal, size_t num_of_samples)
+{
+    if (num_of_samples == 0)
+    {
+        return 0.0f;
+    }
+
+    float sum_of_squares = 0.0f;
+    for (size_t i = 0; i < num_of_samples; ++i)
+    {
+        float vrmsp2 = (signal[i].real() * signal[i].real()) + (signal[i].imag() * signal[i].imag());
+        sum_of_squares += vrmsp2 / 100.0;
+    }
+
+    float mean_of_squares = sum_of_squares / num_of_samples;
+
+    // Convert RMS value to dBm
+    return 10 * log10(mean_of_squares);
+}
+
+// Rx Callback (async)
+void receivedSamples(CaribouLiteRadio* radio, const std::complex<float>* samples, CaribouLiteMeta* sync, size_t num_samples)
+{
+    std::cout << "Radio: " << radio->GetRadioName() << " Received " << std::dec << num_samples << " samples"
+              << "RSSI: " << RSSI(samples, num_samples) << " dBm" << std::endl;
+
+}
+
+
+// Main entry
+int main ()
+{
+    std::complex<float>* samples = new std::complex<float>[128*1024];
+
+    // try detecting the board before getting the instance
+    detectBoard();
+
+    // get driver instance - use "CaribouLite&" rather than "CaribouLite" (ref)
+    // get a "synchronous" api instance
+    CaribouLite &cl = CaribouLite::GetInstance(false);
+
+    // print the info after connecting
+    printInfo(cl);
+
+    // get the radios
+    CaribouLiteRadio *s1g = cl.GetRadioChannel(CaribouLiteRadio::RadioType::S1G);
+    CaribouLiteRadio *hif = cl.GetRadioChannel(CaribouLiteRadio::RadioType::HiF);
+
+    // write radio information
+    std::cout << "First Radio Name: " << s1g->GetRadioName() << "  MtuSize: " << std::dec << s1g->GetNativeMtuSample() << " Samples" << std::endl;
+    std::cout << "First Radio Name: " << hif->GetRadioName() << "  MtuSize: " << std::dec << hif->GetNativeMtuSample() << " Samples" << std::endl;
+
+    std::vector<CaribouLiteFreqRange> range_s1g = s1g->GetFrequencyRange();
+    std::vector<CaribouLiteFreqRange> range_hif = hif->GetFrequencyRange();
+    std::cout << "S1G Frequency Regions:" << std::endl;
+    for (int i = 0; i < range_s1g.size(); i++)
+    {
+        std::cout << "  " << i << ": " << range_s1g[i] << std::endl;
+    }
+
+    std::cout << "HiF Frequency Regions:" << std::endl;
+    for (int i = 0; i < range_hif.size(); i++)
+    {
+        std::cout << "  " << i << ": " << range_hif[i] << std::endl;
+    }
+
+    // Receive Synchrnonously
+    try
+    {
+        hif->SetFrequency(2490000000);
+    }
+    catch (...)
+    {
+        std::cout << "The specified freq couldn't be used" << std::endl;
+    }
+    hif->SetRxGain(69);
+    hif->SetAgc(false);
+    hif->SetRxSampleRate(4000000);
+    //hif->StartReceiving();
+
+    s1g->SetRxGain(69);
+    s1g->SetAgc(false);
+    s1g->SetRxSampleRate(2000000);
+    s1g->StartReceiving();
+
+    int num_buffers = 10;
+    while (num_buffers--)
+    {
+        //s1g->FlushBuffers();
+        int ret = s1g->ReadSamples(samples, (1<<16));
+        if (ret > 0)
+        {
+            std::cout << "Radio: " << hif->GetRadioName() << " Received " << std::dec << ret << " samples"
+                      << "RSSI: " << RSSI(samples, ret) << " dBm" << std::endl;
+            std::cout << "Radio: " << s1g->GetRadioName() << " Received " << std::dec << ret << " samples" << std::endl;
+        }
+    }
+
+    /*try
+    {
+        s1g->SetFrequency(900100000);
+    }
+    catch (...)
+    {
+        std::cout << "The specified freq couldn't be used" << std::endl;
+    }
+    s1g->SetRxGain(69);
+    s1g->SetRxBandwidth(2500e3);
+    s1g->SetAgc(false);
+    s1g->StartReceiving(receivedSamples);*/
+
+    delete []samples;
+
+    return 0;
+}