Arduino.ru

Есть код для управления светодиодами с возможностью установки адреса кнопками и отображения адреса на экране, но в этом коде реализована возможность управления только яркостью, необходимо на дополнительный адрес вписать функцию стробоскопа для всех цветов, например 0 - сторбоскоп выключен 1-255 строб включен и от 1 до 255 регулируется скорость. есть примеры кода со стобоскопом но без возможности установки адреса

вот исходный код:

// Set and display DMX address for Arduino DMX controller
// Read DMX data from DMX address and PWM output
// First = all brightless together (multiplicator)
// 30/01/2013

#include <TM1637.h>                    // display TM1637 lib
#include <EEPROM.h>                    // EEPROM lib
#include <DMXSerial.h>                 // DMX512 lib

TM1637 tm1637(2,4);                    // CLK & DIO input pin from TM1637

#define MODEPIN  7                     // mode input pin
#define UPPIN    8                     // increment DMX address input pin
#define DOWNPIN  12                    // decrement DMX address input pin
#define SETPIN   1                     // set input pin

#define KEYSPEED     200               // buttons action trheshold, ms
#define KEEPDMXDISP  30                // keep DMX address on screen, sec

#define PWM1 3                         // outputs PWM
#define PWM2 5
#define PWM3 6
#define PWM4 9
#define PWM5 10
#define PWM6 11

                                     
boolean       setaddr=false,           // DMX process/set address flag
              btn_up=true,             // button flags
              btn_down=true,
              btn_set=true,
              btn_mode=true;
unsigned long last_btn;                // buttons press timestamps
//              last_disp=millis();      // last screen update timestamp
byte          ticks,                   // movement buttons handled actions
              deltadmx;                // movement step
int           dmxaddr=1,               // DMX address
              mult=0;                  // all channels light multiplicator
uint8_t       dmxh,dmxl;               // EEPROM DMX record
int8_t        brightness=4;            // screen brightness level
                                     
void dmxdisp(){                      
  int tmp;                             // temp
  int8_t digit[3];                     // address output
  tmp=dmxaddr-(dmxaddr%100);
  digit[0]=tmp/100;
  tmp=dmxaddr-(dmxaddr%10)-(digit[0]*100);
  digit[1]=tmp/10;
  digit[2]=dmxaddr-(digit[0]*100)-(digit[1]*10);
  if(setaddr){
    tm1637.display(0,0x0A);            // setup address
    tm1637.display(1,digit[0]);
    tm1637.display(2,digit[1]);
    tm1637.display(3,digit[2]);
  }else{
    tm1637.display(1,digit[0]);        // display address
    tm1637.display(2,digit[1]);
    tm1637.display(3,digit[2]);
  }
}

void processmovestep(){
  ticks++;
  if(ticks>10) deltadmx=10;            // increase step
  if(ticks>20) deltadmx=50;
  if(ticks>30){                        // reset step
    deltadmx=1;
    ticks=0;
  }
  dmxdisp();
}

void setup(){
  pinMode(PWM1,OUTPUT);                // init output pins
  pinMode(PWM2,OUTPUT);
  pinMode(PWM3,OUTPUT);
  pinMode(PWM4,OUTPUT);
  pinMode(PWM5,OUTPUT);
  pinMode(PWM6,OUTPUT);
  pinMode(SETPIN,INPUT_PULLUP);        // init input key pins
  pinMode(MODEPIN,INPUT_PULLUP);
  pinMode(UPPIN,INPUT_PULLUP);
  pinMode(DOWNPIN,INPUT_PULLUP);
  tm1637.init();                       // LDM init
  tm1637.set(brightness);
  DMXSerial.init(DMXReceiver);
  dmxh=EEPROM.read(0x00);              // restore DMX
  dmxl=EEPROM.read(0x01);
  if(dmxh!=0xFF) dmxaddr=(dmxh*256)+dmxl;
  dmxdisp();
}

