tinygo-org / pio Goto Github PK

View Code? Open in Web Editor NEW

17.0 17.0 0.0 166 KB

Programmable I/O API for RP2040.

License: BSD 3-Clause "New" or "Revised" License

Go 100.00%

pio's People

Contributors

Stargazers

Watchers

pio's Issues

hub75 support

It would be really great to implement HUB75 support like what this does https://github.com/raspberrypi/pico-examples/blob/master/pio/hub75/Readme.md

What I'd really like to do is have a PIO implementation that is the same interface as https://github.com/aykevl/things/blob/master/hub75/driver.go

Changing any .pio code in any example and running go generate will encounter the dependency of a special version of pioasm which is not mentioned in the readme but available at @soypat 's fork of pico-sdk on the pioasm-go branch.

However, there are errors compiling pioasm on that branch. The following code should address those issues.

==> pio_disassembler.cpp <==
/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include <array>
#include <sstream>
#include <iomanip>
#include "pio_disassembler.h"

extern "C" void disassemble(char *buf, int buf_len, uint16_t inst, unsigned int sideset_bits, bool sideset_opt) {
    if (buf_len) buf[disassemble(inst, sideset_bits, sideset_opt).copy(buf, buf_len - 1)] = 0;
}

std::string disassemble(uint16_t inst, unsigned int sideset_bits_including_opt, bool sideset_opt) {
    std::stringstream ss;
    unsigned int major = inst >> 13u;
    unsigned int arg1 = ((unsigned int) inst >> 5u) & 0x7u;
    unsigned int arg2 = inst & 0x1fu;
    auto op = [&](const std::string &s) {
        ss << std::left << std::setw(7) << s;
    };
    auto op_guts = [&](const std::string &s) {
        ss << std::left << std::setw(16) << s;
    };

    bool invalid = false;
    switch (major) {
        case 0b000: {
            static std::array<std::string, 8> conditions{"", "!x, ", "x--, ", "!y, ", "y--, ", "x != y, ", "pin, ",
                                                         "!osre, "};
            op("jmp");
            op_guts(conditions[arg1] + std::to_string(arg2));
            break;
        }
        case 0b001: {
            unsigned int source = arg1 & 3u;
            std::string guts;
            switch (source) {
                case 0b00:
                    guts = "gpio, " + std::to_string(arg2);
                    break;
                case 0b01:
                    guts = "pin, " + std::to_string(arg2);
                    break;
                case 0b10:
                    if (arg2 & 0x8u) {
                        invalid = true;
                    } else {
                        guts = "irq, " + std::to_string(arg2 & 7u);
                        if (arg2 & 0x10u) {
                            guts += " rel";
                        }
                    }
                    break;
            }
            if (!invalid) {
                guts = ((arg1 & 4u) ? "1 " : "0 ") + guts;
                op("wait");
                op_guts(guts);
            }
            break;
        }
        case 0b010: {
            static std::array<std::string, 8> sources { "pins", "x", "y", "null", "", "status", "isr", "osr"};
            std::string source = sources[arg1];
            if (source.empty()) {
                invalid = true;
            } else {
                op("in");
                op_guts(source + ", " + std::to_string(arg2 ? arg2 : 32));
            }
            break;
        }
        case 0b011: {
            static std::array<std::string, 8> dests { "pins", "x", "y", "null", "pindirs", "pc", "isr", "exec"};
            op("out");
            op_guts(dests[arg1] + ", " + std::to_string(arg2 ? arg2 : 32));
            break;
        }
        case 0b100: {
            if (arg2) {
                invalid = true;
            } else {
                std::string guts = "";
                if (arg1 & 4u) {
                    op("pull");
                    if (arg1 & 2u) guts = "ifempty ";
                } else {
                    op("push");
                    if (arg1 & 2u) guts = "iffull ";
                }
                guts += (arg1 & 0x1u) ? "block" : "noblock";
                op_guts(guts);
            }
            break;
        }
        case 0b101: {
            static std::array<std::string, 8> dests { "pins", "x", "y", "", "exec", "pc", "isr", "osr"};
            static std::array<std::string, 8> sources { "pins", "x", "y", "null", "", "status", "isr", "osr"};
            std::string dest = dests[arg1];
            std::string source = sources[arg2 & 7u];
            unsigned int operation = arg2 >> 3u;
            if (source.empty() || dest.empty() || operation == 3) {
                invalid = true;
            }
            if (dest == source && !operation && (arg1 == 1 || arg2 == 2)) {
                op("nop");
                op_guts("");
            } else {
                op("mov");
                std::string guts = dest + ", ";
                if (operation == 1) {
                    guts += "!";
                } else if (operation == 2) {
                    guts += "::";
                }
                guts += source;
                op_guts(guts);
            }
            break;
        }
        case 0b110: {
            if ((arg1 & 0x4u) || (arg2 & 0x8u)) {
                invalid = true;
            } else {
                op("irq");
                std::string guts;
                if (arg1 & 0x2u) {
                    guts += "clear ";
                } else if (arg1 & 0x1u) {
                    guts += "wait ";
                } else {
                    guts += "nowait ";
                }
                guts += std::to_string(arg2 & 7u);
                if (arg2 & 0x10u) {
                    guts += " rel";
                }
                op_guts(guts);
            }
            break;
        }
        case 0b111: {
            static std::array<std::string, 8> dests{"pins", "x", "y", "", "pindirs", "", "", ""};
            std::string dest = dests[arg1];
            if (dest.empty()) {
                invalid = true;
            } else {
                op("set");
                op_guts(dests[arg1] + ", " + std::to_string(arg2));
            }
            break;
        }
    }
    if (invalid) {
        return "reserved";
    }
    unsigned int delay = ((unsigned int) inst >> 8u) & 0x1f;
    ss << std::left << std::setw(7);
    if (sideset_bits_including_opt && (!sideset_opt || (delay & 0x10u))) {
        ss << ("side "+ std::to_string((delay & (sideset_opt ? 0xfu : 0x1fu)) >> (5u - sideset_bits_including_opt)));
    } else {
        ss << "";
    }
    delay &= ((1u << (5 - sideset_bits_including_opt)) - 1u);
    ss << std::left << std::setw(4) << (delay ? ("[" + std::to_string(delay) + "]") : "");
    return ss.str();
}

