| Cpico_arduino::ArduinoPicoTone | ArduinoPicoTone provides static methods for PicoTone |
| ▼Cpico_arduino::Buffers< T > | We are managing a 2 collections of memory arrays: One for the available buffers which can be requested to record data and the buffers of filled data which need to be processed (e.g. stored to a SD drive) |
| Cpico_arduino::SoundBuffer< T > | SoundBuffer where the data is standardized, amplified and clipped |
| ▼Carduino::HardwareSPI | |
| Cpico_arduino::PicoHardwareSPI | Arduino HardwareSPI interface using the Pico API. We use the following default pins spi0: pinRx = 16; pinTx = 19; pinCS = 17; pinSCK = 18; spi1: pinRx = 12; pinTx = 11; pinCS = 13; pinSCK = 10; On the master miso = pinRx and mosi = pinTx |
| Cpico_arduino::Vector< T >::iterator | Iterator for the Vector class |
| Cpico_arduino::Map< K, V > | A simple key value map collection |
| Cpico_arduino::Map< K, V >::MapEntry< KM, VM > | Key/Value |
| Cpico_arduino::Map< K, V >::MapEntry< K, V > | |
| Cpico_arduino::MuliticoreFifo | The RP2040 contains two FIFOs for passing data, messages or ordered events between the two cores. Each FIFO is 32 bits wide, and 8 entries deep. One of the FIFOs can only be written by core 0, and read by core 1. The other can only be written by core 1, and read by core 0 |
| Carduino::Stream::MultiTarget | |
| Cpico_arduino::PicoDMA< T > | We can use the Pico DMA to copy data "in the background" while the processor is doing some other work. One PicoDMA object represents a single DMA channel which is reserved the first time it is needed. You can release it explicity after you are done with the processing |
| Cpico_arduino::PicoLogger | A simple Logger that writes messages dependent on the log level |
| Cpico_arduino::PicoPinFunction | The pico requires that the function of the pin is defined. In Arduino, there is no such concept - however we need to define if the pin is input or output |
| Cpico_arduino::PicoPWM | This is an even more powerfull PWM API where we can specify a user defined input range and the cycle frequency in hz |
| Cpico_arduino::PicoPWMNano | Basic PWM API based on the input and output in nano seconds The Raspberry Pico has 8 controllable PWM slices with each 2 channels, so we can control up to 16 pwm devices at the same time! This is Simple Basic PWM API where we specifiy the periods and duty cyle in Nanoseconds |
| Cpico_arduino::PicoTone | We use the TimerAlarmRepeating to generate tones |
| Cpico_arduino::PinInfo | Information about an the status and the Arduino PinMode of an individual pin |
| ▼Cpico_arduino::PinSetup | Base class for function specific pin setup and pin use functionality |
| Cpico_arduino::PicoPWMReader | PWM class which supports the input of PWM signals |
| Cpico_arduino::PicoPWMWriter | Support for the generation of PWM signals. For the standard Arduino functionality we use on fixed frequency (defined in the constructor). If you use this API you can define separate frequencies per slice by creating separate instances |
| Cpico_arduino::PinSetupADC | Pin Initialization for ADC |
| Cpico_arduino::PinSetupGPIO | Pin Initialization for GPIO |
| Cpico_arduino::PIOManager | The PIO subsystem on RP2040 allows you to write small, simple programs for what are called PIO state machines, of which RP2040 has eight split across two PIO instances. A state machine is responsible for setting and reading one or more GPIOs, buffering data to or from the processor (or RP2040’s ultra-fast DMA subsystem), and notifying the processor, via IRQ or polling, when data or attention is needed |
| Carduino::PluggableUSB_ | |
| Carduino::PluggableUSBModule | |
| ▼Carduino::Print | |
| Carduino::Server | |
| ▼Carduino::Stream | |
| Carduino::Client | |
| ▼Carduino::HardwareI2C | |
| Cpico_arduino::PicoHardwareI2C | Arduino I2C implementation using the Pico functionality. In Arduino we can read and write individal characters wheresease in Pico the operations have to be done with arrays. We therefore create a read and write buffer to cache the operations |
| ▼Carduino::HardwareSerial | |
| Cpico_arduino::PicoSerialUART | Serial Stream for a defined UART. By default we use the following pins: UART0 tx/rx = gp0/gp1; UART1 tx/rx = gp4/gp5; |
| Cpico_arduino::PicoSerialUSB | PicoUSBSerial is using the pico USB output. It is mapped to the Arduino Serial variable |
| Carduino::UDP | |
| Cpico_arduino::SoftwareSerial | Software Serial Arduino Stream which uses the Pico PIO |
| ▼Carduino::Printable | |
| Carduino::IPAddress | |
| Cpico_arduino::Queue< T > | Construct a new Pico Queue object |
| Cpico_arduino::Queue< T * > | |
| Cpico_arduino::Semaphore | Pico Semaphore which might be useful if you use the 2 processors (e.g. with the Thread class) |
| CSerialDAC | If your Microcontroller does not provide a dedicated analog output you can use the serial output instead as a poor man's work around. The idea is based on the fact that the output of 0b0 leads to 0 Volt on the signal line and the output of 0b1111111111111111 leads to 3.3V |
| Cpico_arduino::Servo | We provide an alternative Pico implementation for the Servo class which is compatible with the Arduino Servo library |
| Carduino::SPISettings | |
| ▼Cpico_arduino::StreamPrintf | Support for Serial.printf. The maximum printable length is defined by PRINTF_BUFFER_SIZE which is set to 512 by default |
| Cpico_arduino::PicoSerialUART | Serial Stream for a defined UART. By default we use the following pins: UART0 tx/rx = gp0/gp1; UART1 tx/rx = gp4/gp5; |
| Cpico_arduino::PicoSerialUSB | PicoUSBSerial is using the pico USB output. It is mapped to the Arduino Serial variable |
| Cpico_arduino::SoftwareSerial | Software Serial Arduino Stream which uses the Pico PIO |
| Cpico_arduino::Thread | Adds support for running code on the second processor core (core1) |
| Cpico_arduino::TimerAlarm | Alarm functions for scheduling future execution |
| Cpico_arduino::TimerAlarmRepeating | Repeating Timer functions for simple scheduling of repeated execution |
| Cpico_arduino::Vector< T > | Vector implementation which provides the most important methods as defined by std::vector. This is neither part of Pico nor of the Arduino framwork but nevertheless it is quite handy to have and most of the times quite better then dealing with raw c arrays |
| Cpico_arduino::Vector< pico_arduino::Map::MapEntry< K, V > > | |
