Unable to get spi1 working on PICO

Other Hardware 3rd Party Boards
1

I am trying to use SPI1 on an Raspberry Pi PICO. SPI0 works fine, but I need SPI1 work. I have tried changing the pins around with no success. Please see code below and thank you for your at:tention:

#include <SPI.h>

#include <DW1000Ranging.h>




// Define the pins you are using for your DW1000 module's chip select (CS) and interrupt (IRQ)

const uint8_t PIN_SS = 13; // Example: GPIO 13 for CS (you can choose any available GPIO)

//const uint8_t PIN_IRQ = 14; // Example: GPIO 14 for IRQ (check your module's pinout)

// connection pins

const uint8_t PIN_RST = 9; // reset pin

const uint8_t PIN_IRQ = 2; // irq pin

//const uint8_t PIN_SS = SS; // spi select pin

void setup() {

Serial.begin(9600);

while (!Serial) delay(100);

SPI.begin();

  // --- Configure SPI1 on RPi Pico ---

SPI1.setRX(12);   // MISO on GPIO 12

SPI1.setCS(13);   // CS on GPIO 13 (library will manage this, but good practice to set)

SPI1.setSCK(10);  // SCK on GPIO 10

SPI1.setTX(11);   // MOSI on GPIO 11

SPI1.begin(); // Initialize SPI1 bus

delay(333);

pinMode(13,OUTPUT);

digitalWrite(13, HIGH);

DW1000Ranging.initCommunication(PIN_RST, PIN_SS, PIN_IRQ); //Reset, CS, IRQ pin

  //define the sketch as anchor. It will be great to dynamically change the type of module

DW1000Ranging.attachNewRange(newRange);

DW1000Ranging.attachBlinkDevice(newBlink);

DW1000Ranging.attachInactiveDevice(inactiveDevice);

  //Enable the filter to smooth the distance

  //DW1000Ranging.useRangeFilter(true);

  //we start the module as an anchor

DW1000Ranging.startAsAnchor("82:17:5B:D5:A9:9A:E2:9C", DW1000.MODE_LONGDATA_RANGE_ACCURACY);

//delay(333);

  }




void loop() {

  // Your ranging loop code here

DW1000Ranging.loop();

}




void newRange() {

Serial.print("from: "); 

Serial.print(DW1000Ranging.getDistantDevice()->getShortAddress(), HEX);

Serial.print("\t Range: "); 

Serial.print(DW1000Ranging.getDistantDevice()->getRange()); 

Serial.print(" m");

Serial.print("\t RX power: "); 

Serial.print(DW1000Ranging.getDistantDevice()->getRXPower()); 

Serial.println(" dBm");

}




void newBlink(DW1000Device* device) {

Serial.print("blink; 1 device added ! -> ");

Serial.print(" short:");

Serial.println(device->getShortAddress(), HEX);

}




void inactiveDevice(DW1000Device* device) {

Serial.print("delete inactive device: ");

Serial.println(device->getShortAddress(), HEX);

}
2

Doesn't work is not something we can work with. How do you know that? We need you to post the error information without interpretation, just show us what you see. Use code tags as well. BTW, next time you post code, get rid of all the unnecessary vertical white space and maybe run Tools/AutoFormat.

3

I've moved your topic to a category that is more suitable for your question.

4

The results of 30 seconds of looking in the DW1000 library:

Project state

Development: There is no active development by the owner thotro.

This library is currently (2019) not actively maintained.

The library code is hard coded to use SPI. There is no obvious mechanism to use a different SPI bus.

You can draw your own conclusions.

5

Was wondering whether the library can actually access SPA1.

6

Thanks for your reply and my apologies. There are no error messages unfortunately. The DWM1000 anchor just does not interact with the tag when assigned to SPI1. It works fine when assigned to SPI0. Some peripherals libraries it seems don’t support SPI1.

7

True, I am trying to get my ENC28J60 Ethernet controller to operate on SPI1, but am running into challenges there too. I am wondering of I should change to another Ethernet controller. Thanks for your input.

8

It probably doesn’t. I need to find an Ethernet controller that does work on SPI1. I am finding challenges to get the ENC28J60 to do that. Should the ENC28J60 libraries may not support SPI1, would love to hear comments about alternative controllers. Thank you!

9

The story seems to be changing.

Is your problem that the Ethernet controller library doesn't want to work on SPI1, or is the DW1000 library?

As a data point, I have had zero problems with SPI1 on the Pico, and that's after 4 projects using it.

10

I am adding to the story, not changing it. I am trying to get something to work on SPI1, so that the DWM1000 can operate on SPI0. ENC28J60 libraries may not support SPI1 operation either, so I am going to look at using W5500 instead. I have no misgivings about the PICO board as of yet.

