ctbk/artnetonice
1
0
Fork 0
Code Issues Pull requests Activity

Art-Net Platform.io Zeugs geaddet

Browse source
This commit is contained in:
Patrick Schwarz 2020-01-03 22:11:47 +01:00
parent 70a4c4abcb
commit 987d44190d
9 changed files with 428 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

52
.gitignore vendored
View file

@ -1,52 +0,0 @@
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
*.cmd
.tmp_versions/
modules.order
Module.symvers
Mkfile.old
dkms.conf

5
nano_artnet_ws2812/.gitignore vendored Normal file
View file

@ -0,0 +1,5 @@
.pio
.vscode/.browse.c_cpp.db*
.vscode/c_cpp_properties.json
.vscode/launch.json
.vscode/ipch

67
nano_artnet_ws2812/.travis.yml Normal file
View file

@ -0,0 +1,67 @@
# Continuous Integration (CI) is the practice, in software
# engineering, of merging all developer working copies with a shared mainline
# several times a day < https://docs.platformio.org/page/ci/index.html >
#
# Documentation:
#
# * Travis CI Embedded Builds with PlatformIO
# < https://docs.travis-ci.com/user/integration/platformio/ >
#
# * PlatformIO integration with Travis CI
# < https://docs.platformio.org/page/ci/travis.html >
#
# * User Guide for `platformio ci` command
# < https://docs.platformio.org/page/userguide/cmd_ci.html >
#
#
# Please choose one of the following templates (proposed below) and uncomment
# it (remove "# " before each line) or use own configuration according to the
# Travis CI documentation (see above).
#
#
# Template #1: General project. Test it using existing `platformio.ini`.
#
# language: python
# python:
# - "2.7"
#
# sudo: false
# cache:
# directories:
# - "~/.platformio"
#
# install:
# - pip install -U platformio
# - platformio update
#
# script:
# - platformio run
#
# Template #2: The project is intended to be used as a library with examples.
#
# language: python
# python:
# - "2.7"
#
# sudo: false
# cache:
# directories:
# - "~/.platformio"
#
# env:
# - PLATFORMIO_CI_SRC=path/to/test/file.c
# - PLATFORMIO_CI_SRC=examples/file.ino
# - PLATFORMIO_CI_SRC=path/to/test/directory
#
# install:
# - pip install -U platformio
# - platformio update
#
# script:
# - platformio ci --lib="." --board=ID_1 --board=ID_2 --board=ID_N

7
nano_artnet_ws2812/.vscode/extensions.json vendored Normal file
View file

@ -0,0 +1,7 @@
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
]
}

39
nano_artnet_ws2812/include/README Normal file
View file

@ -0,0 +1,39 @@
This directory is intended for project header files.
A header file is a file containing C declarations and macro definitions
to be shared between several project source files. You request the use of a
header file in your project source file (C, C++, etc) located in `src` folder
by including it, with the C preprocessing directive `#include'.
```src/main.c
#include "header.h"
int main (void)
{
...
}
```
Including a header file produces the same results as copying the header file
into each source file that needs it. Such copying would be time-consuming
and error-prone. With a header file, the related declarations appear
in only one place. If they need to be changed, they can be changed in one
place, and programs that include the header file will automatically use the
new version when next recompiled. The header file eliminates the labor of
finding and changing all the copies as well as the risk that a failure to
find one copy will result in inconsistencies within a program.
In C, the usual convention is to give header files names that end with `.h'.
It is most portable to use only letters, digits, dashes, and underscores in
header file names, and at most one dot.
Read more about using header files in official GCC documentation:
* Include Syntax
* Include Operation
* Once-Only Headers
* Computed Includes
https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

46
nano_artnet_ws2812/lib/README Normal file
View file

