how to send uart data over ble with nrf52840 dongle

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Fri, 09 Apr 2021 12:40:40 GMT

Although I felt very lucky to get these replies.

I think I've found out why uart_event_handle didn't send the data.

void uart_event_handle(app_uart_evt_t * p_event)
{
    static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
    static uint8_t index = 0;
    uint32_t       err_code;

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            index++;

            if ((data_array[index - 1] == '\n') ||
                (data_array[index - 1] == '\r') ||
                (index >= m_ble_nus_max_data_len))
            {
                if (index > 1)
                {
                    NRF_LOG_DEBUG("Ready to send data over BLE NUS");
                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);

                    do
                    {
                        uint16_t length = (uint16_t)index;
                        err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
                        printf("%s\r\n", data_array);
                        if ((err_code != NRF_ERROR_INVALID_STATE) &&
                            (err_code != NRF_ERROR_RESOURCES) &&
                            (err_code != NRF_ERROR_NOT_FOUND))
                        {
                            APP_ERROR_CHECK(err_code);
                        }
                    } while (err_code == NRF_ERROR_RESOURCES);
                }

                index = 0;
            }
            break;

        case APP_UART_COMMUNICATION_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_communication);
            break;

        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;

        default:
            break;
    }
}

The function above has certain condition for sending data over ble.

if ((data_array[index - 1] == '\n') ||
(data_array[index - 1] == '\r') ||
(index >= m_ble_nus_max_data_len))

this seems the part that I should've understood. When sending the data from Arduino I had to send '\n' at the end.

It seems above handler waits for the condition above.

This is the Arduino code that works now.

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
  }


  Serial.println("Goodnight moon!");

  // set the data rate for the SoftwareSerial port
  mySerial.begin(115200);
  mySerial.println("Hello, world?");
}
char c = 'a';
void loop() // run over and over
{
  
  if (mySerial.available()){
    Serial.write(mySerial.read());
    if (c == 'z' + 1)
      c = 'a';
    mySerial.write(c++);mySerial.write('\n');
  }
  delay(500);
}

I can see the sent data from python shell with the setup I had.

I have tones of other questions but I guess I can wrap it up for now.

RE: how to send uart data over ble with nrf52840 dongle

Karl Ylvisaker — Fri, 09 Apr 2021 10:58:44 GMT

[quote user="Senchoi"]

I did not fully understand this part but as I tried app_uart_put it sends to arduino just fine.

I'm a bit confused because the issue at this moment is arduino not sending uart signal to NRF. I'm not sure why arduino's RX register matters.

[/quote]

Thats great to hear - so now we know that the issue is with the arduino sending over uart, not with the NRF and its RX/TX. This is great to know for the continued debugging effort.
The reason I asked you to do this test was to figure out if the issue was with the nrf or the arduino.
It was not clear to me that the issue was on the arduino's side prior to you confirming this.

[quote user="Senchoi"]I guess this issue is not going to end unless I can fully understand what's going on in UART. Would it help to get logic analyzer?[/quote]

There are always ways to get around it, but they are tedious and take a lot longer. Being enable to see exactly what is happening on the lines help tremendously when working with all serial protocols, since it is the only way to know what is actually happening.

[quote user="Senchoi"]But modifying existing handler to send the received data back to arduino is a little out of my capability. I was kinda hoping to know a sure way to receive uart data from arduino since the error code is 5.[/quote]

I am sure you will be able to modify this if you had wanted - but since we now know that the issue is on the arduino side you do not have to make this modification, since we are past that part of the debugging. If the arduino is not sending correctly, there is nothing you can do on the nrf side to alleviate this, so we will have to look at the arduino side to resolve this.

[quote user="Senchoi"]if uart_event_handle function is supposed to handle incoming uart data just fine and arduino is the only problem, figuring out what's exactly happening might be a waste of time because final product wouldn't work with arduino.[/quote][quote user="Senchoi"]is uart_event_handle function implemented and getting it used in uart_init enough to make it deliver the data just fine?[/quote]

Yes, you are right. The default uart_event_handler in the ble_app_uart example does exactly this - whenever it receives something through UART it queues it for sending over BLE.
I was not aware that you do not intend to keep the arduino in your project. I suppose you could say that debugging the arduino is then a waste of time, but then again - what did you hope to achieve with the arduino in the first place? Certainly these goals will not be met if you abandon the arduino now.

[quote user="Senchoi"]if this works I might not even have to use logic analyzer.[/quote]

In the short term this looks to be the case then, yes. For future development it would however be very useful for you to have access to a logic analyzer when developing with serial protocols.
Fortunately, logic analyzers are quite easy to come by these days, and there exists many cheap versions out there, so at least it might be something to look into, for you own future sake.

