[Solved] undefined reference to `stdio_init_all'

[llooman]

While trying to start pi pico development
Downloaded latest 1.9.3.
Using Arduino-cli compile --fqbn rp2040:rp2040:rpipico

#include <stdio.h>
#include "pico/stdlib.h"

int main() {
stdio_init_all();

while (true) {
    printf("Hello, world!\n");
    sleep_ms(1000);
}
return 0;

}

Any tips?

[Andy2No]

Maybe try version 1.9.2, instead.

[Tomwhiting1987]

Hi Earle, I tried your suggestion above for this (enabling Serial as debug port) but when I use non-Arduino methods such as the code below, the Serial monitor is not available - i get "Error opening serial port 'COM8'. (Port not found)". The same happened when I used Serial.printf in the same code. However, when I do this using Arduino methods (setup, loop) and Serial.printf like in llooman's code below, a COM port becomes available for the serial monitor and it works! Any ideas? Maybe something I'm doing silly or I've misunderstood?

#include <stdio.h>
#include "pico/stdlib.h"

int main() {
printf("Hello, world!\n");
sleep_ms(1000);
}

[earlephilhower]

You can't have a main() in this core. For that, you need to use the plain pico-sdk and cmake. The core already has a main which sets up the Arduino-way of doing things and handles the setup/loop logic.

[TorontoFred]

Mr. Philhower, I think this topic needs a bit more thought for others like myself and my colleagues here. First and foremost we are trying to program RP2040 in C. And for myself, I'm following this book, Programming the Raspberry Pi Pico in C by Harry Fairhead. In that book, he uses your Board Library, which can be downloaded into Arduino Classic IDE, Raspberry Pi Pico/RP2040 V. 1.9.8. And of course the addition of the Additional Boards Manager URLs under Preferences. Nothing else.
For basic digital I/O functions, programming in C, this arrangement works. An example is this push pb and hold:

//#include "pico/stdlib.h"  //Seems to work with or without. 

//  Press Or Hold  You can carry on elaborating on how to respond to a button. 
//  For example,  most users have grown accustomed to the idea that holding a 
//  button down for  a longer time than a press makes something different happen. 
//  To distinguish  between a press and a hold.  Pg 84

int main()
{
    gpio_set_function(21, GPIO_FUNC_SIO);
    gpio_set_dir(21,false);
    gpio_pull_down(21);

    gpio_set_function(22, GPIO_FUNC_SIO);
    gpio_set_dir(22, true);
    gpio_put(22, 0);

    uint64_t t;

    while(true)
    {
     while(gpio_get(21) == 0){};
     t = time_us_64();
     sleep_ms(1);
     while(gpio_get(21)== 1){};
     t =(uint64_t)(time_us_64()-t);
     if (t<2000*1000)
     {
      gpio_put(22, 1);
      sleep_ms(1000);
      gpio_put(22, 0);
     }
     else
     {
      for (int i=0; i< 10; i++)
      {
        gpio_put(22, 1);
        sleep_ms(100);
        gpio_put(22, 0);
        sleep_ms(100);
      }
     }
    }
}

The first problem is using Arduino's Monitor to track the performance of the programme. Here's an example with some attempt to solve the issue commented.

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/adc.h"
//#define PICO_DEFAULT_UART 0
//#define PICO_DEFAULT_UART_TX_PIN 0
//#define PICO_DEFAULT_UART_RX_PIN 1

int main()

{
  void stdio_uart_init(void);
  
  adc_init();
  adc_gpio_init(26);
  adc_gpio_init(29);


  while(1)

  {
    const float conversion_factor = 3.3f / (1<<12);
    adc_select_input(0);
    uint16_t result = adc_read();
    printf("Raw value 0: 0x%03x, voltage: %f V\n" , result, result * conversion_factor);

    adc_select_input(3);
    result = adc_read();
    printf("Raw value 3: 0x%03x,  voltage %f V\n" , result, result*conversion_factor);

    sleep_ms(500);
  }
}

To upload these programmes to the target Pico, I select the board. Of course, there is no comport, so, I disconnect the board from the PC, press the Boot PB, reconnect and the expected RP2 Boot under "other devices" pops up. I then hit the Arduino IDE upload button and it, resets a comport (sometimes COM7), complies and uploads, and releases RP2 Boot as the board resets. Note that IDE/Tools/Debug Port/is serial.

For the Pushbutton Hold programme above, it works as expected. - As a note: When using the Arduino C dialect, I observe that the IDE first resets the RP2040 so that access to it is a portable device. After upload, it resets the RP2040 and this time RP2040 executes the programme and opens a comport on its USB.

For the Analog_Input example above, I get this as the last comment in the IDE upload comments section, "Board at COM8 is not available."

At this point, we can continue a laborious discussion. Like the structure of setup() and loop() as opposed to main() However, my intent is to come up with some sort of conclusion/solution that my colleagues and I can use now. Let's establish some common ground.

1. We're interested in standard C because it allows us to dig deep into the machine to do things that normally wouldn't be possible if we relied on other people's libraries. This C dialect may be referred to as the scalpel. Arduino's IDE uses a friendlier C dialect making it possible to quickly design solutions using a friendlier syntax and libraries at a cost of flexibility. I call this the machete.
2. Generally, we are not impressed with the toolchain used to cut code and upload it as described in Mr. Fairhead's book. We are makers, not coders. Our expertise is connecting a microcontroller to the outside world. We know contact sulphidation, for example. Hence our appeal to Arduino's IDE approach.
3. I have not installed the Arduino board library, Arduino Mbed RP2040 Boards.

If it is possible to open a comport of some sort to monitor printf statements when coding in standard C; can you provide a solution example of that programme?

If it is not at all possible at this time, can you make that statement with an alternative as an example.... possibly an Arduino sketch? This is simply to tie up loose ends for colleagues less knowledgeable.

Thank you for your time, Mr. Philhower.

[Andy2No]

Booman's answer (13th of August) covers how to use the Arduino serial monitor - you have to use Serial.begin(speed);, in setup(), then use Serial.printf(..); or Serial.write(); or Serial.print(); which are simpler - they take a single string or variable, and don't do any formatting. Those compile to a smaller amount of machine code.

Since it's Arduino, not quite standard C++, you should at least change the name of main() to setup().

Since the last part of the body of your main() is an endless loop, the Arduino way is to put the contents of that in loop(), without the while(1) part, but it has the same effect either way.

[earlephilhower]

This is the first I've heard of that book, @TorontoFred , but I think its author doesn't quite get the whole Arduino idea and really chose the wrong tool for the job.

If you want to use straight C/C++, the pico-sdk is very accessible and easy to set up, even for Windows, with many tutorials on it. Using something like VS Code or even Eclipse with the regular toolchain should be a simple, solved exercise and let you have 100% control of the Pico. With that integration it's very much like the Arduino IDE. Most of the SDK is available in this Arduino port, but in 99.9% of cases there is no reason to ever use it in your own code.

This Arduino core is built to work with the 1,000s of Arduino libraries, and tries hard to "just work" for Arduino users. Need to read environmental sensors? Include the BMP library. Need an LCD display, there are dozens of SPI graphics libraries that work.

So, the USB port is initted on startup to enable auto-reset/upload (unlike some other boards, the Pico USB serial port is actually code running on the Pico itself, so w/o the whole USB init you won't see a serial port at all and won't be able to reset into upload mode automatically).

If all you want is printf() to work, again all you need to do is add a Serial.begin() at the top of setup() and set the Tools->Debug Port->Serial menu in the IDE and it should go. You can also just call Serial.printf() instead.

Alternatively, you could do things the Arduino way and your code will work on the Pico or on the AVR or on the SAMD boards or ESP8266 or ESP32. For example, your last code snippet would be something like:

void setup() {
    Serial.begin(115200);
    pinMode(A0, INPUT);
    pinMode(A3, INPUT);
}

void loop() {
    const float conversion_factor = 3.3f / (1<<12);

    auto result = analogRead(A0);
    Serial.printf("Raw value 0: 0x%03x, voltage: %f V\n" , result, result * conversion_factor);

    result = analogRead(A3);
    Serial.printf("Raw value 3: 0x%03x,  voltage %f V\n" , result, result*conversion_factor);

    delay(500);
}

[llooman]

Many thanks Earl,

Just do it the Arduino way is working. The Serial.print default to the pico USB.
I did read a lot of other sites to start with the pi pico, very confusing.

void setup() {
Serial.begin(115200);
}

void loop() {
delay(3000);
Serial.printf("Core temperature: %2.1fC\n", analogReadTemp());
}

I hope Maxgerhardt will get the platform.io version done.
https://github.com/maxgerhardt/platform-raspberrypi