==> pio_disassembler.h <==
/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef _PIO_DISASSEMBLER_H
#define _PIO_DISASSEMBLER_H

#ifdef __cplusplus
#include <cstdint>
#include <string>

typedef unsigned int uint;

std::string disassemble(uint16_t inst, uint sideset_bits, bool sideset_opt);
extern "C" void disassemble(char *buf, int buf_len, uint16_t inst, uint sideset_bits, bool sideset_opt);

#else
#include <stdint.h>

void disassemble(char *buf, int buf_len, uint16_t inst, unsigned int sideset_bits, bool sideset_opt);

#endif

#endif

Perhaps a readme in the examples dir could be added to explain this aspect of the library's usage, for those who are not already otherwise familiar with or using the pico-sdk

RP2040 datasheet - link correction

The correct page of the PIO chapter of the RP2040 data sheet is 309. But with this link you can go directly to the page.
https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf#page=310

should the examples work? SetPindirsConsecutive instead of SetConsuecutivePindirs???

I'm struggling to get the examples to work. I changed line 11 in blink_pio.go to

sm.SetPindirsConsecutive(pin, 1, true)

and I got it to work. I suspect the API morphed after the examples were written?

PICO PIO testing with WS2812B

Congratulations Patricio! I've already managed to do some tests on the Raspberry Pico with the WS281B example. Thank you.
https://github.com/tinygo-org/pio/tree/main/rp2-pio/examples/ws2812

But I found some things that need correction or change.

ws, err := piolib.NewWS2812(sm, ws2812Pin, 16000000)

This function lacked the definition of the Baud rate.
Through testing, I discovered the frequency of 16MHz (maybe it is based on Arduino?).
func NewWS2812(sm pio.StateMachine, pin machine.Pin, baud uint32) (*WS2812, error)

The color sequence appears to be incorrect.
Based on the WS2812B datasheet, we can verify that the color sequence in the 24 bits is green-red-blue and not RGB.
https://cdn-shop.adafruit.com/datasheets/WS2812.pdf

https://github.com/tinygo-org/pio/blob/main/rp2-pio/piolib/ws2812.go

func (ws *WS2812) SetRGB(r, g, b uint8) {
	color := uint32(r)<<16 | uint32(g)<<8 | uint32(b)
	println("r", r, "g", g, "b", b)
	ws.sm.TxPut(color)
}

Using DMA channels outside of piolib

I'm trying to port the pico unicorn library to tinygo now that pio is supported but it uses DMA channels in a way that I'm not sure is currently allowed by the piolib package. I don't see anything exported from piolib that allows channels to be claimed and configured. Is DMA only intended to be used internally in piolib or would it be ok to submit a PR to export it?

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.