[quote user="Senchoi"]After commenting out uart_init function. It seems the test I was doing works fine. The one with sending 111. Only if printf function would work without breaking texts.[/quote]

I am not sure what you mean by this. Are you saying that if you comment out uart_init, you are able to pass the byte with value 111 back and forth as expected?
As I mentioned earlier, the retargeted printf actually uses the app_uart_put function behind the curtains. You could check the retargeting library source code to see this for yourself. This means that if you use printf, it is the same as calling app_uart_put on a cstring containing whatever you tried to have print.
If you refrain for using the retargeted printf function, this should not be an issue.

[quote user="Senchoi"]shouldn't retval be NRF_SUCCESS when it gets data from RX?[/quote]

Yes, it should be NRF_SUCCESS if it has successfully retrieved a byte from the UART RX buffer.
This is the kind of issue we could easily avoid if we had a logic analyzer scope the communication, because suddenly it seems like the arduino is sending the data as expected.

On a general note the returned error code should usually be passed to an APP_ERROR_CHECK for handling, but this is not necessary in this simple debugging test program. I just thought I should mention it for future development.

[quote user="Senchoi"]But the code below this prints out on arduino just like it's expected.[/quote]

Are you saying that you are then able to pass the same '111' valued byte back and forth?

[quote user="Senchoi"]With the code below, nothing prints out on arduino.[/quote]

On a general note you should always use braces around your conditional statements, it is considered bad practice for maintainability to leave the braces out just because you technically can. Please see this StackOverflow answer for more detail.

Best regards,
Karl

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 22:21:18 GMT

This is also interesting.

With the code below, nothing prints out on arduino.

    uint8_t data;
    uint32_t retval;
    for (;;)
    {
        retval=app_uart_get(&data);
        if(retval==NRF_SUCCESS)
          app_uart_put(data);
        nrf_delay_ms(500);
    }

But the code below this prints out on arduino just like it's expected.

    uint8_t data;
    uint32_t retval;
    for (;;)
    {
        retval=app_uart_get(&data);
        app_uart_put(data);
        nrf_delay_ms(500);
    }

shouldn't retval be NRF_SUCCESS when it gets data from RX?

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 18:16:59 GMT

After commenting out uart_init function. It seems the test I was doing works fine. The one with sending 111. Only if printf function would work without breaking texts.

Still If I could not use uart_event_handle function I don't know how to send this uart data, 111 in this case, over bluetooth.

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 15:52:51 GMT

Another thing,

if uart_event_handle function is supposed to handle incoming uart data just fine and arduino is the only problem, figuring out what's exactly happening might be a waste of time because final product wouldn't work with arduino.

What I could do is testing it with the actual final setup that's going to be in place of current arduino.

is uart_event_handle function implemented and getting it used in uart_init enough to make it deliver the data just fine?

if this works I might not even have to use logic analyzer.

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 15:28:31 GMT

And is there anything else that's helpful other than logic analyzer?

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 15:23:38 GMT

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303790#303790"]On the Arduino side, have the arduino send a single known byte periodically, for example a byte with value 111. Have the arduino check if it has received anything in its UART RX register by checking .available() with following .read() periodically, and if it has have the arduino toggle a LED or something similar - the arduino should also check the value of the byte it has received, to see if it matches the value of the byte it sent.[/quote]

I did not fully understand this part but as I tried app_uart_put it sends to arduino just fine.

I'm a bit confused because the issue at this moment is arduino not sending uart signal to NRF. I'm not sure why arduino's RX register matters.

My goal is eventually to deliver series of uint8_t data periodically over ble.

I can understand the importance of sending periodical data from arduino and let dongle's handler handle the data. But modifying existing handler to send the received data back to arduino is a little out of my capability. I was kinda hoping to know a sure way to receive uart data from arduino since the error code is 5.

I guess this issue is not going to end unless I can fully understand what's going on in UART. Would it help to get logic analyzer?

RE: how to send uart data over ble with nrf52840 dongle

Karl Ylvisaker — Thu, 08 Apr 2021 13:17:27 GMT

[quote user="Senchoi"]

Also i'm not sure If it's because of connection. "0 received. 5 is the retval." message breaks like crazy.

something like..

[/quote]

The returned value of app_uart_get is an uint32_t, not an int, I am not sure that the arduino decodes it correctly in the printf statement.
Take a look at this stackoverflow answer for a more indepth explanation of why it is important to be exact with these types.

