#!/bin/bash
export DISPLAY=:0.0
cd /home/your_path/scripts
DISPLAY=:0.0 aticonfig --pplib-cmd "set fanspeed 0 75"
DISPLAY=:0 ./poclbm.py -d0 -v -r 5 -w128 http://your_user@mail.com:your_password@deepbit.net:8332 | tee mining_gpu0.log

#!/bin/bash
export DISPLAY=:0.1
cd /home/your_path/scripts
DISPLAY=:0.1 aticonfig --pplib-cmd "set fanspeed 0 75"
DISPLAY=:0 ./poclbm.py -d0 -v -r 5 -w128 http://your_user@mail.com:your_password@deepbit.net:8332 | tee mining_gpu1.log

#!/bin/bash
export DISPLAY=:0.2
cd /home/your_path/scripts
DISPLAY=:0.2 aticonfig --pplib-cmd "set fanspeed 0 75"
DISPLAY=:0 ./poclbm.py -d0 -v -r 5 -w128 http://your_user@mail.com:your_password@deepbit.net:8332 | tee mining_gpu2.log

/usr/bin/screen -admS gpu0 ./gpu0.sh

screen -x gpu0

#!/bin/bash

cd /home/your_path/scripts
echo Starting mining scripts...
/usr/bin/screen -admS gpu0 ./gpu0.sh
/usr/bin/screen -admS gpu1 ./gpu1.sh
/usr/bin/screen -admS gpu2 ./gpu2.sh
...

#!/bin/bash
#---times constants
control_time=5       # Time cycle between control loops (5 seconds)
overclock_delay=180  # waiting time between overclocking commands (It is multiplier of control_time (180*5 = 15 min)
downclock_delay=60   # waiting time between downclocking commands (60*5 = 5 min)
downclock_urgent=24  # waiting time between urgent downclocking commands (24*5 = 2 min)
timeCounter=0        # time counter

#---GPUs temperatures
target_temp=75      # Target temp for the GPUs. Automatic Overclocking/downclocking will be performed for reaching this temperature as maximum.
hightemp_alarm=80   # Alarm temperature: If exceeded, it will be performed an urgent downclocking
maxtemp_stop=83     # maximum temperature in the GPUs: The mining process will be stopped for security resons.
temp_recover=65     # recovery temperature: After a mining stop due to high temperature, when this safe temperature is reached, the mining is already started.
control_gap=3       # Temperature below target_temp that is needed to be exceeded for an overclock command. (If current temperature is very near from the target temp, overclockin is not performed... we maintain the temp. near but below the limit) 

#---CPU temperaturas
tempCPU_halt=70     #If this temperature is reached by the CPU or motherboard, a HALT is performed for turning of the RIG.

#---Clock limits
corefreq_min=800    # Minimum freq. to be set by the control algorithm
corefreq_max0=945   # Maximum freq. to be set by the control algorithm in GPU0 (In my case I checked that above 975Mhz this GPU hangs the X session)
corefreq_max1=955   # Maximum freq. to be set by the control algorithm in GPU1 (In my case I checked that above 995Mhz the mining process got zombie)
corefreq_max2=1025  # Maximum freq. to be set by the control algorithm in GPU2 (In my case I checked that above 1055Mhz the mining process got zombie)
mem_freq=300       # Fixed value for memory clock (normally it is 1200MHz in the GPUs, but using 300MHz reduces the temperature without affecting to the performance)

#--Mail sending
subject="Important advice from your RIG"
mail1="your_mail@mail.com"
mail2="other_mail@mail.com"
mail3="other_mail@mail.com"

#--control constants
retryMiningAfterFailure=1  # Mining scripts are automatically started after a failure
debug=0       # enable/disable debugging messages
numRetries=5       # Limit of retries for restarting the mining processes in the GPUs
reboot=1                   # If zombie mining processes are detected, the control script can perform an automatic system reboot. This will recover mining in all GPUs.

#--FAN constants
FANGPU0=75
FANGPU1=75
FANGPU2=75

