jcmvbkbc

хочется чтобы лента плавно изменяла яркость

для этого нужно менять скважность ШИМ не один раз скачком от текущего значения к целевому, а постепенно, за несколько шагов. С постоянной скоростью -- примерно так:

void set_pwm_smooth(int new_pwm)
{
    static const int pwm_step = ...; // шаг изменения ШИМ
    static const int pwm_step_time = ...; // время одного шага изменения ШИМ
    static int old_pwm;
    int pwm = old_pwm;

    while (pwm != new_pwm) {
        int next_pwm = pwm + (pwm < new_pwm ? pwm_step : -pwm_step);
        if ((pwm < new_pwm && next_pwm > new_pwm) ||
            (pwm > new_pwm && next_pwm < new_pwm))
            pwm = new_pwm;
        else
            pwm = next_pwm;
        analogWrite(LEDPIN, pwm);
        delay(pwm_step_time);
    }
    old_pwm = new_pwm;
}

Подскажите пожалуйста, почему так

Потому что порядок перечисления библиотек важен: в списке библиотек a b c символы, которые нужны библиотеке b будут искаться только в библиотеке c, но не в a. Если между библиотеками нет циклических зависимостей (т.е. нет такого, что a определяет символ, нужный b, а b определяет символ, нужный a), то их можно упорядочить так, что линковка будет успешной (см. топологическая сортировка). Если циклические зависимости есть, или сортировать лень, можно перечислить нужные библиотеки несколько раз или взять их в группу:

g++ main.cpp -Wl,--start-group -lglfw3 -lgdi32 -lopengl32 -lglew32s -Wl,--end-group

sum_of = sum(matrix[][]);

должно стать
sum_of = sum(n, matrix);

int sum (int n, int matrix[n][n]) {
    int sum = 0;
    for (int j = 0; j < n; ++j){
        for (int i = 0; i < n; ++i){
            if (j == i){
                sum += matrix[j][i];
            }
        }
    }
    return sum;
}

Это, конечно, работает, но лучше написать так:

int sum (int n, int matrix[n][n])
{
    int sum = 0;
    for (int i = 0; i < n; ++i) {
        sum += matrix[i][i];
    }
    return sum;
}

пишу ключ -static

из info gcc:

'-static'
On systems that support dynamic linking, this prevents linking with
the shared libraries. On other systems, this option has no effect.

линковать с ключем -dynamic.

нет же такого ключа когда собираешь под linux

Что делать? Убирать ключ -static -- всё равно статически слинкованного исполняемого файла не получится, раз нужна динамическая библиотека.

Если выполнить так, то работает, но вручную прописывать не подходит:

А скрипт поправить?

#!/bin/bash
z1=({0..3}); z2=({4..7}) #...
for((i = 1; i < 3; ++i)); do
declare -n a=z$i
FILES=()
for n in ${a[@]}; do
FILES[${#FILES[@]}]="/untitled/a/$i/$n.jpg"
done
montage -monitor "${FILES[@]}" -geometry +0+0 -tile 4x1 /untitled/b/$i.jpg
done

Стоит ли сокращать код? И как?

Можно сделать так:

struct
{	
  bool btn_state;
  bool btn_flag;
  bool hold_flag;
  bool counter_flag;
  bool isHolded_f;
  bool isRelease_f;
  bool isPress_f;
  bool step_flag;
  bool oneClick_f;
  bool isOne_f;

} fl;
fl flags;
// ........ 

boolean GButton::isFlag(bool& flag) {
  if (_tickMode) GButton::tick();
  if (flag) {
    flag = false;
    return true;
  } else return false;
}

boolean GButton::isPress() {
  return isFlag(flags.isPress_f);
}
boolean GButton::isRelease() {
  return isFlag(flags.isRelease_f);
}
boolean GButton::isClick() {	
  return isFlag(flags.isOne_f);
}
boolean GButton::isHolded() {
  return isFlag(flags.isHolded_f);
}

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

popen например.

switch(1){
case 1:
    double d = 1; //ошибка
}

Почему нельзя инициализировать в case?

С этим кодом всё в порядке с точки зрения стандарта. Проблемы начнутся, если добавить меток case в switch после определения переменной d. Переход на эти метки входит в область видимости переменной d, но минует её инициализацию. Это запрещено стандартом (с++98, 6.7:3):

It is possible to transfer into a block, but not in a way that bypasses declarations
with initialization. A program that jumps from a point where a local variable with
automatic storage duration is not in scope to a point where it is in scope is ill-formed
unless the variable has POD type (3.9) and is declared without an initializer.

Подскажите, а можно ли по такому же принципу преобразовать char массив в int?

unsigned char a[4] = {...};
int b = ...;
memcpy(a, &b, sizeof(a)); // -- int в char
memcpy(&b, a, sizeof(a)); // -- char в int

Как объявить их так, чтобы избежать подобных ошибок?

Очень странная конструкция в коде:
- если это такой уж univeralTool, то зачем он завязывается на поле какого-то конкретного объекта какого-то класса?
- если уж надо завязаться на поле объекта, то почему эта функция -- не член этого класса?
- если надо обработать какое-то значение, то почему не передать это значение как аргумент функции?

Ну и если и ни то и ни сё, и действительно надо как написано в коде -- то раздели всё на части и используй объявления или упорядочи определения функций как следует, например так:

class someClass {
public:
  void someClassTool();
  int variableInClass = 5;
};

Someclass someclass;

void someUniversalTool()
{
  int variable1 = someClass.variableInClass ;
  //some additional code
}

void SomeClass::someClassTool()
{
   someUniversalTool();
   //some additional code
}

Потому что С++. gcc это принимает (без ключа -pedantic) просто потому что это совместимо с с99. Но это не стандартный с++.

Почему так, не подскажете?

Потому что && разбивает команду следующим образом:

( screen -dmS unpack unzip -o arhiv.zip ) && ( rm arhiv.zip )

т.е. "запустить screen и удалить файл". Чтобы удалить файл внутри screen надо написать

screen -dmS unpack bash -c 'unzip -o arhiv.zip && rm arhiv.zip'