[quote user="Senchoi"]I don't understand. Should I ask this in arduino community about how to send uart signal other than mySerial.write function?[/quote]

Keep in mind that the app_uart_get function retrieves one byte at the time.
Reading the .write arduino documentation again seems to say that the .write takes an array, or a single value. In this case, a byte with value 111 should have been written.

However, you are also first attempting to write what you have received last, with the .write(.read()) function. Then we need to look at what your arduino might be receiving over the UART. In this case, it looks like it will receive the cstring from your printf statement.
This is certainly a little chaotic.

I am not certain that the logic in your test is correct. Please write down what you tried to have happen in this code. If the goal was to periodically send a byte with value 111 that is not what you are currently doing.

How about this instead:
On the NRF side, implement the test as part of the uart RX event handler, have it retrieve the one byte using app_uart_get, and then send the same byte back by using app_uart_put for only that single byte, received over UART. Do not use printf for anything in this test, as the retargeting of printf will have its output be put on the UART, creating clutter.
Let your main() loop only contain the idle_state_handler call.

On the Arduino side, have the arduino send a single known byte periodically, for example a byte with value 111. Have the arduino check if it has received anything in its UART RX register by checking .available() with following .read() periodically, and if it has have the arduino toggle a LED or something similar - the arduino should also check the value of the byte it has received, to see if it matches the value of the byte it sent.

Implement this test, and see if it results in the LED toggling every 500 ms period on the arduino, then you will know that their communication is working as it should.

I think part of the issue here is that you have not checked your returned error codes, and that you have mixed up what is actually happening on the UART interface, since you are using printf on both sides in combination with your test byte. Additionally I think the test logic on the arduino side might not have achieved exactly what you hoped to.

This is where a logical analyzer would make the work a lot easier, since we immediately would see what is going on on the UART - but we will find a way to make due without the analyzer.

Looking forward to resolving this issue together!

Best regards,
Karl

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 12:21:00 GMT

The error code is five which must be NRF_ERROR_NOT_FOUND.

I guess arduino is not sending the uart signal for some reason.

Here's my arduino code...

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
  }


  Serial.println("Goodnight moon!");

  // set the data rate for the SoftwareSerial port
  mySerial.begin(115200);
  mySerial.println("Hello, world?");
}

void loop() // run over and over
{
  if (mySerial.available()){
    Serial.write(mySerial.read());
    mySerial.write(111);
  }
}

Here's my dongle code in the main function.

    uint8_t data;
    int retval;
    for (;;)
    {
        retval = app_uart_get(&data);
        printf("%u received. %d is the retval.\n", data, retval);
        //idle_state_handle();
        //nrf_pwr_mgmt_run();
        //NRF_LOG_FLUSH();
        nrf_delay_ms(500);
    }

this setup constantly prints out "0 received. 5 is the retval." in every 500ms.

I don't understand. Should I ask this in arduino community about how to send uart signal other than mySerial.write function?

Also i'm not sure If it's because of connection. "0 received. 5 is the retval." message breaks like crazy.

something like..