#--Internal variables
GPU0=0
GPU1=1
GPU2=2
mining_stopped=0    # Mining process has been stopped by the control algorithm
init_coreCLK0=900   # initial overclocking value for GPU0
init_coreCLK1=900   # initial overclocking value for GPU1
init_coreCLK2=900   # initial overclocking value for GPU2
counterLastCLK0=0   # Stores the time of the last overclocking/downclocking performed on GPU0
counterLastCLK1=0   # Stores the time of the last overclocking/downclocking performed on GPU1
counterLastCLK2=0   # Stores the time of the last overclocking/downclocking performed on GPU2
simulation=0       # Disables the overclockin, only logs outputs for debuguing .
retriesGPU0=0
retriesGPU1=0
retriesGPU2=0
alertFailProcessGPU0=0
alertFailProcessGPU1=0
alertFailProcessGPU2=0

# ---------------------------------------------------------------------
# Function Debug: It outputs messages to the console only in debug mode
# Parameters: Text Message to be displayed
# -----------------------------------------------------------------
function debug(){
if (test $debug -eq 1)
       then
    echo -e "[Time: $timeCounter | $(date | awk '{print $3 $2 $4}')] $@"
fi
}

# ---------------------------------------------------------------------
# Function output: This function output messages to the console
# $1: Message
# $2: if $2=1 the message is sent by email
# ---------------------------------------------------------------------
function output(){
mensaje="[Time: $timeCounter | $(date | awk '{print $3 $2 $4}')] $1"
echo -e $mensaje       
if test $2 -eq 1
then
echo -e "$mensaje" | mail -s "$subject" $mail1
echo -e "$mensaje" | mail -s "$subject" $mail2
echo -e "$mensaje" | mail -s "$subject" $mail3
fi
}

# ----------------------------------------------------------------
# Function FANCommand: This function sets the FAN speed of a GPU
# Params: $1:num_gpu: $GPU0,$GPU1,$GPU2
#         $2:FAN_SPEED: Value from 0 to 100 %, ej: 100
# Use:  FANCommand $GPU0 100
# ----------------------------------------------------------------
function FANCommand(){
case $1 in
  0)
DISPLAY=:0.0 aticonfig --pplib-cmd "set fanspeed 0 $2">>null;;
  1)
DISPLAY=:0.1 aticonfig --pplib-cmd "set fanspeed 0 $2">>null;;
  2)
DISPLAY=:0.2 aticonfig --pplib-cmd "set fanspeed 0 $2">>null;;
esac
output "  New setting: FAN GPU$1 to $2 %" 0
}

# ----------------------------------------------------------------
# Function overclock: This function sets the clk of a GPU
# Params: $1:num_gpu : $GPU0,$GPU1,$GPU2
#         $2:clkfreq : core clk value to be set, ej: 850
#         $3:memfreq : mem clk to be set, ej: 300 
# Use:  overclock 0 850 1200
# ----------------------------------------------------------------
function overclock(){
if test $simulation -eq 0
then
case $1 in
   0)
aticonfig --adapter=0 --odsc=$2,$3 >>null;;
   1)
aticonfig --adapter=1 --odsc=$2,$3 >>null;;
   2)
aticonfig --adapter=2 --odsc=$2,$3 >>null;;
esac
fi
output "  New setting: Overclock GPU$1 to $2 / $3 Mhz" 0
}

# ----------------------------------------------------------------
# Function controlFAN: Calculates the FAN speed depending on the temperatures and current FAN speed (num_gpu, currentTemp, currentFAN)
#   It performes the FAN speed control of a GPU
# Params: $1:num_gpu : $GPU0,$GPU01,$GPU2
#         $2:currentTemp: Current value reported by the GPU (no decimals), ej: 56
#    $3:currentFAN:  Current FAN speed for this GPU, ej: 75 %
#  
# Use:  controlFAN $GPU0 56 75
# ----------------------------------------------------------------
function controlFAN(){

#hysteresis of 2ºC around temperature threshold 55º
if test $2 -lt 54
then
controlFAN=30
elif test $2 -lt 56
then
if test $3 -ne 45
then
controlFAN=30
fi
#hysteresis of 2ºC around temperature threshold 60º
elif test $2 -lt 59
then
controlFAN=45
elif test $2 -lt 61
then
if test $3 -ne 60
then
controlFAN=45
fi
#hysteresis of 2ºC around temperature threshold 65º
elif test $2 -lt 64
then
controlFAN=60
elif test $2 -lt 66
then
if test $3 -ne 75
then
controlFAN=60
fi
#hysteresis of 2ºC around temperature threshold 70º
elif test $2 -lt 69
then
controlFAN=75
elif test $2 -lt 71
then
if test $3 -ne 90
then
controlFAN=75
fi
else
controlFAN=90
  fi

# It sends the FAN speed command only if the new setting is different to the current one.
case $1 in
    0)
    debug "FAN control GPU0: Current FAN=$FANGPU0, controlFAN:$controlFAN"
  if test $controlFAN -ne $FANGPU0
                then
  FANCommand 0 $controlFAN
