Windows10 system volume controller

hi,

bit of newbie here in need of advice. updates seem progressing faster i'm learning!

i made frankenstein sketch leonardo control system volume, largely advice posted stefan jones on blog. used remote class , mods core files.

all seemed working intended win7 setup... updated win10. leonardo no longer mounts after rebooting (shows usb com port) , needs resetting before works. read somewhere newer source code should fix this, downloaded latest, recompiled , errors everywhere!

i know code wasn't perfect, , needed rewriting. wondering if there's easier ways of doing now?

all needed pushbutton vol+ vol- , mute (much on extended keyboards, or laptops). rotary volume might better. system volume, not line volume.

searches have failed me. maybe simple!

i can upload code if helps (please dont judge me on though)

i think code got working originally. broke coding rules , conventions wasnt copied , pasted.

code: [select]

// constants
// set pin numbers buttons:
const int downvolume = 2;     
const int mutevolume = 3;       
const int upvolume = 4;
const int = 5;
const int forward = 6;
const int playpause = 7;
const int outpin = 13;       // play/pause led

// long's because time in ms become bigger int.
long debounce = 20;      // debounce in ms
long holdtime = 2000;    // ms hold period: how long wait press+hold event
long time = 0;

// variables
int backval = 0;       // value read button
int backlast = 0;       // buffered value of button's previous state
int forwardval = 0;
int forwardlast = 0;
long btndntime;           // time button pressed down
long btnuptime;           // time button released
boolean ignoreup = false; // whether ignore button release because click+hold triggered
int state = high;      // current state of output pin
int reading;           // current reading input pin
int previous = low;    // previous reading input pin


// initialize buttons' inputs:
void setup()
{
  pinmode(downvolume, input);       
  pinmode(mutevolume, input);       
  pinmode(upvolume, input);
  pinmode(back, input);
  pinmode(forward, input);
  pinmode(playpause, input);
  pinmode(outpin, output);
  digitalwrite(back, low);
  digitalwrite(forward, low);
}


void loop()
{
//**********************rewind , skip back************************
  // read state of button
  backval = digitalread(back);
 
  // test button pressed , store down time
  if (backval == high && backlast == low && (millis() - btnuptime) > debounce)
  {
    btndntime = millis();
  }
 
  // test button release , store time
  if (backval == low && backlast == high && (millis() - btndntime) > debounce)
  {
    if (ignoreup == false) event1();
      else ignoreup = false;
      btnuptime = millis();
  }
 
  // test button held down longer hold time
  if (backval == high && (millis() - btndntime) > holdtime)
  {
    event2();
    ignoreup = true;
    btndntime = millis();
  }

backlast = backval;
//***********************************************************************


//**********************fforward , skip forward************************
  // read state of button
  forwardval = digitalread(forward);
 
  // test button pressed , store down time
  if (forwardval == high && forwardlast == low && (millis() - btnuptime) > debounce)
  {
    btndntime = millis();
  }
 
  // test button release , store time
  if (forwardval == low && forwardlast == high && (millis() - btndntime) > debounce)
  {
    if (ignoreup == false) event3();
      else ignoreup = false;
      btnuptime = millis();
  }
 
  // test button held down longer hold time
  if (forwardval == high && (millis() - btndntime) > holdtime)
  {
    event4();
    ignoreup = true;
    btndntime = millis();
  }

forwardlast = forwardval;
//***********************************************************************


//*****************************volume************************************
 
  if (digitalread(downvolume) == high)
  {
    remote.decrease();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
  if (digitalread(mutevolume) == high)
  {
    remote.mute();
    delay(500);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
  if (digitalread(upvolume) == high)
  {
    remote.increase();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
//***********************************************************************


//*****************************play/pause********************************

reading = digitalread(playpause);

  // if input went low , high , we've waited long enough
  // ignore noise on circuit, toggle output pin , remember
  // time
  if (reading == high && previous == low && millis() - time > debounce) {
    if (state == high)
    {
      state = low;
      remote.pause();
     // delay(100);     // simple debounce
      remote.clear(); // prevent duplicate activation
    }
    else
    {
      state = high;
      remote.play();
    //  delay(100);     // simple debounce
      remote.clear(); // prevent duplicate activation
    }

    time = millis();   
  }

  digitalwrite(outpin, state);

  previous = reading;
 
}

//=================================================
// events trigger click , press+hold

void event1()
{
  remote.previous();
  remote.clear(); // prevent duplicate activation
}

void event2()
{
  remote.rewind();
  remote.clear();
}

void event3()
{
  remote.next();
  remote.clear(); // prevent duplicate activation
}

void event4()
{
  remote.forward();
  remote.clear();
}
 
 
 
 
 
 
 
 
 
 
 
  /*
 
  if (digitalread(upvolume) == high) {
    remote.increase();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
  if (digitalread(downvolume) == high) {
    remote.decrease();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
  if (digitalread(mutevolume) == high) {
    remote.mute();
    delay(500);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
 
  if (digitalread(playmedia) == high) {
    remote.play();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }

  if (digitalread(pausemedia) == high) {
    remote.pause();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }

  if (digitalread(rewindmedia) == high) {
    remote.rewind();
    delay(100);     // simple debounce
    remote.clear(); // prevent duplicate activation
  }
  */


Arduino Forum > Using Arduino > Project Guidance > Windows10 system volume controller

arduino