11

I'm going to take your topic literally. So here's an example of SPI1 working perfectly well on a Pico. Complete code and a picture of the wired circuit are provided below.

#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &SPI1, /*DC*/ 16, /*RST*/ 17, /*CS*/ 13);

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

   SPI1.setSCK(10);
   SPI1.setTX(11);
   SPI1.setRX(12);
   SPI1.setCS(13);

   if( !display.begin(SSD1306_SWITCHCAPVCC) ) {
      Serial.println(F("SSD1306 allocation failed"));
      while( true ) {
         digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
         delay(250);
      }
   }

   display.clearDisplay();
   display.setRotation(0);
   display.setTextSize(2);
   display.setTextColor(SSD1306_WHITE);
   display.setCursor(0, 0);
   display.println(F("SPI1 on"));
   display.println(F("Pico"));
   display.println(F("working."));
   display.display();
}

void loop() {
}

SPI1 on Pico working
SPI1 on Pico working682×400 99.4 KB

Adding is changing. Good luck figuring your issue out.

12

Why do you need to use a different SPI interfaces for your DWM1000 and Ethernet module? Do you know that SPI is a bus and you can connect a multiple modules to the single SPI interface?

13

I appreciate your input. As per your advice, II am abandoning the SPI0 and SPI1 attempt. I am trying to get the DW1000 radio and WizNet W5500 Ethernet controller to share SPI0. Both SPI devices work fine independently. Together I get no Compiler errors and no radio or Ethernet data. Please see code below, thank you!