@ -0,0 +1,46 @@
This directory is intended for project specific (private) libraries.
PlatformIO will compile them to static libraries and link into executable file.
The source code of each library should be placed in a an own separate directory
("lib/your_library_name/[here are source files]").
For example, see a structure of the following two libraries `Foo` and `Bar`:
|--lib
| |
| |--Bar
| | |--docs
| | |--examples
| | |--src
| | |- Bar.c
| | |- Bar.h
| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
| |
| |--Foo
| | |- Foo.c
| | |- Foo.h
| |
| |- README --> THIS FILE
|
|- platformio.ini
|--src
|- main.c
and a contents of `src/main.c`:
```
#include <Foo.h>
#include <Bar.h>
int main (void)
{
...
}
```
PlatformIO Library Dependency Finder will find automatically dependent
libraries scanning project source files.
More information about PlatformIO Library Dependency Finder
- https://docs.platformio.org/page/librarymanager/ldf.html

20
nano_artnet_ws2812/platformio.ini Normal file
View file

@ -0,0 +1,20 @@
;PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:nanoatmega328]
platform = atmelavr
board = nanoatmega328
framework = arduino
; To avoid red dot flickering
build_flags = -O1
build_unflags = -Os
lib_deps = UIPEthernet, ArtNode, FastLED

233
nano_artnet_ws2812/src/main.cpp Normal file
View file