void loop(){
  if(setaddr){
    if(btn_up && btn_down && btn_set && btn_mode){  // read movement keys from idle mode
      btn_up=digitalRead(UPPIN);
      btn_down=digitalRead(DOWNPIN);
      btn_set=digitalRead(SETPIN);
      btn_mode=digitalRead(MODEPIN);
      last_btn=millis();
      ticks=0;
      deltadmx=1;
      if(!btn_up && !btn_down) btn_down=true;
    }
    if(!btn_mode){                                // back to DMX process mode
      btn_mode=true;                              // change mode
      setaddr=false;
      dmxh=EEPROM.read(0x00);                     // restore DMX
      dmxl=EEPROM.read(0x01);
      if(dmxh!=0xFF) dmxaddr=(dmxh*256)+dmxl;
      tm1637.init();                              // reset screen
      delay(500);
      dmxdisp();
//      last_disp=millis();
    }
    if(!btn_set){                                 // store DMX
      if(dmxaddr>255){
        if(EEPROM.read(0x00)!=0x01) EEPROM.write(0x00,0x01);
        dmxl=dmxaddr-256;
      }else{
        if(EEPROM.read(0x00)!=0x00) EEPROM.write(0x00,0x00);
        dmxl=dmxaddr;
      }
      if(EEPROM.read(0x01)!=dmxl) EEPROM.write(0x01,dmxl);
      btn_set=true;                               // change mode
      setaddr=false;
      tm1637.init();                              // reset screen
      delay(500);
      dmxdisp();
//      last_disp=millis();
    }
    if(!btn_up) btn_up=digitalRead(UPPIN);        // read movement keys from moving mode
    if(!btn_down) btn_down=digitalRead(DOWNPIN);
    if(!btn_up && millis()-last_btn>=KEYSPEED){   // move DMX up
      last_btn=millis();
      dmxaddr+=deltadmx;
      if(dmxaddr>512) dmxaddr=1;
      processmovestep();
    }
    if(!btn_down && millis()-last_btn>=KEYSPEED){ // move DMX down
      last_btn=millis();
      dmxaddr-=deltadmx;
      if(dmxaddr<1) dmxaddr=512;
      processmovestep();
    } 
  }else{
    if(digitalRead(MODEPIN)==0){                 // enter set address mode
      setaddr=true;                              // change mode
      tm1637.init();                             // reset screen
      delay(500);
      dmxdisp();
    }
//    if(millis()-last_disp>=KEEPDMXDISP*1000) tm1637.init(); // clear screen if no buttons pressed
//================= main DMX programm ================================
    mult = DMXSerial.read(dmxaddr);                         // read from DMX
    analogWrite(PWM1,(DMXSerial.read(dmxaddr+1)*mult/256));    // channel 1
    analogWrite(PWM2,(DMXSerial.read(dmxaddr+2)*mult/256));    // channel 2
    analogWrite(PWM3,(DMXSerial.read(dmxaddr+3)*mult/256));    // channel 3
    analogWrite(PWM4,(DMXSerial.read(dmxaddr+4)*mult/256));    // channel 4
//    analogWrite(PWM5,(DMXSerial.read(dmxaddr+5)*mult/256));   // channel 5
//    analogWrite(PWM6,(DMXSerial.read(dmxaddr+6)*mult/256));   // channel 6
//====================================================================
  }
}

а вот код со стробоскопом но без возможности установки адреса и индикации

/*
DMX_LED_Strips
Copyright (c) 2015, Matthew Tong
https://github.com/mtongnz/DMX_LED_Strips
http://www.instructables.com/id/DMX-LED-Strips/
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program.
If not, see http://www.gnu.org/licenses/
  
This sketch takes the DMX input and controls 5 RGB LED strips.
Channel allocation is red, green, blue, strobe for each output (20 channels total).
Strobe:  0-19        off
         20 - 189    slow - fast
         190 - 205   slow random
         206 - 219   fast random
         220 - 255   off
Libraries Used:
  ShiftPWM by Elco Jacobs.    www.elcojacobs.com
  DMXSerial by Mat Hertel.    www.mathertel.de
*/

// ShiftPWM settings
const int ShiftPWM_latchPin=8;
const bool ShiftPWM_invertOutputs = false;
const bool ShiftPWM_balanceLoad = true;

#include <DMXSerial.h>
#include <ShiftPWM.h>

// ShiftPWM settings
unsigned char maxBrightness = 255;
unsigned char pwmFrequency = 125;
unsigned int numRegisters = 2;
unsigned int numOutputs = numRegisters*8;

// Status LED pin
const int statusLEDPin = 5;

// Output settings
const int numRGBS = 5;
const int dmxNumChan = numRGBS * 4;

// DMX address.
const int dmxStartAddr = 1;  // unit 1 & 2 = 61, unit 3 & 4 = 81