0 recived.  is th retal.
0 recdved. 5 s theretal.
0 rece⸮⸮⸮s⸮~⸮.A⸮⸮⸮⸮g⸮[I⸮0 receved.5 Z.ݫ⸮⸮х⸮⸮
0 reaeiv;⸮. 5 iq⸮⸮W&⸮va[⸮⸮0 received. 5 isthe reval.
0 recewed. 5 is he reval.
0 rY⸮YZY⸮	J́⸮⸮⸮⸮⸮х⸮⸮R0 received. 5 is th re:val.
0 receve⸮. 5 is the 9eval.

RE: how to send uart data over ble with nrf52840 dongle

Karl Ylvisaker — Thu, 08 Apr 2021 11:09:04 GMT

[quote user="Senchoi"]That's just how "the other" dongle is programmed. "the other" dongle listens ble signal and sends Serial signal to the computer. When python reads the other dongle and there's no data, it prints out 0 after timeout period that is set in Python code. It will print something other than 0 before timeout when "the other" dongle reads something.[/quote]

Aha, I misinterpreted your 's' as a shorthand for seconds, instead of plural, thank you for clarifying.

[quote user="Senchoi"]testing part in the dongle is below code in the main function out of loop.[/quote]

You are not checking the returned error code of app_uart_get. You should always check the returned error code - if you do not, you have no way of knowing whether the function succeeded or not.

[quote user="Senchoi"]Arduino code looks like this[/quote]

I am not too familiar with arduino code personally, but it looks to me like your conditional statements check whether to write something only if it has already received something?
Your conditionals use the .available() function, which only will evaluate to true if data has already been received over UART. It looks to me like none of those lines will ever run, unless the dongle starts out by sending something over UART to the arduino.
Could you also have you arduino either toggle a LED or give some other indication that it is writing to UART? You could for example base this on the returned value from the .write() function.

[quote user="Senchoi"]But it seems idle_state_handle() in the for loop constantly turns the dongle on and off for power management since "0 received" prints out about every half a second when the dongle is connected to Arduino.[/quote]

The idle_state_handler checks whether there are logs that needs processing, and if not it places the CPU in a low power SYSTEM_ON state (idle) to save power. It does not turn off the dongle (SYSTEM_OFF). Since you are not checking the error code returned by the app_uart_get function the function might never actually succeed, and this might be why you are seeing the repeated 0 (if this is the initialized value of the data variable).
You could check this by either checking the returned error code - which you always should do -, or by initializing the data variable to a known other value, and seeing if this is the value you are seeing repeatedly.

Looking forward to resolving this issue together!

Best regards,
Karl

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 10:30:38 GMT

There's a typo in the code in this part.

[quote userid="103143" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303707#303707"]testing part in the dongle is below code[/quote]

uint8_t data;
app_uart_get(&data);
printf("%u received", data);

I left out "f" from printf function. My apologies.

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Thu, 08 Apr 2021 10:27:16 GMT

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303704#303704"]I don't fully understand what you mean by this sentence. The python code is made to print something on the serial terminal after a timeout of 0s...? Please elaborate on this.[/quote]

That's just how "the other" dongle is programmed. "the other" dongle listens ble signal and sends Serial signal to the computer. When python reads the other dongle and there's no data, it prints out 0 after timeout period that is set in Python code. It will print something other than 0 before timeout when "the other" dongle reads something.

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303704#303704"]This is an interesting find that indicates that that the UART data is not processed correctly.
Could you show me the specific code you used for this test?[/quote]

Arduino code looks like this

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
  }


  Serial.println("Goodnight moon!");

  // set the data rate for the SoftwareSerial port
  mySerial.begin(115200);
  mySerial.println("Hello, world?");
}

void loop() // run over and over
{
  if (mySerial.available())
    Serial.write(mySerial.read());
  if (Serial.available())
    mySerial.write(111);
  //delay(500);
}

testing part in the dongle is below code in the main function out of loop.

uint8_t data;
app_uart_get(&data);
print("%u received", data);

But it seems idle_state_handle() in the for loop constantly turns the dongle on and off for power management since "0 received" prints out about every half a second when the dongle is connected to Arduino.

RE: how to send uart data over ble with nrf52840 dongle

Karl Ylvisaker — Thu, 08 Apr 2021 09:56:54 GMT

Hello,

[quote user="Senchoi"]Thank you for your reply,[/quote]

No problem at all, I am happy to help!

Thank you for elaborating - this is very helpful for me to understand your project and issue better.

[quote user="Senchoi"]Arduino ide's serial monitor prints out dongle's "printf("\r\nUART started.\r\n");" part repetitively once in every half a second. Although the loop doesn't have any delay and there's no setup of half a second in dongle program(main.c file below).[/quote]

This might be caused by a non-NRF_SUCCESS error code being passed to an APP_ERROR_CHECK.
Since you only have 1 UART hardware interface, and you are using it in your application, it makes us unable to get the debug information from the logger directly.
So instead, we will have to implement something more than the default error-handling, to root out what this issue is.
Alternatively, you could take a look at Jimmy's comment in this ticket where he describes how to get the logger information output over USB - this would be very useful to have during development.

[quote user="Senchoi"]When I check Python IDLE the python code prints out data after set timeout which is 0s instead of "hello world".[/quote]

I don't fully understand what you mean by this sentence. The python code is made to print something on the serial terminal after a timeout of 0s...? Please elaborate on this.

[quote user="Senchoi"]I haven't found such indication. Unfortunately all I have is two dongles and this arduino kit.[/quote]

It is all right, then we will have to make due with these, no problem.

[quote user="Senchoi"]When I used app_uart_get function to receive numbers and sent it right back it just printed out 0. I had sent 111 on the other hand.[/quote]

This is an interesting find that indicates that that the UART data is not processed correctly.
Could you show me the specific code you used for this test?

On a general note I notice that you have a lot of commented out code in your project source code.
I strongly recommend that you move these out of your working document, since this greatly reduced readability and clutters up your IDE. If you have code that you think might be useful later, I suggest moving it to another document for storage, rather than keeping it commented out in the source code.

Looking forward to resolving this issue together!

Best regards,
Karl

RE: how to send uart data over ble with nrf52840 dongle

Senchoi — Wed, 07 Apr 2021 19:13:28 GMT

devzone.nordicsemi.com/.../0451.main.c

Thank you for your reply,

History of this project is pretty long. I don't think I could give you all the details but I'll do my best.

Base of (1) is ble_app_uart/pca10056/s140....emproject file.

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303547#303547"]Did you make any other changes to its functionality?[/quote]

They first transplanted SAADC functions to make it work for something. But I disabled this part in the main function eventually because it's no longer needed

And my mate added send_triangular_wave function to it and this sends uint8_t signal over bluetooth so that I could check with Python IDLE

Also, he changed MIN_CONN_INTERVAL to be 50ms instead of 20ms.

Change I made was, in uart_init function these four parts to suit the wiring,

.rx_pin_no = 29,
.tx_pin_no = 31,
.rts_pin_no = UART_PIN_DISCONNECTED,
.cts_pin_no = UART_PIN_DISCONNECTED,

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303547#303547"]what did you observe when it did not work?[/quote]

Arduino ide's serial monitor prints out dongle's "printf("\r\nUART started.\r\n");" part repetitively once in every half a second. Although the loop doesn't have any delay and there's no setup of half a second in dongle program(main.c file below).

devzone.nordicsemi.com/.../0451.main.c

When I check Python IDLE the python code prints out data after set timeout which is 0s instead of "hello world".

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303547#303547"]a schematic would be very helpful to see[/quote]

I find it a little difficult to draw everything and the setup is not so complicated so I'll use words.

Arduino GND connected to dongle GND

Arduino 3.3v connected to dongle VDD OUT

Arduino digital pin 2(RX) connected to dongle 0.31

Arduino digital pin 3(TX) connected to dongle 0.29

[quote userid="87869" url="~/f/nordic-q-a/73629/how-to-send-uart-data-over-ble-with-nrf52840-dongle/303547#303547"]Do you receive any indication from your dongle that an UART message has been received? The best way to check this is to have it connected to a logical analyzer, but if you do not have access to one you could also for testing purposes have the dongle loop back the received message. I.e if it receives a UART tranmission, it should send it back again immediately before continuing with its application execution.[/quote]

I haven't found such indication. Unfortunately all I have is two dongles and this arduino kit.

When I used app_uart_get function to receive numbers and sent it right back it just printed out 0. I had sent 111 on the other hand.

RE: how to send uart data over ble with nrf52840 dongle

Karl Ylvisaker — Wed, 07 Apr 2021 13:52:39 GMT

Hello,

[quote user=""](1) I've modified the project in example/ble_peripheral/ble_app_uart to send arbitrary data(series of uint8_t signal) to another dongle and I could see the data in Python IDLE.[/quote]

The ble_app_uart example already sends arbitrary (received over UART) uint8_t data to the connected device. Do you mean that you modified it to work with the nRF52840 Dongle (PCA10059)? Did you make any other changes to its functionality?

[quote user=""]I've changed the code (1) a little bit to see if I could send uart to the other dongle. It didn't work.[/quote]

How did you change the code, what functionality were you looking to implement, and what did you observe when it did not work?

[quote user=""]Most of what I've done is changing the TX RX pin number to suit wiring setup.[/quote]

It would be great if you could be explicit here. What changes did you make, and how is your test setup currently wired (a schematic would be very helpful to see)?

[quote user=""]What's hard to understand is the project already has uart_event_handle function in the main.c and it uses ble_nus_data_send function just like (1) but it seems it's not responding to uart signal sent from arduino or it's not sending the received uart signal.[/quote][quote user=""]Although I couldn't check arduino's uart signal, I'm quite sure (2) project's success in test indicates it's not a problem of connection or arduino code. Correct me if I'm wrong.[/quote]

Do you receive any indication from your dongle that an UART message has been received? The best way to check this is to have it connected to a logical analyzer, but if you do not have access to one you could also for testing purposes have the dongle loop back the received message. I.e if it receives a UART tranmission, it should send it back again immediately before continuing with its application execution.
It is always scary to assume that a certain operation or codeblock has executed successfully, without actually knowing.
Could you share this part of the code with me, possibly?

On a general note I would highly recommend acquiring and using the nRF52840 Development Kit for development, rather than the dongles. The dongle is a great companion to the DK during development, but a DK is much easier to work with and debug - especially so because of the on-board debugger.
When working with the dongle it is recommended to have a look through the Dongle Programming Tutorial - but since you have already achieved the code modification and functionality in your (1) description, I suppose you know many of these things already.

Looking forward to resolving this issue together!

Best regards,
Karl