FANGPU0=$controlFAN
  fi;;
    1)
    debug "FAN control GPU1: Current FAN=$FANGPU1, controlFAN:$controlFAN"
  if test $controlFAN -ne $FANGPU1
                then
  FANCommand 1 $controlFAN
FANGPU1=$controlFAN
  fi;;
    2)
    debug "FAN control GPU2: Current FAN=$FANGPU2, controlFAN:$controlFAN"
  if test $controlFAN -ne $FANGPU2
                then
  FANCommand 2 $controlFAN
FANGPU2=$controlFAN
  fi;;
esac
}

# ----------------------------------------------------------------
# Function controlTemp: Calculates the GPU clock correction to be performed depending on the GPU temperatures (num_gpu, currentTemp, consignaTemp)
#    It performes the overclocking/downclocking of the GPU
# Params: $1:num_gpu : $GPU0,$GPU01,$GPU2
#         $2:currentTemp: Current temperature reported by the GPU (no decimals), ej: 56
#         $3:TargetTemp: Target temperature desired in this GPU as maximum, ej: 78
# Outputs:
#    counterLastCLK0, counterLastCLK1 y counterLastCLK2: Time information of the last CLK correction on each GPU.
#  
# Use:    controlTemp $GPU 56 78
# ----------------------------------------------------------------
function controlTemp(){
offsetCLK=$(expr $3 - $2)

# temperature gap defined in 'control_gap' is guaranteed to avoid causing stress to the GPU when the current temperature is very near to the target temperature
if (test $offsetCLK -gt 0) && (test $offsetCLK -lt $control_gap)
then
debug "The correction ($offsetCLK) does not exceed the control GAP ($control_gap). CLK is maintained."
return 1
fi

# Demanded frequencies are limited to the specific clk ranges of each GPU
case $1 in
    0)
  demandaCLK=$(expr $coreCLK0 + $offsetCLK)
  if test $demandaCLK -gt $corefreq_max0
                then
demandaCLK=$corefreq_max0
           fi;;
    1)
  demandaCLK=$(expr $coreCLK1 + $offsetCLK)
  if test $demandaCLK -gt $corefreq_max1
  then
demandaCLK=$corefreq_max1
           fi;;

    2)
  demandaCLK=$(expr $coreCLK2 + $offsetCLK)
  if test $demandaCLK -gt $corefreq_max2
                then
demandaCLK=$corefreq_max2
  fi;;
esac

if test $demandaCLK -lt $corefreq_min
       then
demandaCLK=$corefreq_min
fi

debug "*** GPU$1 --> CurrentTemp:$2 - Consigna:$3 - Control:$demandaCLK ($offsetCLK)"

# Sending of overclock command, only if there is a change.
case $1 in
    0)
  if test $demandaCLK -ne $coreCLK0
                then
  overclock 0 $demandaCLK $mem_freq
counterLastCLK0=$timeCounter
debug "Tiempo contCLK0: $counterLastCLK0"
  else
  debug "GPU0: Limit is already reached: $corefreq_max0."
  counterLastCLK0=$timeCounter
  fi;;
    1)
  if test $demandaCLK -ne $coreCLK1
                then
overclock 1 $demandaCLK $mem_freq
counterLastCLK1=$timeCounter
debug "Tiempo contCLK1: $counterLastCLK1"
  else
  debug "GPU1: Limit is already reached: $corefreq_max1."
  counterLastCLK1=$timeCounter
  fi;;
    2)
  if test $demandaCLK -ne $coreCLK2
                then