// Counter variables
int strobeCount[numRGBS];
int randStrobeCount[numRGBS];
int timerCount;

void setup(){
  int x;

  // Random Seed
  randomSeed(analogRead(0));
  
  // Setup DMX receiver
  DMXSerial.init(DMXReceiver);

  // Setup PWM output
  ShiftPWM.SetAmountOfRegisters(numRegisters);
  ShiftPWM.Start(pwmFrequency,maxBrightness);
  
  // set all channels to 0 default
  ShiftPWM.SetAll(0);
  
  // Setup status LED
  pinMode(statusLEDPin, OUTPUT);
  digitalWrite(statusLEDPin, 1);
  
  // Set counters to zero
  for (x = 0; x < numRGBS; x++) {
    strobeCount[x] = 0;
    randStrobeCount[x] = random(5, 200);
  }
  timerCount = 0;

  //set timer0 interrupt at 200Hz
  cli();                                // disable interupts
  TCCR0A = 0;                           // set entire TCCR0A register to 0
  TCCR0B = 0;                           // same for TCCR0B
  TCNT0  = 0;                           // initialize counter value to 0
  OCR0A = 78;                           // set compare match register for 200hz increments
  TCCR0A |= (1 << WGM01);               // turn on CTC mode
  TCCR0B |= (1 << CS02) | (1 << CS00);  // Set CS02 and CS00 bits for 1024 prescaler
  TIMSK0 |= (1 << OCIE0A);              // enable timer compare interrupt
  sei();                                // enable interupts
}

// Timer0 interupt handler.  Increments all the counters.
ISR(TIMER0_COMPA_vect){
  int x;
  
  for (x = 0; x < numRGBS; x++)
    strobeCount[x]++;
  
  timerCount++;
}

void loop() {
  int x, y, s;
  
  if (timerCount >= 100) {
    // Blink status LED if DMX receiving
    if (DMXSerial.noDataSince() < 1000) {
      digitalWrite(statusLEDPin, digitalRead(statusLEDPin) ^ 1);
      
    //   Turn status LED red if no DMX received
    }else
      digitalWrite(statusLEDPin, 1);
    timerCount = 0;
  }
  
  // Turn off all outputs if we haven't received DMX in 10 seconds
  if (DMXSerial.noDataSince() > 10000)
    ShiftPWM.SetAll(0);
  else {
    // loop through each of the 'y' RGB leds
    for (y = 0; y < numRGBS; y++) {
      s = DMXSerial.read(dmxStartAddr + (y * 4));
      
      //  strobe mode
      if (s > 20 && s <= 220) {
        int t;
        
        // random strobe
        if (s > 190) {
          t = (40 - (s - 190)) * 10;
          s = randStrobeCount[y];
        }

        
        // strobe on
        if (strobeCount[y] >= ( (192 - s) + 5) && strobeCount[y] < 500) {
          for (x = 0; x < 3; x++)
            ShiftPWM.SetOne((y*3) + x, DMXSerial.read(dmxStartAddr + (y * 4) + x + 1));
          strobeCount[y] = 500;
          TCNT0  = 0;  //clear timer
        }
        
        // strobe off
        if (strobeCount[y] >= 501 ) {
          for (x = 0; x < 3; x++)
            ShiftPWM.SetOne((y*3) + x, 0);
          strobeCount[y] = 0;
          
          randStrobeCount[y] = random(1, t);
        }
        
        
      // non strobe mode
      } else {
        strobeCount[y] = 0;
        
        // Get DMX values and set outputs
        for (x = 0; x < 3; x++)
          ShiftPWM.SetOne((y*3) + x, DMXSerial.read(dmxStartAddr + (y * 4) + x + 1));
      }
    }
  }
}

отпишите кто нибудь в лс или сюда https://vk.com/andy.rock

буду благодарен если кто поможет, делаю в основном для себя(работаю светорежиссером и появилось желание внести немного креатива в работу и попробовать собрать пару самодельных девайсов), но могу оплатить вашу работу

так же сам только знакомлюсь с основами програмирования, до этого занимался в основном аналоговым оборудованием(радиолюбитель с 15 летним стажем), поэтому паралелльно ищу человека, который поможет в написании кода под световые приборы, или поможет в освоении языка. уже разобрался как прописывать выходы, перенумеровывать. менять частоту и т.д. но вот пока с такими вещами как вписать стробоскоп или какие то программы переключения в зависимости от адреса пока еще не получается