@ -0,0 +1,233 @@
#include <Arduino.h>
#include <FastLED.h>
#include <UIPEthernet.h>
#include <ArtNode.h>
////////////////////////////////////////////////////////////
ArtConfig config = {
.mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}, // MAC
.ip = {10, 0, 0, 85}, // IP
.mask = {255, 255, 255, 0}, // Subnet mask
.udpPort = 0x1936,
.dhcp = false,
.net = 0, // Net (0-127)
.subnet = 0, // Subnet (0-15)
"NanoNode", // Short name
"NanoNode", // Long name
.numPorts = 1,
.portTypes = {
PortTypeDmx | PortTypeOutput},
.portAddrIn = {0}, // Port input universes (0-15)
.portAddrOut = {0}, // Port output universes (0-15)
.verHi = 0,
.verLo = 1
};
////////////////////////////////////////////////////////////
IPAddress gateway(config.ip[0], config.ip[1], config.ip[2], 1);
EthernetUDP udp;
byte buffer[530];
ArtNode node = ArtNode(config, sizeof(buffer), buffer);
// How many leds are in the strip?
#define NUM_LEDS 60
// Data pin that led data will be written out over
#define DATA_PIN 2
// This is an array of leds. One item for each led in your strip.
CRGB leds[NUM_LEDS];
// Standby fade
uint8_t hue = 0;
uint8_t standby = 0; // seconds to change to standby lighting
// Standby fade functions
void rainbow()
{
// FastLED's built-in rainbow generator
fill_rainbow( leds, NUM_LEDS, hue, 7);
}
void addGlitter( fract8 chanceOfGlitter)
{
if( random8() < chanceOfGlitter) {
leds[ random16(NUM_LEDS) ] += CRGB::White;
}
}
void rainbowWithGlitter()
{
// built-in FastLED rainbow, plus some random sparkly glitter
rainbow();
addGlitter(80);
}
void confetti()
{
// random colored speckles that blink in and fade smoothly
fadeToBlackBy( leds, NUM_LEDS, 10);
int pos = random16(NUM_LEDS);
leds[pos] += CHSV( hue + random8(64), 200, 255);
}
void sinelon()
{
// a colored dot sweeping back and forth, with fading trails
fadeToBlackBy( leds, NUM_LEDS, 20);
int pos = beatsin16( 13, 0, NUM_LEDS-1 );
leds[pos] += CHSV( hue, 255, 192);
}
// Modify for DHCP
/*volatile unsigned char localip[4];
ArtPollReply * ArtNode::createPollReply() {
ArtPollReply *reply = (ArtPollReply*)buffer;
memset(buffer, 0, sizeof(ArtPollReply));
setPacketHeader();
reply->OpCode = OpPollReply;
memcpy(reply->BoxAddr.IP, localip, 4);
reply->BoxAddr.Port = config->udpPort;
reply->VersionInfoHi = config->verHi;
reply->VersionInfoLo = config->verLo;
reply->NetSwitch = config->net;
reply->SubSwitch = config->subnet;
strcpy((char*)reply->ShortName, config->shortName);
strcpy((char*)reply->LongName, config->longName);
reply->NumPortsLo = config->numPorts;
memcpy(reply->PortTypes, config->portTypes, 4);
memset(reply->GoodInput, 0x8, config->numPorts); // Input disabled
memset(reply->GoodOutput, 0x80, config->numPorts); // Very important for MadMapper!
memcpy(reply->SwIn, config->portAddrIn, 4);
memcpy(reply->SwOut, config->portAddrOut, 4);
reply->Style = StyleNode;
memcpy(reply->Mac, config->mac, 6);
reply->Status2 = 0x8; // Supports 15bit address (ArtNet 3)
memcpy(reply->BindIp, config->ip, 4);
packetSize = sizeof(ArtPollReply);
return reply;
}*/
void setup() {
// Wait a little bit for recovery
delay(3000);
// Init WS2812 out and limit current
//FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip); // initializes LED strip
FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip); // initializes LED strip
FastLED.setBrightness(0);// blackout
set_max_power_in_volts_and_milliamps(5, 300);
// Init Art-Net
// DHCP?
Ethernet.begin(config.mac, config.ip, gateway, gateway, config.mask);
//Ethernet.begin(config.mac);
udp.begin(config.udpPort);
} // setup
// loop through the rainbow colors
void loop() {
// Test DHCP localip
//localip = Ethernet.localIP();
// send the 'leds' array out to the actual LED strip
//FastLED.delay(1000/120);
FastLED.show();
// Standby Animation
if (standby == 0) {
// insert a delay to keep the framerate modest
FastLED.delay(1000/120);
// do some periodic updates
EVERY_N_MILLISECONDS( 50 ) {
// slowly cycle the "base color" through the rainbow
hue++;
// Fade in
if(FastLED.getBrightness() < 100) {
FastLED.setBrightness((FastLED.getBrightness() + 1));
}
}
rainbow();
//rainbowWithGlitter();
//sinelon();
//confetti();
} else {
// Countdown to standby
EVERY_N_SECONDS(1) {
standby--;
}
}
while (udp.parsePacket()) {
standby = 10;
if(FastLED.getBrightness() < 100) {
FastLED.setBrightness(100);
}
int n = udp.read(buffer, min(udp.available(), sizeof(buffer)));
if (n >= sizeof(ArtHeader) && node.isPacketValid()) {
// Package Op-Code determines type of packet
switch (node.getOpCode()) {
// Poll packet. Send poll reply.
/*case OpPoll: {
//ArtPoll* poll = (ArtPoll*)buffer;
node.createPollReply();
udp.beginPacket(node.broadcastIP(), config.udpPort);
udp.write(buffer, sizeof(ArtPollReply));
udp.endPacket();
} break;*/
// DMX packet
case OpDmx: {
ArtDmx* dmx = (ArtDmx*)buffer;
//int port = node.getPort(dmx->Net, dmx->SubUni);
//int len = dmx->getLength();
byte *data = dmx->Data;
//if (port == 0 ) { //&& len >= (NUM_LEDS * 3)
//FastLED.setBrightness(100);// global brightness
// read recent DMX values and set levels
for(int LedDot = 0; LedDot < NUM_LEDS; LedDot++) {
int DMXStartAddress = LedDot * 3;
leds[LedDot] = CRGB(data[DMXStartAddress],data[(DMXStartAddress + 1)],data[(DMXStartAddress + 2)]);
}
// Brightness set on Channel 512
// ToDo
//}
} break;
default:
break;
}
}
}
} // loop

11
nano_artnet_ws2812/test/README Normal file
View file

@ -0,0 +1,11 @@
This directory is intended for PIO Unit Testing and project tests.
Unit Testing is a software testing method by which individual units of
source code, sets of one or more MCU program modules together with associated
control data, usage procedures, and operating procedures, are tested to
determine whether they are fit for use. Unit testing finds problems early
in the development cycle.
More information about PIO Unit Testing:
- https://docs.platformio.org/page/plus/unit-testing.html