overclock 2 $demandaCLK $mem_freq
counterLastCLK2=$timeCounter
debug "Tiempo contCLK2: $counterLastCLK2"
  else
  debug "GPU2: Limit is already reached: $corefreq_max2."
  counterLastCLK2=$timeCounter
  fi;;
esac
}


# ----------------------------------------------------------------
# Function checkOverclockTimeGuard: This function ensures a certain period of time between consecutives overclock commands.
# - Guard Time between overclocks: $overclock_delay*$control_time (180*5 = 15 minutes)
# - Guard Time between downclocks: $downclock_delay*$control_time (60*5 = 5 minutes)
# - Guard time between urgent downclocks: $downclock_urgent*$control_time (24*5 = 2 minutes)
# Params: $1:num_gpu : 0,1,2
#         $2:timeCounter: Current value of the time counter
#         $3:up_down: 0:overclock, 1:downclock, 2:urgent downclock
# Outputs:
#    $return_correction: 0:Not to perform CLK correction. 1:CLK correction can be performed now.
# ----------------------------------------------------------------
function checkOverclockTimeGuard (){
return_correction=0
case $1 in
0)
if test $3 -eq 0
                     then  ##overclock
due_time=$(expr $counterLastCLK0 + $overclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi
elif test $3 -eq 1
                     then  ##normal downclocking
due_time=$(expr $counterLastCLK0 + $downclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi

elif test $3 -eq 2
                     then  ##urgent downclocking
due_time=$(expr $counterLastCLK0 + $downclock_urgent)
if test $2 -ge $due_time
                            then
return_correction=1
fi
fi;;
       1)
if test $3 -eq 0
                     then  ##overclocking
due_time=$(expr $counterLastCLK1 + $overclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi
elif  test $3 -eq 1
                     then  ##normal downclocking
due_time=$(expr $counterLastCLK1 + $downclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi
elif test $3 -eq 2
                     then  ##urgent downclocking
due_time=$(expr $counterLastCLK1 + $downclock_urgent)
if test $2 -ge $due_time
                            then
return_correction=1
fi
fi;;
       2)
if test $3 -eq 0
                     then  ##overclocking
due_time=$(expr $counterLastCLK2 + $overclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi
elif test $3 -eq 1
                     then  ##normal downclocking
due_time=$(expr $counterLastCLK2 + $downclock_delay)
if test $2 -ge $due_time
                            then
return_correction=1
fi
elif test $3 -eq 2
                     then  ##urgent downclocking
due_time=$(expr $counterLastCLK2 + $downclock_urgent)
if test $2 -ge $due_time
                            then
return_correction=1
fi
fi;;
esac
debug "-------GPU$1: due_time: $due_time, correction: $return_correction"
}

# ---------------------------------------------------------------------------------------------------------
# MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN - MAIN
# ---------------------------------------------------------------------------------------------------------
#Overclockin enabling
aticonfig --adapter=0 --od-enable   
aticonfig --adapter=1 --od-enable   
aticonfig --adapter=2 --od-enable   
overclock 0 $init_coreCLK0 $mem_freq 
overclock 1 $init_coreCLK1 $mem_freq 
overclock 2 $init_coreCLK2 $mem_freq   
FANCommand 0 30
FANCommand 1 30
FANCommand 2 30
output "Automatic control algorithm has been started" 1  #This is sent by email.
output "Automatic FAN speed control starts from 30%" 0
while true; do

#Fetching of current temperatures
tempGPU0=$(aticonfig --adapter=0 --od-gettemperature | tail -n1 | awk '{print $5}' | cut -c1-2)
tempGPU1=$(aticonfig --adapter=1 --od-gettemperature | tail -n1 | awk '{print $5}' | cut -c1-2)
tempGPU2=$(aticonfig --adapter=2 --od-gettemperature | tail -n1 | awk '{print $5}' | cut -c1-2)
tempCPU=$(sensors |grep CPU |grep Temperature | awk '{print $3}'|cut -c2-3)
tempMB=$(sensors |grep NB |grep Temperature | awk '{print $3}'|cut -c2-3)

#Fetching of current GPU CLK frequencies
coreCLK0=$(aticonfig --adapter=0 --odgc |grep Clocks | awk '{print $4}')
memCLK0=$(aticonfig --adapter=0 --odgc |grep Clocks | awk '{print $5}')
coreCLK1=$(aticonfig --adapter=1 --odgc |grep Clocks | awk '{print $4}')
memCLK1=$(aticonfig --adapter=1 --odgc |grep Clocks | awk '{print $5}')
coreCLK2=$(aticonfig --adapter=2 --odgc |grep Clocks | awk '{print $4}')
memCLK2=$(aticonfig --adapter=2 --odgc |grep Clocks | awk '{print $5}')

  #It detects if there are mining processes already running
  miningIsActive0=$(ls /var/run/screen/S-your_user/ |grep gpu0 |wc -l)   # we look for the 'screen' session lock file
        miningIsActive1=$(ls /var/run/screen/S-your_user/ |grep gpu1 |wc -l)   # we look for the 'screen' session lock file
        miningIsActive2=$(ls /var/run/screen/S-your_user/ |grep gpu2 |wc -l)   # we look for the 'screen' session lock file

loadGPU0=$(aticonfig --adapter=0 --odgc |grep GPU |awk '{print $4}' | cut -c1-2)  # It is also checked the load of each GPU
loadGPU1=$(aticonfig --adapter=1 --odgc |grep GPU |awk '{print $4}' | cut -c1-2)
loadGPU2=$(aticonfig --adapter=2 --odgc |grep GPU |awk '{print $4}' | cut -c1-2)
debug " --> Temps: $tempGPU0, $tempGPU1, $tempGPU2"
debug " --> Clks: $coreCLK0, $coreCLK1, $coreCLK2"

# --------------------------------Temperature of CPU and Motherboard ---------------------------------------
if (test $tempCPU -gt $tempCPU_halt) || (test $tempMB -gt $tempCPU_halt)
        then
output "ERR: Temperature of CPU/MB is too high! $tempCPU / $tempMB.... \nSWITCHING OFF THE SYSTEM. \n Check the CPU FAN condition and switch the RIG on manually." 1
/usr/bin/halt
fi

# Checking of zombie mining processes.
num_defunc=$(ps -Al |grep py|grep defunc| wc -l) 
if test $num_defunc -gt 0
      then
if test $reboot -eq 1
then
    output "### ERR: There are one or more zombie mining processes:
\nMaybe a mining process is hanged and blocked.
\nIt is neccesary to restart the system for recovering the mining (sudo reboot).
\n$(ps -Al |grep py|grep defunc| wc -l)
\n --> PERFORMING AN AUTOMATIC REBOOT OF THE SYSTEM...." 1    # Sent my email
/usr/bin/reboot
else
output "### ERR: There are one or more zombie mining processes:
\nMaybe a mining process is hanged and blocked.
\nIt is neccesary to restart the system for recovering the mining (sudo reboot).
\n$(ps -Al |grep py|grep defunc| wc -l)" 1                    # Sent my email
fi
fi

# --------------------------------Init checkings -------------------------------
if (test $miningIsActive0 -eq 0)
        then
if (test $mining_stopped -eq 0) && (test $retryMiningAfterFailure -eq 1)
              then
if test $retriesGPU0 -lt $numRetries
                     then
output "### ERR the mining process in GPU0 is not started ......" 0
output "*** Starting mining on GPU0..." 0
overclock 0 $init_coreCLK0 $mem_freq 
coreCLK0= $init_coreCLK0
/usr/bin/screen -admS gpu0 ./gpu0.sh
retriesGPU0=$(expr $retriesGPU0 + 1)
elif test $alertFailProcessGPU0 -eq 0
then
output "### ERR Mining retries limit has been reached in the process GPU0.sh
\n*** Check that the process is not zombie and start it manually " 1    # Sent by email
alertFailProcessGPU0=1
fi
fi
fi

if (test $miningIsActive1 -eq 0)
        then
if (test $mining_stopped -eq 0) && (test $retryMiningAfterFailure -eq 1)
              then
if test $retriesGPU1 -lt $numRetries
                     then
output "### ERR the mining process in GPU1 is not started ......" 0
output "*** Starting mining on GPU1..." 0
overclock 1 $init_coreCLK1 $mem_freq 
coreCLK1= $init_coreCLK1
/usr/bin/screen -admS gpu1 ./gpu1.sh
retriesGPU1=$(expr $retriesGPU1 + 1)
elif test $alertFailProcessGPU1 -eq 0       
then
output "### ERR Mining retries limit has been reached in the process GPU1.sh
\n*** Check that the process is not zombie and start it manually " 1    # Sent by email
      alertFailProcessGPU1=1
fi
fi
fi


if (test $miningIsActive2 -eq 0)
        then
if (test $mining_stopped -eq 0) && (test $retryMiningAfterFailure -eq 1)
              then
if test $retriesGPU2 -lt $numRetries
                     then
output "### ERR the mining process in GPU2 is not started ......" 0
output "*** Starting mining on GPU2..." 0
overclock 2 $init_coreCLK2 $mem_freq 
coreCLK2= $init_coreCLK2
/usr/bin/screen -admS gpu2 ./gpu2.sh
retriesGPU2=$(expr $retriesGPU2 + 1)
elif test $alertFailProcessGPU2 -eq 0
then
output "### ERR Mining retries limit has been reached in the process GPU2.sh
\n*** Check that the process is not zombie and start it manually " 1    # Sent by email
alertFailProcessGPU2=1   
fi
fi
fi


# --------------------------------Automatic switching off control -----------------------------
if (test $tempGPU0 -gt $maxtemp_stop) || (test $tempGPU1 -gt $maxtemp_stop) || (test $tempGPU2 -gt $maxtemp_stop)
then
if (test $mining_stopped -eq 0)
then

if test $retryMiningAfterFailure -eq 1
then
output "ERR: Extreme temperature in GPUs ($tempGPU0, $tempGPU1, $tempGPU2 ºC) - Switching off the mining...
       \n After some minutes it will be strated again ..." 1   # Sent by email
else
output "ERR: Extreme Temperature in GPUs ($tempGPU0, $tempGPU1, $tempGPU2 ºC) - Switching off the mining...
       \n Start the mining process manually ..." 1 # Sent by email
fi
./stop.sh
mining_stopped=1
fi

else  # As soon as the GPUs temperatures are below temp_recover, mining is started again.  
    if (test $mining_stopped -eq 1) && (test $retryMiningAfterFailure -eq 1) 
    then
if (test $tempGPU0 -lt $temp_recover) || (test $tempGPU1 -lt $temp_recover) || (test $tempGPU2 -lt $temp_recover)
then
# It Sets safe GPUs clock values
output "The temperature of the GPUs has been recovered to $tempGPU0 / $tempGPU1 / $tempGPU2" 0
output "GPUS clocks are stablished to 850/300 MHz." 0
overclock 0 $init_coreCLK0 $mem_freq 
overclock 1 $init_coreCLK1 $mem_freq 
overclock 2 $init_coreCLK2 $mem_freq 
coreCLK0= $init_coreCLK0
coreCLK1= $init_coreCLK1
coreCLK2= $init_coreCLK2
retriesGPU0=0
retriesGPU1=0
retriesGPU2=0
output " --> Starting mining." 0
./minar.sh
mining_stopped=0
fi
    fi
fi

#------------------------------  Overclocking control on GPU0 ----------------------------------

if (test $mining_stopped -eq 0) && (test $miningIsActive0 -eq 1)
then
#The temperature is within the control margins, below target temp
if (test $tempGPU0 -lt $target_temp)
          then   
checkOverclockTimeGuard $GPU0 $timeCounter 0
if test $return_correction -eq 1
              then
controlTemp $GPU0 $tempGPU0 $target_temp
fi

#The temperature is outside the control margins, below the alarm temp
elif (test $tempGPU0 -lt $hightemp_alarm)
        then
checkOverclockTimeGuard $GPU0 $timeCounter 1 #downclocking
if test $return_correction -eq 1
              then
controlTemp  $GPU0 $tempGPU0 $target_temp
fi

# Overtemp alarm
elif (test $tempGPU0 -lt $maxtemp_stop)
        then
output "Alarm! GPU0 very hot, temperature: $tempGPU0. Performing urgent downclocking ...." 1    #Sent by email
checkOverclockTimeGuard $GPU0 $timeCounter 2 #urgent downclocking
if test $return -eq 1
              then
controlTemp  $GPU0 $tempGPU0 $target_temp
fi
fi
# FAN Speed control
controlFAN $GPU0 $tempGPU0 $FANGPU0
fi

#------------------------------  Overclocking control on GPU1 ----------------------------------

if (test $mining_stopped -eq 0) && (test $miningIsActive1 -eq 1)
then
#The temperature is within the control margins, below target temp
if (test $tempGPU1 -lt $target_temp) && (test $miningIsActive1 -eq 1) && (test $mining_stopped -eq 0) 
        then   
checkOverclockTimeGuard $GPU1 $timeCounter 0
if test $return_correction -eq 1
              then
controlTemp  $GPU1 $tempGPU1 $target_temp
fi

#The temperature is outside the control margins, below the alarm temp
elif (test $tempGPU1 -lt $hightemp_alarm) && (test $miningIsActive1 -eq 1) && (test $mining_stopped -eq 0)
        then
checkOverclockTimeGuard $GPU1 $timeCounter 1 #downclocking
if test $return_correction -eq 1
              then
controlTemp  $GPU1 $tempGPU1 $target_temp
fi

# Overtemp alarm
elif (test $tempGPU1 -lt $maxtemp_stop) && (test $miningIsActive1 -eq 1) && (test $mining_stopped -eq 0)
        then
output "Alarm! GPU1 very hot, temperature: $tempGPU1. Performing urgent downclocking ...." 1    #Sent by email
checkOverclockTimeGuard $GPU1 $timeCounter 2 #urgent downclocking
if test $return_correction -eq 1
              then
controlTemp  $GPU1 $tempGPU1 $target_temp
fi
fi
# FAN Speed control
controlFAN $GPU1 $tempGPU1 $FANGPU1
fi
#------------------------------  Overclocking control on GPU2 ----------------------------------
if (test $mining_stopped -eq 0) && (test $miningIsActive2 -eq 1)
then
#The temperature is within the control margins, below target temp
if (test $tempGPU2 -lt $target_temp) && (test $miningIsActive2 -eq 1) && (test $mining_stopped -eq 0)
        then   
checkOverclockTimeGuard $GPU2 $timeCounter 0
if test $return_correction -eq 1
              then
controlTemp  $GPU2 $tempGPU2 $target_temp
fi

#The temperature is outside the control margins, below the alarm temp
elif (test $tempGPU2 -lt $hightemp_alarm) && (test $miningIsActive2 -eq 1) && (test $mining_stopped -eq 0)
        then
checkOverclockTimeGuard $GPU2 $timeCounter 1 #downclocking
if test $return_correction -eq 1
              then
controlTemp  $GPU2 $tempGPU2 $target_temp
fi

# Overtemp alarm
elif (test $tempGPU2 -lt $maxtemp_stop) && (test $miningIsActive2 -eq 1) && (test $mining_stopped -eq 0)
        then
output "Alarm! GPU2 very hot, temperature: $tempGPU2. Performing urgent downclocking ...." 1    #Sent by email
checkOverclockTimeGuard $GPU2 $timeCounter 2 #urgent downclocking
if test $return_correction -eq 1
              then
controlTemp  $GPU2 $tempGPU2 $target_temp
fi
fi
# FAN Speed control
controlFAN $GPU2 $tempGPU2 $FANGPU2
fi
timeCounter=$(expr $timeCounter + 1)
sleep $control_time;
done

#!/bin/bash
cd /home/your_user/scripts
./control.sh | tee control.log

#!/bin/bash
while true; do
        echo "---------------- GPUs Health ----------------"
        aticonfig --adapter=0 --od-gettemperature | tail -n1 | awk '{print "GPU0 Temperature: " $5}' ;
        aticonfig --adapter=1 --od-gettemperature | tail -n1 | awk '{print "GPU1 Temperature: " $5}' ;
        aticonfig --adapter=2 --od-gettemperature | tail -n1 | awk '{print "GPU2 Temperature: " $5}' ;
        echo $(aticonfig --adapter=0 --odgc | grep GPU);
        echo $(aticonfig --adapter=1 --odgc | grep GPU);
echo $(aticonfig --adapter=2 --odgc | grep GPU);
        echo "GPU FANS: $(DISPLAY=:0.0 aticonfig --pplib-cmd 'get fanspeed 0'|grep Result |cut -d ' ' -f 4) / $(DISPLAY=:0.1 aticonfig --pplib-cmd 'get fanspeed 0'|grep Result |cut -d ' ' -f 4) / $(DISPLAY=:0.2 aticonfig --pplib-cmd 'get fanspeed 0'|grep Result |cut -d ' ' -f 4)"
        echo "Overclocking...."
        echo "-   Core Clocks: $(aticonfig --adapter=0 --odgc |grep Clocks |cut -d ' ' -f 18) / $(aticonfig --adapter=1 --odgc |grep Clocks |cut -d ' ' -f 18) / $(aticonfig --adapter=2 --odgc |grep Clocks |cut -d ' ' -f 18) Mhz."
        echo "-   Mem Clocks: $(aticonfig --adapter=0 --odgc |grep Clocks |cut -d ' ' -f 29) / $(aticonfig --adapter=1 --odgc |grep Clocks |cut -d ' ' -f 29) / $(aticonfig --adapter=2 --odgc |grep Clocks |cut -d ' ' -f 29) Mhz."
#echo " "
echo ----------------  PC health -------------------
        echo $(sensors |grep CPU |grep Temperature) | cut -d ' ' -f 1,2,3
        echo $(sensors |grep NB |grep Temperature) | cut -d ' ' -f 1,2,3
        echo $(sensors |grep SB |grep Temperature) | cut -d ' ' -f 1,2,3
echo "HDD Avail: $(df -h |grep sda1 |cut -d ' ' -f 20)"
        #echo " "
echo "---------------- Mining rate ------------------"
        # Check if there are Screen lock files....
        IsMining_gpu0=$(ls /var/run/screen/S-your_user/ |grep gpu0 |wc -l)
        IsMining_gpu1=$(ls /var/run/screen/S-your_user/ |grep gpu1 |wc -l)
        IsMining_gpu2=$(ls /var/run/screen/S-your_user/ |grep gpu2 |wc -l)
        # Last Hashrate report
if test $IsMining_gpu0 -ge 1
then
echo "Mining on GPU0: " $(cat mining_gpu0.log | cut -d '[' -f 2)
else
echo "Mining on GPU0:  ERR! Mining Process is stopped!"
fi

        if test $IsMining_gpu1 -ge 1
        then
echo "Mining on GPU1: " $(cat mining_gpu1.log | cut  -d '[' -f 2)
        else
              echo "Mining on GPU1:  ERR! Mining process is stopped!"
        fi
        if test $IsMining_gpu2 -ge 1
        then
echo "Mining on GPU2: " $(cat mining_gpu2.log | cut -d '[' -f 2)
        else
              echo "Mining on GPU2:  ERR! Mining process is stopped!"
        fi
#Erase mining logs... next loop we will find only the hashrate.
echo "" > mining_gpu0.log
echo "" > mining_gpu1.log
echo "" > mining_gpu2.log
        controlIsActive=$(ls /var/run/screen/S-vamach/ |grep control |wc -l)
        #echo " "
echo "---------- Logs Mining Controller -------------"
if test $controlIsActive-ge 1
        then
                tail -5 control.log
        else
                echo "Control algorithm is OFF"
        fi
  sleep 5;
        clear
done

#!/bin/bash
cd /home/your_user/scripts
monitorIsRunning=$(ls /var/run/screen/S-your_user/ |grep monitor |wc -l)
if test $monitorIsRunning -ge 1
then
echo "Monitor script is already running in another Screen. Getting attached..."
screen -x monitor
else
echo "Monitor script is not running. Starting..."
/usr/bin/screen -admS monitor ./monitor.sh
fi

!/bin/bash

cd /home/your_path/scripts
echo Starting mining scripts...
/usr/bin/screen -admS gpu0 ./gpu0.sh
/usr/bin/screen -admS gpu1 ./gpu1.sh
/usr/bin/screen -admS gpu2 ./gpu2.sh
echo Starting monitor script...
/usr/bin/screen -admS monitor ./monitor.sh
echo Starting automatic control script...
/usr/bin/screen -admS control ./start_control.sh
echo " "
echo For monitoring the RIG, enter m. 

#!/bin/bash
screen -X -S gpu0 kill
screen -X -S gpu1 kill
screen -X -S gpu2 kill
screen -X -S monitor kill
screen -X -S control kill
killall screen