#include <SPI.h>
#include <Ethernet2.h>
#include <EthernetUdp2.h>
// connection pins#define SHIELD_TYPE  USING_W5500 // or USING_W5100, USING_W5200, etc.
#include "DW1000.h"
#include "DW1000Ranging.h"
const int ETH_CS_PIN = 22;
///////////////////////////////////
SPISettings dw1000set(20000000,MSBFIRST,SPI_MODE0);
SPISettings w5500set(20000000,MSBFIRST,SPI_MODE0);
const uint8_t PIN_RST = 9; // reset pin
const uint8_t PIN_IRQ = 2; // irq pin
const uint8_t PIN_SS = SS; // spi select pin
/////////////////////
volatile boolean received = false;
volatile boolean error = false;
volatile int16_t numReceived = 0; // todo check int type
String message;
int deviceAddress;
int x = 0;
////////////////////////
// Enter a MAC address and IP address
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 10, 177);
IPAddress remote(192, 168, 10, 129);
unsigned int localPort = 8888; // local port to listen on
unsigned int remotePort = 8888;
EthernetUDP Udp;
//////////////////////
void setup() {//////////////////////////////////////////////////////////////
Serial.begin(9600);
delay(1000);
SPI.setSCK(18);///SLK
SPI.setTX(19); // MOSI
SPI.setRX(16); // MISO
SPI.begin(true);
pinMode(PIN_SS,OUTPUT);
digitalWriteFast(PIN_SS, HIGH);
pinMode(ETH_CS_PIN,OUTPUT);
digitalWriteFast(ETH_CS_PIN, HIGH);
//DW1000.newConfiguration();
messageSetup();
delay(1000);
//init the configuration
DW1000Ranging.initCommunication(PIN_RST, PIN_SS, PIN_IRQ); //Reset, CS, IRQ pin
//define the sketch as anchor. It will be great to dynamically change the type of module
DW1000Ranging.attachNewRange(newRange);
DW1000Ranging.attachNewDevice(newDevice);
DW1000Ranging.attachInactiveDevice(inactiveDevice);
//Enable the filter to smooth the distance
//DW1000Ranging.useRangeFilter(true);

//we start the module as a tag
DW1000Ranging.startAsAnchor("9C:00:22:EA:82:60:3B:7D", DW1000.MODE_LONGDATA_RANGE_ACCURACY);
delay(100);
/////////////////////////////////////////////
//while (!Serial);
Ethernet.init(ETH_CS_PIN);
Ethernet.begin(mac, ip);
Udp.begin(localPort);
Serial.print("IP: ");
Serial.println(Ethernet.localIP());
delay(100);
/////////////////////////////////////////////////////////////////////////
}
void loop() {
DW1000Ranging.loop(); 
if(x==133000){
messageReceived();
x = -133000;
}else{
//DW1000Ranging.loop();
x++;
} 
}
void newRange() {
SPI.beginTransaction(dw1000set);
digitalWriteFast(PIN_SS, LOW);
Serial.print("from: ");
Serial.print(DW1000Ranging.getDistantDevice()->getShortAddress(), HEX);
deviceAddress = (DW1000Ranging.getDistantDevice()->getShortAddress(), HEX);
Serial.print("\t Range: ");
Serial.print(DW1000Ranging.getDistantDevice()->getRange());
Serial.print(" m");
Serial.print("\t RX power: ");
Serial.print(DW1000Ranging.getDistantDevice()->getRXPower());
Serial.println(" dBm");
digitalWriteFast(PIN_SS, HIGH);
SPI.endTransaction();
delay(1000);
///SPI SWITCH//////////////////////////////////////
SPI.beginTransaction(w5500set);
digitalWriteFast(ETH_CS_PIN, LOW);
Udp.beginPacket(remote, remotePort);
Udp.write(deviceAddress);
Udp.write(DW1000Ranging.getDistantDevice()->getRange());
Udp.write(DW1000Ranging.getDistantDevice()->getRXPower());
Udp.endPacket();
digitalWriteFast(ETH_CS_PIN, HIGH);
SPI.endTransaction();
delay(1000);
}//////////////////////////////////////////////////////
void newDevice(DW1000Device device) {
SPI.beginTransaction(dw1000set);
digitalWriteFast(PIN_SS, LOW);
Serial.print("ranging init; 1 device added ! -> ");
Serial.print(" short:");
Serial.println(device->getShortAddress(), HEX);
int addedDevice = (device->getShortAddress(), HEX);
SPI.endTransaction();
digitalWriteFast(PIN_SS, HIGH);
/////////////////////////
SPI.beginTransaction(w5500set);
digitalWriteFast(ETH_CS_PIN, LOW);
Udp.beginPacket(remote, remotePort);
Udp.write(deviceAddress);
Udp.write(addedDevice);
Udp.endPacket();
SPI.endTransaction();
digitalWriteFast(ETH_CS_PIN, HIGH);
/////////////////////////
}
void inactiveDevice(DW1000Device* device) {
SPI.beginTransaction(dw1000set);
digitalWriteFast(PIN_SS, LOW);
Serial.print("delete inactive device: ");
Serial.println(device->getShortAddress(), HEX);
int inactiveDevice = (device->getShortAddress(), HEX);
digitalWriteFast(PIN_SS, HIGH);
SPI.endTransaction();
/////////////////////////
SPI.beginTransaction(w5500set);
digitalWriteFast(ETH_CS_PIN, LOW);
Udp.beginPacket(remote, remotePort);
Udp.write(deviceAddress);
Udp.write(inactiveDevice);
Udp.endPacket();
SPI.endTransaction();
digitalWriteFast(ETH_CS_PIN, HIGH);
/////////////////////////
}
void messageSetup(){///////////////////////////////////////////////////////
Serial.println(F("### DW1000-arduino-receiver-test ###"));
// initialize the driver
DW1000.begin(PIN_IRQ, PIN_RST);
DW1000.select(PIN_SS);
Serial.println(F("DW1000 initialized ..."));
// general configuration
DW1000.newConfiguration();//////
DW1000.setDefaults();
DW1000.setDeviceAddress(6);
DW1000.setNetworkId(10);
// DW1000.enableMode(DW1000.MODE_LONGDATA_RANGE_LOWPOWER);
DW1000.commitConfiguration();
Serial.println(F("Committed configuration ..."));
// DEBUG chip info and registers pretty printed
char msg[128];
DW1000.getPrintableDeviceIdentifier(msg);
Serial.print("Device ID: "); Serial.println(msg);
DW1000.getPrintableExtendedUniqueIdentifier(msg);
Serial.print("Unique ID: "); Serial.println(msg);
DW1000.getPrintableNetworkIdAndShortAddress(msg);
Serial.print("Network ID & Device Address: ");
Serial.println(msg);
DW1000.getPrintableDeviceMode(msg);
Serial.print("Device mode: "); Serial.println(msg);
// attach callback for (successfully) received messages
delay(100);
DW1000.attachReceivedHandler(handleReceived);/////////
delay(100);
DW1000.attachReceiveFailedHandler(handleError);
delay(100);
DW1000.attachErrorHandler(handleError);
// start reception
delay(10000);
receiver();
}///////////////////////////////////////////////////////////////////////////
void handleReceived() {
// status change on reception success
received = true;
}
void handleError() {
error = true;
}
void receiver() {
DW1000.newReceive();
DW1000.setDefaults();
// so we don't need to restart the receiver manually
DW1000.receivePermanently(true);
DW1000.startReceive();
}
void messageReceived(){
SPI.beginTransaction(dw1000set);
digitalWriteFast(PIN_SS, LOW);
Serial.println("");
Serial.println("/////////");
DW1000.getData(message);
Serial.println(message);
Serial.println("/////////");
Serial.println("");
received = false;
SPI.endTransaction();
digitalWriteFast(PIN_SS, HIGH);
}
14

I added to the explanation.