AVERAGEPOWER(){
	sensorid=${1}
	daysback=${2}
	
	if [[ "${daysback^^}" = *"M"* ]]; then
		interval="${daysback::-1} MINUTE"
	elif [[ "${daysback^^}" = *"H"* ]]; then
		interval="${daysback::-1} HOUR"
	elif [[ "${daysback^^}" = *"D"* ]]; then
		interval="${daysback::-1} DAY"
	elif [[ "${daysback}" =~ ^[0-9]+$ ]]; then
		interval="${daysback} DAY"
	fi
	
	if [ "${3}" = "both" ]; then
		logsfound_amp=0;
		logsfound_watt=0;
		total_amp=0
		total_watt=0
		while IFS=$'\t' read date amp watt ;do
			if [ "${amp}" != "" ] && [ "${amp}" != "0" ] && [ "${amp}" != "NULL" ] && [[ "${amp}" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
				total_amp=$(bc <<< "scale=2; ${total_amp}+${amp}")
				((logsfound_amp++))
			fi
			if [ "${watt}" != "" ] && [ "${watt}" != "0" ] && [ "${watt}" != "NULL" ] && [[ "${watt}" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
				total_watt=$(bc <<< "scale=2; ${total_watt}+${watt}")
				((logsfound_watt++))
			fi
		done  < <(${mysql_conn} -se "USE servermonitor; SELECT date,amp,watt from power_data WHERE sensorid=${sensorid} AND date >= DATE_SUB(NOW(), INTERVAL ${interval}) ORDER BY id DESC;")
		if [ "${logsfound_watt}" != "0" ]; then
			average_amp=$(bc <<< "scale=2; ${total_amp}/${logsfound_amp}")
			average_watt=$(bc <<< "scale=2; ${total_watt}/${logsfound_watt}")
		else
			average_amp=0
			average_watt=0
		fi
		echo "${average_amp}~${average_watt}"
	else
		logsfound=0;
		total=0
		[ "${3}" != "" ] && ptype=${3} || ptype=watt
		while IFS=$'\t' read date ${ptype} ;do
			if [ "${!ptype}" != "" ] && [ "${!ptype}" != "NULL" ]; then
				total=$(bc <<< "scale=2; ${total}+${!ptype}")
				((logsfound++))
			fi
		done  < <(${mysql_conn} -se "USE servermonitor; SELECT date,${ptype} from power_data WHERE sensorid=${sensorid} AND date >= DATE_SUB(NOW(), INTERVAL ${interval}) ORDER BY id DESC;")
		[ "${logsfound}" != "0" ] && average=$(bc <<< "scale=2; ${total}/${logsfound}") || average=0
		echo ${average}
	fi
}

CHECKPOWER(){
	rm -f ${PW_TMPFOLDER}/*.hostpower*
	REPORT=0
	wspc=10
	while [ $# -gt 0 ]; do
		case "$1" in
			-a|-avg) avgdays=${2};;
			-o|-offsite) STYPE=offsite;;
			-m|-mainsite) STYPE=mainsite;;
			-k|-kyle) STYPE=kyle;;
			-e|-esxi) PTYPE=esxi;;
			-p|-power) PTYPE=power;;
		-r|-report)
				REPORT=1
				unset idsCL idsBG idsST
				idsCL=('')
				idsBG=('')
				idsST=('')
			;;
		esac
		shift 1
	done
	if [ "${avgdays}" != "" ]; then
		[ ${REPORT} -eq 0 ] && modstart=`date +%s`
		if [ "${avgdays}" = "0" ]; then
			unset avgdays
		elif [[ "${avgdays^^}" = *"M"* ]]; then
			avgdays_disp="${avgdays::-1}Min"
		elif [[ "${avgdays^^}" = *"H"* ]]; then
			avgdays_disp="${avgdays::-1}Hr"
		elif [[ "${avgdays^^}" = *"D"* ]]; then
			avgdays_disp="${avgdays::-1}Day"
		elif [[ "${avgdays}" =~ ^[0-9]+$ ]]; then
			avgdays_disp="${avgdays}Day"
		fi
	# else
	# 	avgdays=noavg
	fi
	
	if ([ "${STYPE}" = "" ] || [ "${STYPE}" = "mainsite" ]) && [ "${PTYPE}" != "esxi" ]; then
		[ ${REPORT} -eq 0 ] && echo
		[ ${REPORT} -eq 0 ] && DIVIDER . yellow ${PRI_WIDTH}
		echo -en "${idsCL[Yellow]}Mainsite Power Information"
		[ "${avgdays}" != "" ] && echo -e "				--${idsCL[LightYellow]}${avgdays_disp}-Averages---" || echo
		DIVIDER . yellow ${PRI_WIDTH}
		
		if [[ "${IP}" != "10.6.1"* ]]; then
				
			[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Yellow]}Pulling data from 'Powerwall' ... "
		
			INVSTATSINFO=$(curl -m 3 -s "http://${PW_INVERTER_IP}/stats.json")
			if [ "${INVSTATSINFO}" != "" ]; then
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_INPUTACV}" != "" ]) && INPUTV=${TEST_INPUTACV} || INPUTV=$(echo ${INVSTATSINFO} | jq '.inputs .inV')
				INPUTA=`echo ${INVSTATSINFO} | jq '.inputs .inA'`
				INV_ALARM=`echo ${INVSTATSINFO} | jq '.errors .Alms'`
				[ "${INV_ALARM}" = "0" ] && INV_ALARM_disp="${idsCL[Green]}No Alarms (${INV_ALARM})" || INV_ALARM_disp="${idsCL[LightRed]}${PW_INVERTER_ALARMS[${INV_ALARM}]}"
				INV_ERROR=`echo ${INVSTATSINFO} | jq '.errors .Err'`
				[ "${INV_ERROR}" = "0" ] && INV_ERROR_disp="${idsCL[Green]}No Errors (${INV_ERROR})" || INV_ERROR_disp="${idsCL[LightRed]}${PW_INVERTER_ERRORS[${INV_ERROR}]}"
				INV_STATE=`echo ${INVSTATSINFO} | jq '.stats .invSTATES'`
				[ "${INV_STATE}" != "0" ] && INV_STATE_disp="${idsCL[Green]}${PW_INVERTER_STATES[${INV_STATE}]}" || INV_STATE_disp="${idsCL[LightRed]}${PW_INVERTER_STATES[${INV_STATE}]}"
				INV_MODE=`echo ${INVSTATSINFO} | jq '.stats .power'`
				([ "${INV_MODE}" != "3" ] && [ "${INV_MODE}" != "4" ] && [ "${INV_MODE}" != "E" ]) && INV_MODE_disp="${idsCL[Green]}${PW_INVERTER_MODES[${INV_MODE}]}" || INV_MODE_disp="${idsCL[LightRed]}${PW_INVERTER_MODES[${INV_MODE}]}"
				OUTPUTV=`echo ${INVSTATSINFO} | jq '.outputs .outV'`
				OUTPUTV2=`echo "scale=2; ${OUTPUTV}/2" | tr -d $'\r' | bc`
				OUTPUTA=`echo ${INVSTATSINFO} | jq '.outputs .outA'`
				OUTPUTA2=`echo "scale=2; ${OUTPUTA}*2" | tr -d $'\r' | bc`
				OUTPUTW=`echo ${INVSTATSINFO} | jq '.outputs .outW'`
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_BATTVOLT}" != "" ]) && BATTV=${TEST_BATTVOLT} || BATTV=`echo ${INVSTATSINFO} | jq '.inputs .battV'`
				BATTA=`echo ${INVSTATSINFO} | jq '.inputs .xfA'`
				BATTLIFE=`echo "scale=2; (${BATTV}*100)/${BATT_FULL}" | tr -d $'\r' | bc`
				if (( $(bc <<<"${BATTV} >= ${FLOAT_CHARGE}") )) || ([ "${PW_INVERTER_MODES[${INV_MODE}]}" == "AC Input" ] && (( $(bc <<<"${BATTA} < -2") ))); then
					if (( $(bc <<<"${BATTV} >= ${BULK_CHARGE}") )) || ([ "${PW_INVERTER_MODES[${INV_MODE}]}" == "AC Input" ] && (( $(bc <<<"${BATTA} < -2") ))); then
						BATTA_disp="${idsCL[Green]}`IDS_NUMBER_FORMAT ${BATTA}`'A ${idsCL[LightCyan]}- Bulk Charging"
					else
						BATTA_disp="${idsCL[Green]}`IDS_NUMBER_FORMAT ${BATTA}`'A ${idsCL[LightCyan]}- Float Charging"
					fi
				elif [ "${BATTA}" = "-0.1" ] || [ "${BATTA}" = "-0.2" ] || [ "${BATTA}" = "-0.3" ]; then
					BATTA_disp="${idsCL[LightCyan]}`IDS_NUMBER_FORMAT ${BATTA}`'A ${idsCL[LightCyan]}- Standby"
				else
					BATTA_disp="${idsCL[LightRed]}`IDS_NUMBER_FORMAT ${BATTA}`'A ${idsCL[LightCyan]}- Discharging"
				fi
			fi
			# if [ "$(CHECK_HOST ${PW_UPS_IP})" != "false" ]; then
				SVRRM_VOLTIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.2.2.1.3.1.1 | sed 's/.*: //')
				SVRRM_VOLTIN=`echo "scale=2; ${SVRRM_VOLTIN}/10" | tr -d $'\r' | bc`
				SVRRM_VOLTOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.2.1.1 | sed 's/.*: //')
				SVRRM_VOLTOUT=`echo "scale=2; ${SVRRM_VOLTOUT}/10" | tr -d $'\r' | bc`
			
				SVRRM_WATT=$(snmpwalk  -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.4.1.1 | sed 's/.*: //')
				SVRRM_AMP=$(snmpwalk  -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.3.1.1 | sed 's/.*: //')
				SVRRM_AMP=`echo "scale=2; ${SVRRM_AMP}/100" | tr -d $'\r' | bc`
			
				AIRCON_INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS['ServerRoom-AC']}:8888/status/${PW_SENSOR_DEVICEID['ServerRoom-AC']} | jq '.dps')
				if [ "${AIRCON_INFO}" != "" ]; then
					AIRCON_AMP=$(echo "${AIRCON_INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g')
					AIRCON_AMP=$(ROUND_NUMBER $(echo "scale=3; ${AIRCON_AMP}/1000" | tr -d $'\r' | bc -l) 2)
					AIRCON_WATT=$(echo "${AIRCON_INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g')
					AIRCON_WATT=$(echo "scale=1; ${AIRCON_WATT}/10" | tr -d $'\r' | bc -l)
				else
					AIRCON_AMP=0
					AIRCON_WATT=0
				fi
			
				SVRRM_AMP_WAC=$(echo "scale=2; ${SVRRM_AMP}+${AIRCON_AMP}" | tr -d $'\r' | bc -l)
				SVRRM_WATT_WAC=$(echo "scale=2; ${SVRRM_WATT}+${AIRCON_WATT}" | tr -d $'\r' | bc -l)
			# fi
			#
			# if [ "$(CHECK_HOST ${PW_APCPDU_IP})" != "false" ]; then
				APCPDU_AMP=$(snmpwalk  -t 1 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.2.3.1.1.2.1 | sed 's/.*: //')
				APCPDU_AMP=`echo "scale=2; ${APCPDU_AMP}/10" | tr -d $'\r' | bc`
				APCPDU_WATT2=$(snmpwalk  -t 1 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.1.16.0 | sed 's/.*: //')
				APCPDU_WATT=`echo "scale=2; ${APCPDU_AMP}*${SVRRM_VOLTOUT}" | tr -d $'\r' | bc`
			# fi
			if [ "${SVRRM_VOLTOUT}" != "" ]; then
				if [ "${APCPDU_AMP}" != "" ]; then
					NETRK_AMP=`echo "scale=2; ${SVRRM_AMP}-${APCPDU_AMP}" | tr -d $'\r' | bc`
					NETRK_WATT=`echo "scale=2; ${SVRRM_WATT}-${APCPDU_WATT}" | tr -d $'\r' | bc`
					NETRK_WATT2=`echo "scale=2; ${SVRRM_WATT}-${APCPDU_WATT2}" | tr -d $'\r' | bc`
				fi
				VOLT_DROP=`echo "scale=1; ${OUTPUTV2}-${SVRRM_VOLTIN}" | tr -d $'\r' | bc`
			fi
		
		
			[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
			echo -e "${idsCL[White]}Inverter State           ${idsCL[Default]}: ${INV_STATE_disp}"
			if [ ${REPORT} -eq 0 ]; then
				echo -e "${idsCL[White]}Inverter Mode            ${idsCL[Default]}: ${INV_MODE_disp}"
				echo -e "${idsCL[White]}Inverter Alarms          ${idsCL[Default]}: ${INV_ALARM_disp}"
				echo -e "${idsCL[White]}Inverter Errors          ${idsCL[Default]}: ${INV_ERROR_disp}"
				echo
			fi
			echo -en "${idsCL[White]}Inverter Input Volts     ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${INPUTV}`'V"
			[ ${TESTMODE} -eq 1 ] && echo -e "  ${idsCL[Yellow]}***TEST MODE***" || echo ""
			echo -e "${idsCL[White]}Inverter Input Amps      ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${INPUTA}`'A"
			if [ ${REPORT} -eq 0 ]; then
				echo
				echo -e "${idsCL[White]}Inverter Output Volts    ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OUTPUTV}`'V / `IDS_NUMBER_FORMAT ${OUTPUTV2}`'V"
				echo -e "${idsCL[White]}Inverter Output Amps     ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OUTPUTA}`'A / `IDS_NUMBER_FORMAT ${OUTPUTA2}`'A"
				echo -e "${idsCL[White]}Inverter Output Watts    ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OUTPUTW} 0`'W"
				echo
			fi
		
			echo -en "${idsCL[White]}Battery Voltage          ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${BATTV}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)"
			([ ${TESTMODE} -eq 1 ] && [ "${TEST_BATTVOLT}" != "" ]) && echo -e "  ${idsCL[Yellow]}***TEST MODE***" || echo ""
			echo -e "${idsCL[White]}Battery Amps Chg/DChg    ${idsCL[Default]}: ${BATTA_disp}${idsCL[Default]}"
			echo
			echo -e "${idsCL[White]}Server Room Voltage IN   ${idsCL[Default]}: ${idsCL[Green]}${SVRRM_VOLTIN}'V${idsCL[Default]}"
			echo -e "${idsCL[White]}Server Room Voltage OUT  ${idsCL[Default]}: ${idsCL[Green]}${SVRRM_VOLTOUT}'V${idsCL[Default]}"
			[ ${REPORT} -eq 0 ] && echo -e "${idsCL[White]}Voltage Drop             ${idsCL[Default]}: ${idsCL[LightRed]}${VOLT_DROP}'V${idsCL[Default]}"
		
			# echo
			DIVIDER . lightCyan ${PRI_WIDTH}
			[ "${avgdays}" != "" ] && echo -e "							--${idsCL[LightYellow]}${avgdays_disp}-Averages---"
			echo -en "${idsCL[LightCyan]}Totals                     Amps        Watts"
			[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
		
			if [ ${REPORT} -eq 0 ]; then
				echo -en "\r\033[K"
				AD=$(IDS_NUMBER_FORMAT ${NETRK_AMP} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				MSG="${idsCL[White]}Network Rack ~est~       ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${NETRK_WATT} 1 yes`'W"
				echo -en "${MSG}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}	Calculating NetworkRack Averages ... "
					NETRK_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['network-rack']} ${avgdays} both)
					NETRK_AMP_avg=$(echo ${NETRK_avg} | cut -d'~' -f 1)
					NETRK_WATT_avg=$(echo ${NETRK_avg} | cut -d'~' -f 2)
					echo -en "\r\033[K"
				
					AS=$(IDS_NUMBER_FORMAT ${NETRK_WATT} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 5`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
					AD=$(IDS_NUMBER_FORMAT ${NETRK_AMP_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
					echo -e "${MSG}${idsCL[LightYellow]}${spcA}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${NETRK_WATT_avg} 1 yes`'W"
				else
					echo
				fi
						
				AD=$(IDS_NUMBER_FORMAT ${APCPDU_AMP} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				MSG="${idsCL[White]}Server Rack              ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${APCPDU_WATT} 1 yes`'W"
				echo -en "${MSG}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}	Calculating Server Rack Averages ... "
					APCPDU_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['server-rack']} ${avgdays} both)
					APCPDU_AMP_avg=$(echo ${APCPDU_avg} | cut -d'~' -f 1)
					APCPDU_WATT_avg=$(echo ${APCPDU_avg} | cut -d'~' -f 2)
					echo -en "\r\033[K"
				
					AS=$(IDS_NUMBER_FORMAT ${APCPDU_WATT} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 5`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
					AD=$(IDS_NUMBER_FORMAT ${APCPDU_AMP_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
					echo -e "${MSG}${idsCL[LightYellow]}${spcA}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${APCPDU_WATT_avg} 1 yes`'W"
				else
					echo
				fi
						
				AD=$(IDS_NUMBER_FORMAT ${SVRRM_AMP} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				MSG="${idsBG[Blue]}${idsCL[White]}Equipment Subtotal       ${idsCL[Default]}: ${idsCL[White]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SVRRM_WATT} 1 yes`'W ${idsBG[Default]}"
				echo -en "${MSG}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}	Calculating Equipment Subtotal Averages ... "
					SVRRM_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['total']} ${avgdays} both)
					SVRRM_AMP_avg=$(echo ${SVRRM_avg} | cut -d'~' -f 1)
					SVRRM_WATT_avg=$(echo ${SVRRM_avg} | cut -d'~' -f 2)
					echo -en "\r\033[K"
				
					AS=$(IDS_NUMBER_FORMAT ${SVRRM_WATT} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 4`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
					AD=$(IDS_NUMBER_FORMAT ${SVRRM_AMP_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
					echo -e "${MSG}${idsBG[Blue]}${spcA}${idsCL[LightYellow]}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${SVRRM_WATT_avg} 1 yes`'W ${idsBG[Default]}"
				else
					echo -e "${idsBG[Default]}"
				fi
			
				DIVIDER . lightCyan ${PRI_WIDTH}
			
				AD=$(IDS_NUMBER_FORMAT ${AIRCON_AMP} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				MSG="${idsCL[White]}Air Conditioner          ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${AIRCON_WATT} 1 yes`'W"
				echo -en "${MSG}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}	Calculating Air Conditioner Averages ... "
					AIRCON_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['ServerRoom-AC']} ${avgdays} both)
					AIRCON_AMP_avg=$(echo ${AIRCON_avg} | cut -d'~' -f 1)
					AIRCON_WATT_avg=$(echo ${AIRCON_avg} | cut -d'~' -f 2)
					echo -en "\r\033[K"
				
					AS=$(IDS_NUMBER_FORMAT ${AIRCON_WATT} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 5`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
					AD=$(IDS_NUMBER_FORMAT ${AIRCON_AMP_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
					echo -e "${MSG}${idsCL[LightYellow]}${spcA}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${AIRCON_WATT_avg} 1 yes`'W"
				else
					echo
				fi
						
				AD=$(IDS_NUMBER_FORMAT ${SVRRM_AMP_WAC} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				MSG="${idsBG[Blue]}${idsCL[White]}Server Room Total w/AIR  ${idsCL[Default]}: ${idsCL[White]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SVRRM_WATT_WAC} 1 yes`'W ${idsBG[Default]}"
				echo -en "${MSG}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}	Calculating Server Room w/AIR Total Averages ... "
				
					SVRRM_WAC_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['total-wac']} ${avgdays} both)
					SVRRM_AMP_WAC_avg=$(echo ${SVRRM_WAC_avg} | cut -d'~' -f 1)
					SVRRM_WATT_WAC_avg=$(echo ${SVRRM_WAC_avg} | cut -d'~' -f 2)
					echo -en "\r\033[K"
				
					AS=$(IDS_NUMBER_FORMAT ${SVRRM_WATT_WAC} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 4`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
					AD=$(IDS_NUMBER_FORMAT ${SVRRM_AMP_WAC_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
					echo -e "${MSG}${idsBG[Blue]}${spcA}${idsCL[LightYellow]}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${SVRRM_WATT_WAC_avg} 1 yes`'W ${idsBG[Default]}"
				else
					echo -e "${idsBG[Default]}"
				fi
			
				DIVIDER . lightCyan ${PRI_WIDTH}
			
			
				DIVIDER . lightCyan ${PRI_WIDTH}			
			fi
#########################################################################################################
		else ############### KYLE #########################################################################################################
		
			[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Yellow]}Pulling data from 'UPS' ... "
	
			
			if [ "$(CHECK_HOST ${PW_UPS_IP})" != "false" ]; then
				## VERTIV
				# UPS_STATUS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.3.9 | sed 's/.*: //')
				# UPS_VOLTIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				# UPS_VOLTOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.2.1 | sed 's/.*: //')
				# UPS_LOAD=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.2.2.1.11.3 | sed 's/.*: //')
				# UPS_LOAD=`echo "scale=2; ${UPS_LOAD}/10" | tr -d $'\r' | bc`
				# UPS_AMPSIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.3.3.1.4.1 | sed 's/.*: //')\
				# UPS_AMPSIN=`echo "scale=2; ${UPS_AMPSIN}/10" | tr -d $'\r' | bc`
				# UPS_AMPSOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.3.1 | sed 's/.*: //')\
				# UPS_AMPSOUT=`echo "scale=2; ${UPS_AMPSOUT}/10" | tr -d $'\r' | bc`
				# UPS_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.2.2.1.8.3 | sed 's/.*: //')
				# UPS_BATT_RUNTIME=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.18.0 | sed 's/.*: //')
				# UPS_BATT_VOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.10.0 | sed 's/.*: //')
				# UPS_BATT_CAP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.19.0 | sed 's/.*: //')
				
				## APC
				UPS_STATUS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.1.0 | sed 's/.*: //')
				UPS_VOLTIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				UPS_VOLTOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.2.1 | sed 's/.*: //')
				UPS_LOAD=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.5.1 | sed 's/.*: //')
				UPS_AMPSIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.3.3.1.4.1 | sed 's/.*: //')\
				#UPS_AMPSIN=`echo "scale=2; ${UPS_AMPSIN}/10" | tr -d $'\r' | bc`
				UPS_AMPSOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.3.1 | sed 's/.*: //')\
				UPS_AMPSOUT=`echo "scale=2; ${UPS_AMPSOUT}/10" | tr -d $'\r' | bc`
				# UPS_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.4.1 | sed 's/.*: //')
				UPS_WATTS=`echo "scale=2; ${UPS_VOLTOUT}*${UPS_AMPSOUT}" | tr -d $'\r' | bc`
				UPS_BATT_RUNTIME=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.3.0 | sed 's/.*: //')
				UPS_BATT_VOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.5.0 | sed 's/.*: //')
				UPS_BATT_VOLT=`echo "scale=2; ${UPS_BATT_VOLT}/10" | tr -d $'\r' | bc`
				UPS_BATT_CAP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.4.0 | sed 's/.*: //')
				
				[ "${PW_UPS_STATES[${UPS_STATUS}]}" != "" ] && UPS_DISP_STATUS=${PW_UPS_STATES[${UPS_STATUS}]} || UPS_DISP_STATUS=${UPS_STATUS}
			
				declare -A UPS_MISC
				for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
					UPS_MISC[${mSENSOR}]=$(GET_TUYA_POWER ${mSENSOR})
				done
			
			fi
		
			[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
		
			echo -e "${idsCL[White]}UPS Status               ${idsCL[Default]}: ${idsCL[LightCyan]}${UPS_DISP_STATUS}${idsCL[Default]}"
			if [ ${REPORT} -eq 0 ]; then
				echo
				echo -en "${idsCL[LightCyan]}                           Amps        Volts"
				[ "${avgdays}" != "" ] && echo -e "		Amps" || echo ""
				
				AD1=$(IDS_NUMBER_FORMAT ${UPS_AMPSIN} 2 yes); c=0; spc1=''; spca=`expr ${wspc} - ${#AD1}`; until [ ${c} = ${spca} ]; do spc1="${spc1} "; ((c++)); done
				echo -en "${idsCL[White]}UPS Input                ${idsCL[Default]}: ${idsCL[Green]}${AD1}'A${spc1}`IDS_NUMBER_FORMAT ${UPS_VOLTIN}`'V${idsCL[Default]}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}		Calculating ${avgdays_disp} Average ... "
					AMP_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['ups-input']} ${avgdays} amp)
					[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
					echo -e "${idsCL[White]}UPS Input                ${idsCL[Default]}: ${idsCL[Green]}${AD1}'A${spc1}`IDS_NUMBER_FORMAT ${UPS_VOLTIN}`'V${idsCL[LightYellow]}		${AMP_avg}'A${idsCL[Default]}"
				else
					echo ""
				fi
				
				AD2=$(IDS_NUMBER_FORMAT ${UPS_AMPSOUT} 2 yes); c=0; spc2=''; spca=`expr ${wspc} - ${#AD2}`; until [ ${c} = ${spca} ]; do spc2="${spc2} "; ((c++)); done
				echo -en "${idsCL[White]}UPS Output               ${idsCL[Default]}: ${idsCL[Green]}${AD2}'A${spc1}`IDS_NUMBER_FORMAT ${UPS_VOLTOUT}`'V${idsCL[Default]}"
				if [ "${avgdays}" != "" ]; then
					echo -en "${idsCL[Yellow]}		Calculating ${avgdays_disp} Average ... "
					AMP_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['ups-output']} ${avgdays} amp)
					[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
					echo -e "${idsCL[White]}UPS Output               ${idsCL[Default]}: ${idsCL[Green]}${AD2}'A${spc1}`IDS_NUMBER_FORMAT ${UPS_VOLTOUT}`'V${idsCL[LightYellow]}		${AMP_avg}'A${idsCL[Default]}"
				else
					echo ""
				fi
				
				echo
			fi
			echo -en "${idsCL[White]}UPS Load Usage           ${idsCL[Default]}: ${idsCL[Green]}${UPS_LOAD}'%${idsCL[Default]}"
			[ "${avgdays}" != "" ] && echo -e "${idsCL[LightCyan]}			Watts" || echo ""
			
			echo -en "${idsCL[White]}UPS Watts                ${idsCL[Default]}: ${idsCL[Green]}${UPS_WATTS}'W${idsCL[Default]}"
			if [ "${avgdays}" != "" ]; then
				echo -en "${idsCL[Yellow]}			Calculating ${avgdays_disp} Average ... "
				WATT_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['ups-output']} ${avgdays} watt)
				[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
				echo -e "${idsCL[White]}UPS Watts                ${idsCL[Default]}: ${idsCL[Green]}${UPS_WATTS}'W${idsCL[LightYellow]}			${WATT_avg}'W${idsCL[Default]}"
			else
				echo ""
			fi
			[ ${REPORT} -eq 0 ] && echo
			[ ${REPORT} -eq 0 ] && echo -e "${idsCL[White]}UPS Battery Voltage      ${idsCL[Default]}: ${idsCL[Green]}${UPS_BATT_VOLT}'V${idsCL[Default]}"
			echo -e "${idsCL[White]}UPS Battery Capacity     ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${UPS_BATT_CAP}`'%${idsCL[Default]}"
			echo -e "${idsCL[White]}UPS Battery Runtime      ${idsCL[Default]}: ${idsCL[Green]}${UPS_BATT_RUNTIME}'mins${idsCL[Default]}"
			[ ${REPORT} -eq 0 ] && echo
		
			TOTAL_MISC_WATTS=0; TOTAL_MISC_AMPS=0
			if [ ${REPORT} -eq 0 ]; then
				echo -en "${idsCL[LightCyan]}Misc Sensors               Amps        Watts"
				[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo -e "       Volts"
			fi
			for mSENSOR in "${!UPS_MISC[@]}"; do
				IFS=: read -r AMP WATT VOLT <<< ${UPS_MISC[${mSENSOR}]}; unset IFS
				TOTAL_MISC_WATTS=`echo "scale=2; ${TOTAL_MISC_WATTS}+${WATT}" | tr -d $'\r' | bc`
				TOTAL_MISC_AMPS=`echo "scale=2; ${TOTAL_MISC_AMPS}+${AMP}" | tr -d $'\r' | bc`
				AD1="${PW_MISCSENSOR_DESC[${mSENSOR}]}"; c=0; spc1=''; spca=`expr 25 - ${#AD1}`; until [ ${c} = ${spca} ]; do spc1="${spc1} "; ((c++)); done
				AD2=$(IDS_NUMBER_FORMAT ${AMP} 2 yes); c=0; spc2=''; spca=`expr ${wspc} - ${#AD2}`; until [ ${c} = ${spca} ]; do spc2="${spc2} "; ((c++)); done
				AD3=$(IDS_NUMBER_FORMAT ${WATT} 1 yes)
		
				[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Default]}${AD1}${spc1}: ${idsCL[Green]}${AD2}'A${spc2}${AD3}'W"
				if [ "${avgdays}" == "" ]; then
					c=0; spc3=''; spca=`expr ${wspc} - ${#AD3}`; until [ ${c} = ${spca} ]; do spc3="${spc3} "; ((c++)); done
					[ ${REPORT} -eq 0 ] && echo -e "${spc3}${VOLT}'V${idsCL[Default]}"
				else
					echo -en "${idsCL[Yellow]}		Calculating ${avgdays_disp} Average ... "
					avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID[${mSENSOR}]} ${avgdays} both)
					AMP_avg=$(echo ${avg} | cut -d'~' -f 1)
					WATT_avg=$(echo ${avg} | cut -d'~' -f 2)
					[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
					echo -en "${idsCL[Default]}${AD1}${spc1}: ${idsCL[Green]}${AD2}'A${spc2}${AD3}'W"
			
					AD=$(IDS_NUMBER_FORMAT ${AMP_avg} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
					echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${WATT_avg} 1 yes`'W"
				fi
			done
		
			# DIVIDER . lightCyan ${PRI_WIDTH}
			# [ "${avgdays}" != "" ] && echo -e "							--${idsCL[LightYellow]}${avgdays_disp}-Averages---"
			# echo -en "${idsCL[LightCyan]}Totals                     Amps        Watts"
			# [ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
			# AW=${TOTAL_MISC_WATTS}
			# AD=$(IDS_NUMBER_FORMAT ${TOTAL_MISC_AMPS} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
			# echo -en "${idsCL[White]}Mainsite Equipment       ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${AW} 1 yes`'W"
			# if [ "${avgdays}" != "" ]; then
			# 	echo -en "${idsCL[Yellow]}	Calculating Mainsite Equipment Total Averages ... "
			# 	UPS_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['mainsite-ups']} ${avgdays} both)
			# 	UPS_AMP_avg=$(echo ${UPS_avg} | cut -d'~' -f 1)
			# 	UPS_WATT_avg=$(echo ${UPS_avg} | cut -d'~' -f 2)
			# 	echo -en "\r\033[K"
			# 	echo -en "${idsCL[White]}Mainsite Equipment        ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${AW} 1 yes`'W"
			#
			# 	AD=$(IDS_NUMBER_FORMAT ${OFFSITE_AMP_avg} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
			# 	echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${OFFSITE_WATT_avg} 1 yes`'W"
			# else
			# 	echo
			# fi
			
			
		fi
		
		[ ${REPORT} -eq 0 ] && echo -e "${idsCL[Default]}"
		
	fi
	
	if ([ "${STYPE}" = "" ] || [ "${STYPE}" = "offsite" ]) && [ "${PTYPE}" != "esxi" ] && [[ "${IP}" != "10.6.1"* ]]; then
			
		DIVIDER . yellow ${PRI_WIDTH}
		echo -en "${idsCL[Yellow]}Offsite Power Information"
		[ "${avgdays}" != "" ] && echo -e "				${idsCL[LightYellow]}--${avgdays_disp}-Averages---" || echo
		DIVIDER . yellow ${PRI_WIDTH}
		
		[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Yellow]}Pulling data from 'Offsite' ... "
	
		[ "${PW_OFFSITE_MONITOR}" == "${IP}" ] && upsinfo=$(upsc offsite-ups 2>&1) || upsinfo=$(${SSHCMD} root@${PW_OFFSITE_MONITOR} 'upsc offsite-ups 2>&1')
		if [ "$(echo "${upsinfo}" | grep 'input.voltage:')" != "" ]; then
			OFFSITE_STATUS=$(echo "${upsinfo}" | grep 'ups.status:' | sed 's/.*: //' | tr -d $'\r')
			[ "${PW_OFFSITE_UPS_CODES[${OFFSITE_STATUS}]}" != "" ] && OFFSITE_STATUS=${PW_OFFSITE_UPS_CODES[${OFFSITE_STATUS}]} || OFFSITE_STATUS=${OFFSITE_STATUS}
			OFFSITE_VOLTIN=$(echo "${upsinfo}" | grep 'input.voltage:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_VOLTOUT=$(echo "${upsinfo}" | grep 'output.voltage:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_LOAD=$(echo "${upsinfo}" | grep 'ups.load:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_WATTS=`echo "scale=2; $(echo "scale=2; ${OFFSITE_LOAD}/100" | tr -d $'\r' | bc)*$(echo "${upsinfo}" | grep 'ups.realpower.nominal:' | sed 's/.*: //')" | tr -d $'\r' | bc`
			OFFSITE_AMPS=`echo "scale=2; ${OFFSITE_WATTS}/${OFFSITE_VOLTOUT}" | tr -d $'\r' | bc`
			(( $(bc <<<"${OFFSITE_AMPS} < 1") )) && [[ "${OFFSITE_AMPS}" = *"."* ]] && OFFSITE_AMPS="0${OFFSITE_AMPS}"
			OFFSITE_BATT_RUNTIME=$(echo "${upsinfo}" | grep 'battery.runtime:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_BATT_RUNTIME=`echo "scale=2; ${OFFSITE_BATT_RUNTIME}/60" | tr -d $'\r' | bc`
			OFFSITE_BATT_VOLT=$(echo "${upsinfo}" | grep 'battery.voltage:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_BATT_CAP=$(echo "${upsinfo}" | grep 'battery.charge:' | sed 's/.*: //' | tr -d $'\r')
			
			declare -A OFFSITE_MISC
			for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
				OFFSITE_MISC[${mSENSOR}]=$(GET_TUYA_POWER ${mSENSOR})
			done
			
		fi
		
		[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
		
		echo -e "${idsCL[White]}UPS Status               ${idsCL[Default]}: ${idsCL[LightCyan]}${OFFSITE_STATUS}${idsCL[Default]}"
		if [ ${REPORT} -eq 0 ]; then
			echo
			echo -e "${idsCL[White]}UPS Voltage In           ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OFFSITE_VOLTIN}`'V${idsCL[Default]}"
			echo -e "${idsCL[White]}UPS Voltage Out          ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OFFSITE_VOLTOUT}`'V${idsCL[Default]}"
		fi
		echo -e "${idsCL[White]}UPS Load Usage           ${idsCL[Default]}: ${idsCL[Green]}${OFFSITE_LOAD}'%${idsCL[Default]}"
		[ ${REPORT} -eq 0 ] && echo
		echo -e "${idsCL[White]}UPS Battery Capacity     ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OFFSITE_BATT_CAP}`'%${idsCL[Default]}"
		echo -e "${idsCL[White]}UPS Battery Runtime      ${idsCL[Default]}: ${idsCL[Green]}${OFFSITE_BATT_RUNTIME}'mins${idsCL[Default]}"
		if [ ${REPORT} -eq 0 ]; then
			echo -e "${idsCL[White]}UPS Battery Voltage      ${idsCL[Default]}: ${idsCL[Green]}${OFFSITE_BATT_VOLT}'V${idsCL[Default]}"
			echo
		fi
		
		TOTAL_MISC_WATTS=0; TOTAL_MISC_AMPS=0
		if [ ${REPORT} -eq 0 ]; then
			echo -en "${idsCL[LightCyan]}Misc Sensors               Amps        Watts"
			[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo -e "       Volts"
		fi
		for mSENSOR in "${!OFFSITE_MISC[@]}"; do
			IFS=: read -r AMP WATT VOLT <<< ${OFFSITE_MISC[${mSENSOR}]}; unset IFS
			TOTAL_MISC_WATTS=`echo "scale=2; ${TOTAL_MISC_WATTS}+${WATT}" | tr -d $'\r' | bc`
			TOTAL_MISC_AMPS=`echo "scale=2; ${TOTAL_MISC_AMPS}+${AMP}" | tr -d $'\r' | bc`
			AD1="${PW_MISCSENSOR_DESC[${mSENSOR}]}"; c=0; spc1=''; spca=`expr 25 - ${#AD1}`; until [ ${c} = ${spca} ]; do spc1="${spc1} "; ((c++)); done
			AD2=$(IDS_NUMBER_FORMAT ${AMP} 2 yes); c=0; spc2=''; spca=`expr ${wspc} - ${#AD2}`; until [ ${c} = ${spca} ]; do spc2="${spc2} "; ((c++)); done
			AD3=$(IDS_NUMBER_FORMAT ${WATT} 1 yes)
		
			[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Default]}${AD1}${spc1}: ${idsCL[Green]}${AD2}'A${spc2}${AD3}'W"
			if [ "${avgdays}" == "" ]; then
				c=0; spc3=''; spca=`expr ${wspc} - ${#AD3}`; until [ ${c} = ${spca} ]; do spc3="${spc3} "; ((c++)); done
				[ ${REPORT} -eq 0 ] && echo -e "${spc3}${VOLT}'V${idsCL[Default]}"
			else
				echo -en "${idsCL[Yellow]}	Calculating ${avgdays_disp} Average ... "
				avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID[${mSENSOR}]} ${avgdays} both)
				AMP_avg=$(echo ${avg} | cut -d'~' -f 1)
				WATT_avg=$(echo ${avg} | cut -d'~' -f 2)
				[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
				echo -en "${idsCL[Default]}${AD1}${spc1}: ${idsCL[Green]}${AD2}'A${spc2}${AD3}'W"
			
				AD=$(IDS_NUMBER_FORMAT ${AMP_avg} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${WATT_avg} 1 yes`'W"
			fi
		done
		
		DIVIDER . lightCyan ${PRI_WIDTH}
		[ "${avgdays}" != "" ] && echo -e "							--${idsCL[LightYellow]}${avgdays_disp}-Averages---"
		echo -en "${idsCL[LightCyan]}Totals                     Amps        Watts"
		[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
		if (( $(bc <<<"${OFFSITE_WATTS} < ${TOTAL_MISC_WATTS}") )); then
			AW=${TOTAL_MISC_WATTS}
			AD=${TOTAL_MISC_AMPS}
		else
			AW=${OFFSITE_WATTS}
			AD=${OFFSITE_AMPS}
		fi
		AD=$(IDS_NUMBER_FORMAT ${AD} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
		echo -en "${idsCL[White]}Offsite Equipment        ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${AW} 1 yes`'W"
		if [ "${avgdays}" != "" ]; then
			echo -en "${idsCL[Yellow]}	Calculating Offsite Equipment Total Averages ... "
			OFFSITE_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['offsite-ups']} ${avgdays} both)
			OFFSITE_AMP_avg=$(echo ${OFFSITE_avg} | cut -d'~' -f 1)
			OFFSITE_WATT_avg=$(echo ${OFFSITE_avg} | cut -d'~' -f 2)
			echo -en "\r\033[K"
			echo -en "${idsCL[White]}Offsite Equipment        ${idsCL[Default]}: ${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${AW} 1 yes`'W"
			
			AD=$(IDS_NUMBER_FORMAT ${OFFSITE_AMP_avg} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
			echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${OFFSITE_WATT_avg} 1 yes`'W"
		else
			echo
		fi
				
		# echo -en "${idsCL[White]}Total Amps               ${idsCL[Default]}: ${idsCL[Green]}${AD}'A ${idsCL[Default]}~ est${idsCL[Green]}${idsCL[Default]}"
		# [ "${avgdays}" != "" ] && echo -e "${idsCL[LightYellow]}		`IDS_NUMBER_FORMAT ${OFFSITE_AMP_avg}`'A" || echo -e "${idsCL[Default]}"
		# echo -en "${idsCL[White]}Total Wattage            ${idsCL[Default]}: ${idsCL[Green]}`IDS_NUMBER_FORMAT ${OFFSITE_WATTS} 0`'W ${idsCL[Default]}~ est"
		# [ "${avgdays}" != "" ] && echo -e "${idsCL[LightYellow]}		`IDS_NUMBER_FORMAT ${OFFSITE_WATT_avg} 0`'W" || echo -e "${idsCL[Default]}\n"
		#
	fi
	
	########## KYLE #############
	if ([ "${STYPE}" = "" ] || [ "${STYPE}" = "kyle" ]) && [ "${PTYPE}" != "esxi" ] && [[ "${IP}" != "10.6.1"* ]]; then
		echo
		DIVIDER . yellow ${PRI_WIDTH}
		echo -en "${idsCL[Yellow]}Kyle's Power Information"
		[ "${avgdays}" != "" ] && echo -e "				${idsCL[LightYellow]}--${avgdays_disp}-Averages---" || echo
		DIVIDER . yellow ${PRI_WIDTH}
		echo -en "${idsCL[LightCyan]}                           Amps        Watts"
		[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
		DIVIDER . lightCyan ${PRI_WIDTH}
		[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Yellow]}Pulling data from Kyle's Equipment ... "
		
		KYLE_INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS['KP-Power']}:8888/status/${PW_SENSOR_DEVICEID['KP-Power']} | jq '.dps')
		if [ "${KYLE_INFO}" != "" ]; then
			KYLE_AMP=$(echo "${KYLE_INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g')
			KYLE_AMP=$(ROUND_NUMBER $(echo "scale=3; ${KYLE_AMP}/1000" | tr -d $'\r' | bc -l) 2)
			KYLE_WATT=$(echo "${KYLE_INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g')
			KYLE_WATT=$(echo "scale=1; ${KYLE_WATT}/10" | tr -d $'\r' | bc -l)
		else
			KYLE_AMP=0
			KYLE_WATT=0
		fi
		[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"		
		
		AD=$(IDS_NUMBER_FORMAT ${KYLE_AMP} 2 yes); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
		MSG="${idsCL[White]}Outlet #7 Power          ${idsCL[Default]}: ${idsCL[White]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${KYLE_WATT} 1 yes`'W ${idsCL[Default]}"
		echo -en "${MSG}"
		if [ "${avgdays}" != "" ]; then
			echo -en "${idsCL[Yellow]}	Calculating Kyle's Total Power Averages ... "
			
			KYLE_POWER_avg=$(AVERAGEPOWER ${PW_POWERSENSOR_ID['KP-Power']} ${avgdays} both)
			KYLE_AMP_avg=$(echo ${KYLE_POWER_avg} | cut -d'~' -f 1)
			KYLE_WATT_avg=$(echo ${KYLE_POWER_avg} | cut -d'~' -f 2)
			echo -en "\r\033[K"
			
			AS=$(IDS_NUMBER_FORMAT ${KYLE_WATT} 1 yes); c=0; spcA=''; spc1=`expr ${wspc} - ${#AS} + 4`; until [ ${c} = ${spc1} ]; do spcA="${spcA} "; ((c++)); done
			AD=$(IDS_NUMBER_FORMAT ${KYLE_AMP_avg} 2 yes); c=0; spcB=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spcB="${spcB} "; ((c++)); done
			echo -e "${MSG}${spcA}${idsCL[LightYellow]}${AD}'A${spcB}`IDS_NUMBER_FORMAT ${KYLE_WATT_avg} 1 yes`'W ${idsCL[Default]}"
		else
			echo -e "${idsCL[Default]}"
		fi		
	fi
	
	
	[ ${REPORT} -eq 0 ] && echo -e "${idsCL[Default]}"
	
	if [ "${PTYPE}" != "power" ]; then
		DIVIDER . yellow ${PRI_WIDTH}
		echo -e "${idsCL[Yellow]}ESXi Host Power Information"
		DIVIDER . yellow ${PRI_WIDTH}
		[ "${avgdays}" != "" ] && echo -e "							--${idsCL[LightYellow]}${avgdays_disp}-Averages---"
		echo -en "${idsCL[LightCyan]}	                   Amps        Watts"
		[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
		DIVIDER . lightCyan ${PRI_WIDTH}
		
		SENSOR_TOTAL_WATTS_MAINSITE=0
		SENSOR_TOTAL_AMPS_MAINSITE=0
		SENSOR_TOTAL_WATTS_OFFSITE=0
		SENSOR_TOTAL_AMPS_OFFSITE=0
		SENSOR_TOTAL_WATTS_KYLE=0
		SENSOR_TOTAL_AMPS_KYLE=0
		SENSOR_TOTAL_WATTS=0
		SENSOR_TOTAL_AMPS=0
		if [ "${avgdays}" != "" ]; then
			AVERAGE_WATTS_MAINSITE=0
			AVERAGE_AMPS_MAINSITE=0
			AVERAGE_WATTS_OFFSITE=0
			AVERAGE_AMPS_OFFSITE=0
			AVERAGE_WATTS_KYLE=0
			AVERAGE_AMPS_KYLE=0
			AVERAGE_TOTAL_WATTS=0
			AVERAGE_TOTAL_AMPS=0
		fi
		
		for SENSOR in ${PW_SENSOR_ORD[@]}; do
			if [ "${PW_HOST_IDRACS[${SENSOR}]}" != "" ]; then
				[[ "${PW_HOST_IDRACS[${SENSOR}]}" = "10.6."* ]] && ESXI_PASS=${PW_ESXI_PASS_KP} || ESXI_PASS=${PW_ESXI_PASS}
				if [ "${STYPE}" = "" ] || ([ "${STYPE}" = "mainsite" ] && [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.10."* ]]) || ([ "${STYPE}" = "offsite" ] && [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.2.1."* ]]) || ([ "${STYPE}" = "kyle" ] && [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.6."* ]]); then
					[ ${REPORT} -eq 0 ] && echo -en "${idsCL[Yellow]}Pulling data for '${SENSOR}' ... "
				
					HOST_WATT_SENSORS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1 -O vq 2> /dev/null | sed -e 's/"//g')
					IFS=$'\n'
					read -rd '' -a HOST_WATT_SENSORS <<<"${HOST_WATT_SENSORS}"
					unset IFS
					PS1='0.0'; PS2='0.0'; HOST_WATTS=0
					if [ "${HOST_WATT_SENSORS}" != "" ]; then
						found=0
						for s in {1..5}; do
							DP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1.${s} | sed 's/.*: //')
							if [[ "${DP}" = *"System Board"* ]]; then
								found=1
								HOST_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
						
							elif [[ "${DP}" = *"PS1"* ]]; then
								PS1=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							elif [[ "${DP}" = *"PS2"* ]]; then
								PS2=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							fi
						done
						PS1V=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.12.1.16.1.1 | sed 's/.*: //')
						PS2V=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.12.1.16.1.2 | sed 's/.*: //')
						
						if [ ${found} -eq 1 ] && [ "${HOST_WATTS}" != "0" ] && [ "${HOST_WATTS}" != "" ]; then
							[ "${PS1}" != "0.0" ] && PS1=`echo "scale=1; ${PS1}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS1} < 1") )) && [[ "${PS1}" = *"."* ]] && PS1="0${PS1}"
							[ "${PS2}" != "0.0" ] && PS2=`echo "scale=1; ${PS2}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS2} < 1") )) && [[ "${PS2}" = *"."* ]] && PS2="0${PS2}"
							HOST_AMPS=`echo "scale=1; ${PS1}+${PS2}" | tr -d $'\r' | bc`
							AD=$(IDS_NUMBER_FORMAT ${HOST_AMPS} 1 true); c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
							HOST_WATTS_disp="${idsCL[Green]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${HOST_WATTS} 0`'W"
							
						elif [ ! -f ${PW_TMPFOLDER}/${SENSOR}.down ] && [ "$(ipmitool -I lanplus -H ${PW_HOST_IDRACS[${SENSOR}]} -U ${PW_ESXI_USER} -P "${ESXI_PASS}" chassis power status | grep off)" != "" ]; then
							HOST_WATTS_disp="${idsCL[LightRed]}Host powered down"
							HOST_WATTS=-1
						elif [ "${HOST_WATTS}" = "0" ]; then
							HOST_WATTS_disp="${idsCL[Yellow]}Host PSU not capable"
							HOST_WATTS=-2
						else
							HOST_WATTS_disp="${idsCL[LightRed]}Could not pull data"
						fi
						
						[ "${HOST_WATTS}" = "" ] && HOST_WATTS=0
						
					else
						HOST_WATTS_disp="${idsCL[LightRed]}Host offline"
					fi

					[ ${REPORT} -eq 0 ] && echo -en "\r\033[K"
					c=0; spc=''; spc1=`expr 25 - ${#SENSOR}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
					MSG="${idsCL[White]}${SENSOR}${spc}${idsCL[Default]}: ${HOST_WATTS_disp}"
					echo -en "${MSG}"
					
					if [ "${avgdays}" != "" ] && [ ${HOST_WATTS} -ne -2 ] && [ "${SENSOR}" != "iDS-vMS-Host6" ]; then
						echo -en "${idsCL[LightYellow]}		Calculating average ...${idsCL[Default]}"
						# AVERAGEPOWER ${PW_POWERSENSOR_ID[${SENSOR}]} ${avgdays} both
						average=$(AVERAGEPOWER ${PW_POWERSENSOR_ID[${SENSOR}]} ${avgdays} both)
						average_amp=$(echo ${average} | cut -d'~' -f 1)
						average_watt=$(echo ${average} | cut -d'~' -f 2)
						AD=${average_amp}; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
						average_disp="		`IDS_NUMBER_FORMAT ${AD} 1 true`'A${spc}`IDS_NUMBER_FORMAT ${average_watt} 0`'W"
						echo -en "\r\033[K"
						echo -e "${MSG}${idsCL[LightYellow]}${average_disp}${idsCL[Default]}"
						
						if [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.10."* ]]; then
							AVERAGE_WATTS_MAINSITE=`echo "scale=2; ${AVERAGE_WATTS_MAINSITE}+${average_watt}" | tr -d $'\r' | bc`
							AVERAGE_AMPS_MAINSITE=`echo "scale=2; ${AVERAGE_AMPS_MAINSITE}+${average_amp}" | tr -d $'\r' | bc`							
						elif [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.2.1."* ]]; then
							AVERAGE_WATTS_OFFSITE=`echo "scale=2; ${AVERAGE_WATTS_OFFSITE}+${average_watt}" | tr -d $'\r' | bc`
							AVERAGE_AMPS_OFFSITE=`echo "scale=2; ${AVERAGE_AMPS_OFFSITE}+${average_amp}" | tr -d $'\r' | bc`
						elif [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.6."* ]]; then
							AVERAGE_WATTS_KYLE=`echo "scale=2; ${AVERAGE_WATTS_KYLE}+${average_watt}" | tr -d $'\r' | bc`
							AVERAGE_AMPS_KYLE=`echo "scale=2; ${AVERAGE_AMPS_KYLE}+${average_amp}" | tr -d $'\r' | bc`
						fi
						AVERAGE_TOTAL_WATTS=`echo "scale=2; ${AVERAGE_TOTAL_WATTS}+${average_watt}" | tr -d $'\r' | bc`
						AVERAGE_TOTAL_AMPS=`echo "scale=2; ${AVERAGE_TOTAL_AMPS}+${average_amp}" | tr -d $'\r' | bc`
						
					else
						echo -e "${idsCL[Default]}"
					fi
					
					if [ ${HOST_WATTS} -gt 0 ]; then
						DIVIDER . darkGray ${PRI_WIDTH}
						echo -e "  PS1			 : ${idsCL[Green]}`IDS_NUMBER_FORMAT ${PS1} 1 true`'A ${idsCL[Default]}@${idsCL[LightCyan]} ${PS1V}'V${idsCL[Default]}"
						echo -e "  PS2			 : ${idsCL[Green]}`IDS_NUMBER_FORMAT ${PS2} 1 true`'A ${idsCL[Default]}@${idsCL[LightCyan]} ${PS2V}'V${idsCL[Default]}"
					fi
					[ "${SENSOR}" != "KP-vMS-Host1" ] && DIVIDER . lightCyan ${PRI_WIDTH}
					
					if [ "${HOST_WATT_SENSORS}" != "" ] && [ ${HOST_WATTS} -gt 0 ]; then
						if [[ "${IP}" != "10.6.1"* ]]; then
							if [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.10."* ]]; then
								SENSOR_TOTAL_WATTS_MAINSITE=$(expr ${SENSOR_TOTAL_WATTS_MAINSITE} + ${HOST_WATTS})
								SENSOR_TOTAL_AMPS_MAINSITE=$(echo "scale=1; ${SENSOR_TOTAL_AMPS_MAINSITE}+${HOST_AMPS}" | tr -d $'\r' | bc)
							elif [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.2.1."* ]]; then
								SENSOR_TOTAL_WATTS_OFFSITE=$(expr ${SENSOR_TOTAL_WATTS_OFFSITE} + ${HOST_WATTS})
								SENSOR_TOTAL_AMPS_OFFSITE=$(echo "scale=1; ${SENSOR_TOTAL_AMPS_OFFSITE}+${HOST_AMPS}" | tr -d $'\r' | bc)
							elif [[ "${PW_HOST_IDRACS[${SENSOR}]}" = *"10.6."* ]]; then
								SENSOR_TOTAL_WATTS_KYLE=$(expr ${SENSOR_TOTAL_WATTS_KYLE} + ${HOST_WATTS})
								SENSOR_TOTAL_AMPS_KYLE=$(echo "scale=1; ${SENSOR_TOTAL_AMPS_KYLE}+${HOST_AMPS}" | tr -d $'\r' | bc)
							fi
						fi
						SENSOR_TOTAL_WATTS=$(expr ${SENSOR_TOTAL_WATTS} + ${HOST_WATTS})						
						SENSOR_TOTAL_AMPS=$(echo "scale=1; ${SENSOR_TOTAL_AMPS}+${HOST_AMPS}" | tr -d $'\r' | bc)
					fi
				fi
			fi
		done
		if [[ "${IP}" != "10.6.1"* ]]; then
			DIVIDER . lightCyan ${PRI_WIDTH}
			echo -en "${idsCL[LightCyan]}TOTALS	                   Amps        Watts"
			[ "${avgdays}" != "" ] && echo -e "		Amps        Watts" || echo
			DIVIDER . lightCyan ${PRI_WIDTH}
			if [ "${STYPE}" = "" ] || [ "${STYPE}" = "mainsite" ]; then
				AD=`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_AMPS_MAINSITE} 1 true`; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				echo -en "${idsCL[LightCyan]}Mainsite ESXi Total      ${idsCL[Default]}: ${idsCL[LightGreen]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_WATTS_MAINSITE} 0`'W "
				[ "${avgdays}" != "" ] && AD=`IDS_NUMBER_FORMAT ${AVERAGE_AMPS_MAINSITE} 1 true`; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				[ "${avgdays}" != "" ] && echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${AVERAGE_WATTS_MAINSITE} 0`'W" || echo
			fi
			if [ "${STYPE}" = "" ] || [ "${STYPE}" = "offsite" ]; then
				AD=`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_AMPS_OFFSITE} 1 true`; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				echo -en "${idsCL[LightCyan]}Offsite ESXi Total       ${idsCL[Default]}: ${idsCL[LightGreen]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_WATTS_OFFSITE} 0`'W   "
				[ "${avgdays}" != "" ] && AD=${AVERAGE_AMPS_OFFSITE}; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				[ "${avgdays}" != "" ] && echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${AVERAGE_WATTS_OFFSITE} 0`'W" || echo
			fi
			if [ "${STYPE}" = "" ] || [ "${STYPE}" = "kyle" ]; then
				AD=`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_AMPS_KYLE} 1 true`; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				echo -en "${idsCL[LightCyan]}Kyle ESXi Total          ${idsCL[Default]}: ${idsCL[LightGreen]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_WATTS_KYLE} 0`'W   "
				[ "${avgdays}" != "" ] && AD=${AVERAGE_AMPS_KYLE}; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				[ "${avgdays}" != "" ] && echo -e "${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${AVERAGE_WATTS_KYLE} 0`'W" || echo
			fi
		fi
		
		if [ "${STYPE}" = "" ]; then
			DIVIDER . yellow ${PRI_WIDTH}
			AD=`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_AMPS} 1 true`; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
			echo -en "${idsBG[Blue]}${idsCL[White]}ESXi Total               ${idsCL[Default]}: ${idsCL[White]}${AD}'A${spc}`IDS_NUMBER_FORMAT ${SENSOR_TOTAL_WATTS} 0`'W   "
			[ "${avgdays}" != "" ] && AD=${AVERAGE_TOTAL_AMPS}; c=0; spc=''; spc1=`expr ${wspc} - ${#AD}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
			[ "${avgdays}" != "" ] && echo -e "${idsBG[Blue]}${idsCL[LightYellow]}		${AD}'A${spc}`IDS_NUMBER_FORMAT ${AVERAGE_TOTAL_WATTS} 0`'W${idsBG[Default]}" || echo -e "${idsBG[Default]}"
		fi
		
		
		
	fi
	if [ ${REPORT} -eq 0 ]; then
		if [ "${avgdays}" != "" ]; then
			modend=`date +%s`; modruntime=$((modend-modstart)); echo -e "\n${idsCL[Default]}script runtime: ${modruntime}s"
		fi
		[ "${PW_ACTION}" != "" ] && echo -e "${idsCL[Default]}"
	fi
}
		
CHECKPOWER_SERVICE(){
	touch ${PW_TMPFOLDER}/power.ac.start
	touch ${PW_TMPFOLDER}/power.dc.start
	[ "${PW_SERVICE_POWER_SCANRATE}" != "" ] && runEvery=${PW_SERVICE_POWER_SCANRATE} || runEvery=10
	while true; do
		start=$(date +%s)
		log_start=$(date "+%Y-%m-%d %H:%M:%S")
		source ${PW_FOLDER}/defaults.inc
				
		if [[ "${IP}" != "10.6.1"* ]]; then
		
			INVSTATSINFO=$(curl -m 3 -s "http://${PW_INVERTER_IP}/stats.json")
			SVRRM_UPS_INPUTACV=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.2.2.1.3.1.1 | sed 's/.*: //')
		
			if (( $(bc <<<"${SVRRM_UPS_INPUTACV} < ${min_acvolt}") )); then
				if [ ! -f ${PW_TMPFOLDER}/power.ups.low ]; then
					touch ${PW_TMPFOLDER}/power.ups.low
				
				elif [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.ups.low)) -ge 60 ]; then
					SENDNOTICE "POWER ALERT - UPS POWER OFF/LOW POWER!!" "UPS has no power for 1min, shutting all servers down!" 1
				
				
					######################### FINISH
				
				
				fi
			
			elif [ -f ${PW_TMPFOLDER}/power.ups.low ]; then
				rm -f ${PW_TMPFOLDER}/power.ups.low
			fi
			
		else
			[ "$(CHECK_HOST ${PW_UPS_IP})" != "false" ] && INVSTATSINFO=1
			
		fi
		
		if [ "${INVSTATSINFO}" != "" ] || [ ${TESTMODE} -eq 1 ]; then
			if [[ "${IP}" == "10.6.1"* ]]; then
				## VERTIV
				# ([ ${TESTMODE} -eq 1 ] && [ "${TEST_INPUTACV}" != "" ]) && INPUTACV=${TEST_INPUTACV} || INPUTACV=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				# ([ ${TESTMODE} -eq 1 ] && [ "${TEST_BATTVOLT}" != "" ]) && BATTVOLT=${TEST_BATTVOLT} || BATTVOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.10.0 | sed 's/.*: //')
				## APC
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_INPUTACV}" != "" ]) && INPUTACV=${TEST_INPUTACV} || INPUTACV=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_BATTVOLT}" != "" ]) && BATTVOLT=${TEST_BATTVOLT} || BATTVOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.5.0 | sed 's/.*: //')
				
				BATTLIFE=`echo "scale=2; (${BATTVOLT}*100)/${BATT_FULL}" | tr -d $'\r' | bc`
			else
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_INPUTACV}" != "" ]) && INPUTACV=${TEST_INPUTACV} || INPUTACV=$(echo ${INVSTATSINFO} | jq '.inputs .inV' | tr -d $'\r')
				([ ${TESTMODE} -eq 1 ] && [ "${TEST_BATTVOLT}" != "" ]) && BATTVOLT=${TEST_BATTVOLT} || BATTVOLT=$(echo ${INVSTATSINFO} | jq '.inputs .battV' | tr -d $'\r')
				BATTA=`echo ${INVSTATSINFO} | jq '.inputs .xfA'`
				BATTLIFE=`echo "scale=2; (${BATTVOLT}*100)/${BATT_FULL}" | tr -d $'\r' | bc`
			fi
			PW_DISCHARGE=0
			
			if [ ${TESTMODE} -eq 1 ] && [ ! -f ${PW_TMPFOLDER}/power.testmode.enabled ]; then
				touch ${PW_TMPFOLDER}/power.testmode.enabled
				SENDNOTICE "TEST MODE" "***TEST MODE*** ENABLED!"
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - Input: ${INPUTACV}'V - Battery: ${BATTVOLT}'V - ***TEST MODE*** ENABLED" >> ${PW_LOGFILE}
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - Input: ${INPUTACV}'V - Battery: ${BATTVOLT}'V - ***TEST MODE*** ENABLED" >> ${PW_LOGPOWER}
			elif [ ${TESTMODE} -eq 0 ] && [ -f ${PW_TMPFOLDER}/power.testmode.enabled ]; then
				rm -f ${PW_TMPFOLDER}/power.testmode.enabled
				SENDNOTICE "TEST MODE" "***TEST MODE*** DISABLED!"
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - Input: ${INPUTACV}'V - Battery: ${BATTVOLT}'V - ***TEST MODE*** DISABLED" >> ${PW_LOGFILE}
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - Input: ${INPUTACV}'V - Battery: ${BATTVOLT}'V - ***TEST MODE*** DISABLED" >> ${PW_LOGPOWER}
			fi
			
			[ ! "${last_battvolt}" ] && last_battvolt=${BATTVOLT}
			
			if (( $(bc <<<"${INPUTACV} >= ${min_acvolt}") )) && [ "${PW_DISCHARGE}" != "1" ]; then
				[ "${last_battvolt}" != "${BATTVOLT}" ] && last_battvolt=${BATTVOLT}
				if [ -f ${PW_TMPFOLDER}/power.ac.low ]; then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V / ${BATTVOLT}'V - Back to Normal Voltage" >> ${PW_LOGPOWER}
					SENDNOTICE "POWER NOMINAL AGAIN" "Normal voltage detected
GRID VOLTAGE:	${INPUTACV}'V
BATT VOLTAGE:	`IDS_NUMBER_FORMAT ${BATTVOLT}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)"
				else
					[ $(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER})) -ge $(echo "scale=0; ${PW_LOG_INTERVAL_NORMAL}*60" | tr -d $'\r' | bc) ] && echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V - Normal Voltage" >> ${PW_LOGPOWER}
					if [ -f ${PW_TMPFOLDER}/power.ac.start ]; then
						SENDNOTICE "POWER Startup - Nominal" "Service Startup
Normal voltage detected
GRID VOLTAGE:	${INPUTACV}'V
BATT VOLTAGE:	`IDS_NUMBER_FORMAT ${BATTVOLT}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)"

						echo "($(date +'%Y-%m-%d %H:%M:%S')) - 'Check Power' Service Startup - Normal voltage detected - Input: ${INPUTACV}'V" >> ${PW_LOGPOWER}
						rm -f ${PW_TMPFOLDER}/power.ac.start
					fi
				fi
				if [ ! -f ${PW_TMPFOLDER}/power.ac.good ]; then
					
					if [[ "${IP}" != "10.6.1"* ]] && ([ -f ${PW_TMPFOLDER}/shutdown.SYS ] || [ -f ${PW_TMPFOLDER}/shutdown.MAIN ] || [ -f ${PW_TMPFOLDER}/power.ac.conserve ]); then
						SENDNOTICE "HOSTS POWER" "Power restored! Will wait ${PW_WAIT_TO_POWER_SERVERS}'mins before turning host(s) back on"
						touch ${PW_TMPFOLDER}/.power.restored
					fi
					
					rm -f ${PW_TMPFOLDER}/power.ac.*
					touch ${PW_TMPFOLDER}/power.ac.good
					
				elif [ -f ${PW_TMPFOLDER}/.power.restored ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/.power.restored)) -ge $(echo "scale=0; ${PW_WAIT_TO_POWER_SERVERS}*60" | tr -d $'\r' | bc) ]; then
					HOSTMGMT mainsite -p on >/dev/null 2>&1 &
					rm -f ${PW_TMPFOLDER}/.power.restored
				fi
				
			else
				[ $(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER})) -ge 300 ] && echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V / ${BATTVOLT}'V - Power OFF or LOW" >> ${PW_LOGPOWER}
				if [ -f ${PW_TMPFOLDER}/power.ac.start ]; then
					SENDNOTICE "POWER Startup - POWER OFF/LOW -${PW_DISCHARGE}- !!" "Service Startup
Power off or low voltage detected
GRID VOLTAGE:	${INPUTACV}'V
BATT VOLTAGE:	`IDS_NUMBER_FORMAT ${BATTVOLT}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)" 1
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - 'Check Power' Service Startup - Normal voltage detected - Input: ${INPUTACV}'V" >> ${PW_LOGPOWER}
					rm -f ${PW_TMPFOLDER}/power.ac.start
					rm -f ${PW_TMPFOLDER}/power.ac.good
					touch ${PW_TMPFOLDER}/power.ac.low
										
				elif [ -f ${PW_TMPFOLDER}/power.ac.good ]; then
					if (( $(bc <<<"${INPUTACV} < ${min_acvolt}") )); then
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V / ${BATTVOLT}'V - Power OFF or LOW voltage detected" >> ${PW_LOGPOWER}
						SENDNOTICE "POWER ALERT - POWER OFF/LOW" "Power off or low voltage detected
GRID VOLTAGE:	${INPUTACV}'V
BATT VOLTAGE:	`IDS_NUMBER_FORMAT ${BATTVOLT}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)" 1
				else
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V / ${BATTVOLT}'V - Running on Batteries" >> ${PW_LOGPOWER}
						SENDNOTICE "POWER ALERT - RUNNING ON BATTERIES!!" "Running on Batteries
GRID VOLTAGE:	${INPUTACV}'V
BATT VOLTAGE:	`IDS_NUMBER_FORMAT ${BATTVOLT}`'V ~ (`IDS_NUMBER_FORMAT ${BATTLIFE}`'% @ ${BATT_FULL}'V)" 1
				fi
					rm -f ${PW_TMPFOLDER}/power.ac.good
					touch ${PW_TMPFOLDER}/power.ac.low
					
				fi
				if [ "${PW_CONSERVE_HOSTS}" != "" ] && [ ! -f ${PW_TMPFOLDER}/power.ac.conserve ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.ac.low)) -ge $(echo "scale=0; ${PW_CONSERVE_AFTER}*60/1" | tr -d $'\r' | bc) ]; then
					echo -e "($(date +'%Y-%m-%d %H:%M:%S')) - ${INPUTACV}'V / ${BATTVOLT}'V - Shutting down iSCSI VM's and Host to conserve power" >> ${PW_LOGPOWER}
					SENDNOTICE "POWER ALERT - Conserving Power" "Shutting down iSCSI VM's and Host to conserve power" 1
					# SHUTDOWN_SERVER ${PW_MAIN_ISCSI} -esxi off &
					CONSERVE_POWER &
					touch ${PW_TMPFOLDER}/power.ac.conserve
				fi
			fi
			
			if (( $(bc <<<"${BATTVOLT} >= ${min_battvolt}") )); then
				[ $(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER})) -ge $(echo "scale=0; ${PW_LOG_INTERVAL_NORMAL}*60" | tr -d $'\r' | bc) ] && echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Battery Voltage" >> ${PW_LOGPOWER}
				if [ -f ${PW_TMPFOLDER}/power.dc.start ]; then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - Battery: ${BATTVOLT}'V - Service Startup - Normal voltage detected" >> ${PW_LOGPOWER}
					rm -f ${PW_TMPFOLDER}/power.dc.start
				fi
				if [ ! -f ${PW_TMPFOLDER}/power.dc.good ]; then
					rm -f ${PW_TMPFOLDER}/power.dc.*
					touch ${PW_TMPFOLDER}/power.dc.good
				fi
				
			else
				[ -f ${PW_TMPFOLDER}/power.dc.good ] && rm -f ${PW_TMPFOLDER}/power.dc.good
				[ $(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER})) -ge $(echo "scale=0; ${PW_LOG_INTERVAL_ABNORMAL}*60" | tr -d $'\r' | bc) ] && echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - LOW BATTERY Voltage" >> ${PW_LOGPOWER}
				
				if (( $(bc <<<"${BATTVOLT} <= ${min_battvolt_sys}") )); then
					[ ! -f ${PW_TMPFOLDER}/power.dc.critlow ] && touch ${PW_TMPFOLDER}/power.dc.critlow

					if [ ! -f ${PW_TMPFOLDER}/shutdown.SYS.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.MAINSITE.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.ALL.started ] && (( $(bc <<<"${INPUTACV} < ${min_acvolt}") )) && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.dc.critlow)) -ge 30 ]; then
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down all remaining servers..." >> ${PW_LOGFILE}
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down all remaining servers..." >> ${PW_LOGPOWER}
						SENDNOTICE "BATT-VOLT REALLY LOW: SHUTDOWN SYS SERVERS" "Battery Voltage REALLY LOW: ${BATTVOLT}'V
Shutting down all remaining servers" 1
						SHUTDOWN_SYS POWER &
					
					fi
					
				elif (( $(bc <<<"${BATTVOLT} < ${min_battvolt}") )); then
					[ ! -f ${PW_TMPFOLDER}/power.dc.low ] && touch ${PW_TMPFOLDER}/power.dc.low
					[ -f ${PW_TMPFOLDER}/power.dc.critlow ] && rm -f ${PW_TMPFOLDER}/power.dc.critlow

					if [ ! -f ${PW_TMPFOLDER}/shutdown.MAIN.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.MAINSITE.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.ALL.started ] && (( $(bc <<<"${INPUTACV} < ${min_acvolt}") )) && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.dc.low)) -ge 30 ]; then
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down main servers..." >> ${PW_LOGFILE}
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down main servers..." >> ${PW_LOGPOWER}
						SENDNOTICE "BATT-VOLT LOW: SHUTDOWN MAIN SERVERS" "Battery Voltage LOW: ${BATTVOLT}'V
Shutting down main servers" 1
						SHUTDOWN_MAIN POWER &
					
					fi
					
				elif [ ! -f ${PW_TMPFOLDER}/shutdown.MAIN.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.MAINSITE.started ] && [ ! -f ${PW_TMPFOLDER}/shutdown.ALL.started ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.ac.low)) -ge $(echo "scale=0; ${PW_SHUTDOWN_MAINSERVERS_AFTER}*60" | tr -d $'\r' | bc) ]; then
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down main servers..." >> ${PW_LOGFILE}
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Shutting down main servers..." >> ${PW_LOGPOWER}
						SENDNOTICE "BATT-VOLT LOW: SHUTDOWN MAIN SERVERS" "Battery Voltage LOW: ${BATTVOLT}'V
Shutting down main servers" 1
						SHUTDOWN_MAIN POWER &
				fi
				
			fi
			if [ -f ${PW_TMPFOLDER}/power.ac.low ] || [ -f ${PW_TMPFOLDER}/power.dc.low ]; then
				volt_diff=`echo "scale=1; ${last_battvolt}-${BATTVOLT}" | tr -d $'\r' | bc`
				(( $(bc <<<"${volt_diff} < 0") )) && volt_diff=`echo "scale=2; ${volt_diff} * -1" | tr -d $'\r' | bc`
				if (( $(bc <<<"${volt_diff} >= 0.5") )); then
					SENDNOTICE "BATTERY VOLTAGE CHANGE" "Battery Voltage: ${BATTVOLT}'V"
					echo -e "($(date +'%Y-%m-%d %H:%M:%S')) - ${BATTVOLT}'V - Battery Voltage Change" >> ${PW_LOGPOWER}
					last_battvolt=${BATTVOLT}
				fi
			fi
			
		else
			sleep 20s
		fi
		
		end=`date +%s`; runtime=$((end-start))
		# echo -e "script runtime: ${runtime}s"; [ ${runtime} -lt ${runEvery} ] && echo "Sleeping for $(expr ${runEvery} - ${runtime})s"
		echo "${log_start}~${runtime}~power" >> ${PW_LOGFOLDER}/service.scantimes
		[ ${runtime} -lt ${runEvery} ] && sleep $(expr ${runEvery} - ${runtime})s ###|| echo "Not sleeping, ran for ${runtime}s previsoulsy"
	done # & 
}

OFFSITE_CHECKPOWER_SERVICE(){
	startup=true
	[ "${PW_SERVICE_POWER_SCANRATE}" != "" ] && runEvery=${PW_SERVICE_POWER_SCANRATE} || runEvery=10
	while true; do
		start=$(date +%s)
		log_start=$(date "+%Y-%m-%d %H:%M:%S")
		source ${PW_FOLDER}/defaults.inc
		
		PW_OFFSITEHOSTS=$(echo ${PW_OFFSITE_HOSTS} | tr ',' ' ')
		[ "${TEST_OFFSITE}" != "" ] && TEST=${TEST_OFFSITE} || TEST=''
		
		if [ "${TEST}" != "" ]; then
			PW_OFFSITE_SHUTDOWNSERVERS_AT_BATTCAP=98		#percent
			PW_OFFSITE_SHUTDOWNSERVERS_AFTER=1			#minutes
			PW_OFFSITE_WAIT_TO_POWER_SERVERS=1			#minutes
			TESTMSG="### TEST MODE ACTIVE ###

		"
		else
			TESTMSG=""
		fi
				
		[ "${PW_OFFSITE_MONITOR}" == "${IP}" ] && upsinfo=$(upsc offsite-ups 2>&1) || upsinfo=$(${SSHCMD} root@${PW_OFFSITE_MONITOR} 'upsc offsite-ups 2>&1')
		if [ "$(echo "${upsinfo}" | grep 'input.voltage:' | sed 's/.*: //' | tr -d $'\r')" != "" ]; then
			rm -f ${PW_TMPFOLDER}/power.offsite.ups.losscomm
			OFFSITE_VOLTIN=$(echo "${upsinfo}" | grep 'input.voltage:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_LOAD=$(echo "${upsinfo}" | grep 'ups.load:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_LOAD=`echo "scale=2; ${OFFSITE_LOAD}/100" | tr -d $'\r' | bc`
			OFFSITE_WATTS=`echo "scale=2; ${OFFSITE_LOAD}*$(echo "${upsinfo}" | grep 'ups.realpower.nominal:' | sed 's/.*: //')" | tr -d $'\r' | bc`
			OFFSITE_BATT_RUNTIME=$(echo "${upsinfo}" | grep 'battery.runtime:' | sed 's/.*: //' | tr -d $'\r')
			OFFSITE_BATT_RUNTIME=`echo "scale=2; ${OFFSITE_BATT_RUNTIME}/60" | tr -d $'\r' | bc`
			OFFSITE_BATT_CAP=$(echo "${upsinfo}" | grep 'battery.charge:' | sed 's/.*: //' | tr -d $'\r')
			
			if (( $(bc <<<"${OFFSITE_WATTS} < 100") )); then
				TOTAL_MISC_WATTS=0
				for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
					TOTAL_MISC_WATTS=`echo "scale=2; ${TOTAL_MISC_WATTS}+$(GET_TUYA_POWER ${mSENSOR})" | tr -d $'\r' | bc`
				done
				(( $(bc <<<"${OFFSITE_WATTS} < ${TOTAL_MISC_WATTS}") )) && OFFSITE_WATTS=${TOTAL_MISC_WATTS}
			fi
			
			if [ "${PW_OFFSITE_MONITOR}" == "${IP}" ]; then
				if [ ! -d /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']} ]; then
					/bin/dtoverlay w1-gpio gpiopin=4
					sleep 2s
				fi
				if [ -d /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']} ]; then
					temp_c=$(cat /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']}/w1_slave | tail -n1 | cut -d "=" -f2)
					OFFSITE_TEMP=$(bc <<< "scale=2; ((${temp_c}/1000)*(9/5))+32")
				else
					OFFSITE_TEMP=ERR
				
				fi
			else
				if ${SSHCMD} root@${PW_OFFSITE_MONITOR} [ ! -d /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']} ]; then
					${SSHCMD} root@${PW_OFFSITE_MONITOR} '/bin/dtoverlay w1-gpio gpiopin=4'
					sleep 2s
				fi
				if ${SSHCMD} root@${PW_OFFSITE_MONITOR} [ -d /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']} ]; then
					temp_c=$(${SSHCMD} root@${PW_OFFSITE_MONITOR} cat /sys/devices/w1_bus_master1/${PW_SENSOR_DEVICEID['Offsite-ServerRoom']}/w1_slave | tail -n1 | cut -d "=" -f2)
					OFFSITE_TEMP=$(bc <<< "scale=2; ((${temp_c}/1000)*(9/5))+32")
				else
					OFFSITE_TEMP=ERR
				
				fi
				
			fi
			

			
			SENDNOTICE2(){
				MESSAGE="${TESTMSG}${2}

BATTERY CHARGE: ${OFFSITE_BATT_CAP}'%
BATT RUNTIME: ${OFFSITE_BATT_RUNTIME}'mins
AC VOLTAGE: ${OFFSITE_VOLTIN}'V
WATT USAGE: ${OFFSITE_WATTS}'W
AMBIENT TEMP: ${OFFSITE_TEMP}'F"
				[ "${3}" != "" ] && PRIORITY=${3} || PRIORITY=0
				SENDNOTICE "${1}" "${MESSAGE}" ${PRIORITY} cosmic
			}
			if [ "${startup}" = "true" ]; then
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_WATTS}'W - ${OFFSITE_BATT_CAP}'% Battery - ${OFFSITE_BATT_RUNTIME}'mins - Service startup" >> ${PW_LOGPOWER}
				echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Service startup" >> ${PW_LOGFILE}
				OFFSITE_SENDPOWER "OFFSITE MONITOR Service Startup" &
				startup=false
			fi
			
			if [ ${OFFSITE_VOLTIN%.*} -gt 105 ]; then
				if [ -f ${PW_TMPFOLDER}/power.offsite.charging ] && [ ${OFFSITE_BATT_CAP%.*} -eq 100 ]; then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Charging Complete" >> ${PW_LOGFILE}
					SENDNOTICE2 "OFFSITE POWER" "Batteries are fully recharged"
					rm -f ${PW_TMPFOLDER}/power.offsite.charging
				# elif [ ${OFFSITE_BATT_CAP%.*} -lt 100 ] && [ ! -f ${PW_TMPFOLDER}/power.offsite.charging ]; then
				elif [ ${OFFSITE_BATT_CAP%.*} -lt 100 ] && ([ ! -f ${PW_TMPFOLDER}/power.offsite.charging ] || [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.charging)) -gt 60 ]); then
					# touch ${PW_TMPFOLDER}/power.offsite.charging
					echo "${OFFSITE_BATT_CAP%.*}'%" >| ${PW_TMPFOLDER}/power.offsite.charging
				fi
				if [ -f ${PW_TMPFOLDER}/power.offsite.ac.low ]; then
					if [ -f ${PW_TMPFOLDER}/shutdown.OFFSITE ]; then
						touch ${PW_TMPFOLDER}/power.offsite.restored
						echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Offsite Power Restored" >> ${PW_LOGFILE}
						SENDNOTICE2 "OFFSITE POWER" "Power restored! Will wait ${PW_OFFSITE_WAIT_TO_POWER_SERVERS}'mins before turning host(s) back on"
					fi
					
					rm -f ${PW_TMPFOLDER}/power.offsite.ac.*
				fi
				if [ -f ${PW_TMPFOLDER}/shutdown.OFFSITE ]; then
					if [ -f ${PW_TMPFOLDER}/power.offsite.restored ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.restored)) -gt $(echo "scale=2; ${PW_OFFSITE_WAIT_TO_POWER_SERVERS}*60" | tr -d $'\r' | bc) ]; then
						if [ "$(CHECK_HOST ${PW_IP})" != "false" ]; then
							echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Powering Hosts ON After Power Outage" >> ${PW_LOGFILE}
							if [ -f ${PW_TMPFOLDER}/power.offsite.nohomeconn ]; then
								SENDNOTICE2 "OFFSITE HOST POWER" "Powerwall connections has been established, powering offsite host(s) back ONLINE after power outage"
							else
								SENDNOTICE2 "OFFSITE HOST POWER" "Powering offsite host(s) back ONLINE after power outage"
							fi
							for host in ${PW_OFFSITEHOSTS_IDRAC}; do
								if [ "${TEST}" = "" ] || [ "${TEST}" = "full" ]; then
									ipmitool -I lanplus -H ${host} -U ${PW_ESXI_USER} -P "${PW_ESXI_PASS}" chassis power on &
								else
									echo "TESTMODE: Powering up '${host}'"
								fi
							done
							rm -f ${PW_TMPFOLDER}/power.offsite.restored ${PW_TMPFOLDER}/power.offsite.nohomeconn ${PW_TMPFOLDER}/shutdown.OFFSITE
						else
							if [ ! -f ${PW_TMPFOLDER}/power.offsite.nohomeconn ]; then
								echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Will wait to power on offsite host(s) until powerwall connection is regained" >> ${PW_LOGFILE}
								touch ${PW_TMPFOLDER}/power.offsite.nohomeconn
								SENDNOTICE2 "OFFSITE HOST POWER" "Will wait to power on offsite host(s) until powerwall connection is regained"
							elif [ -f ${PW_TMPFOLDER}/power.offsite.nohomeconn ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.nohomeconn)) -gt $(echo "scale=2; ${PW_OFFSITE_WAIT_TO_POWER_SERVERS}*60" | tr -d $'\r' | bc) ]; then
								touch ${PW_TMPFOLDER}/power.offsite.nohomeconn
								SENDNOTICE2 "OFFSITE HOST POWER" "Still waiting for connection to powerwall before powering offsite host(s) back on"
							fi
						fi
					fi
				fi
				logtime=$(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER}))
				if [ ${logtime} -ge $(echo "scale=0; ${PW_LOG_INTERVAL_NORMAL}*60" | tr -d $'\r' | bc) ] || ([ ${OFFSITE_BATT_CAP%.*} -lt 100 ] && [ ${logtime} -gt ${PW_LOG_INTERVAL_CHARGING} ]); then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_WATTS}'W - ${OFFSITE_BATT_CAP}'% Battery - ${OFFSITE_BATT_RUNTIME}'mins - Normal" >> ${PW_LOGPOWER}
				fi
			else
				[ ! -f ${PW_TMPFOLDER}/power.offsite.ac.low ] && touch ${PW_TMPFOLDER}/power.offsite.ac.low
				
				if [ ! -f ${PW_TMPFOLDER}/power.offsite.ac.low.notice ] || [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.ac.low.notice)) -gt $(echo "scale=2; ${PW_RENOTIFY_LOWPOWER}*60" | tr -d $'\r' | bc) ]; then
					# echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Powering LOW/OFF!" >> ${PW_LOGFILE}
					SENDNOTICE2 "OFFSITE POWER - POWER OFF/LOW!!" "Power off or low voltage detected" 1
					touch ${PW_TMPFOLDER}/power.offsite.ac.low.notice
				fi

				if [ ! -f ${PW_TMPFOLDER}/shutdown.OFFSITE ] && [ ${OFFSITE_WATTS%.*} -gt 100 ] && ([ ${OFFSITE_BATT_CAP%.*} -le ${PW_OFFSITE_SHUTDOWNSERVERS_AT_BATTCAP} ] || [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.ac.low)) -ge $(echo "scale=2; ${PW_OFFSITE_SHUTDOWNSERVERS_AFTER}*60" | tr -d $'\r' | bc) ]); then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) - ${OFFSITE_VOLTIN}'V - ${OFFSITE_BATT_CAP}'% Battery - Powering Down Hosts!" >> ${PW_LOGFILE}
					SENDNOTICE2 "OFFSITE HOST POWER" "Powering DOWN offsite host(s) due to power outage" 1
					touch ${PW_TMPFOLDER}/shutdown.OFFSITE
					for host in ${PW_OFFSITEHOSTS}; do
						if [ "${TEST}" = "" ] || [ "${TEST}" = "full" ]; then
							SHUTDOWN_SERVER ${host} -esxi off &
						fi
					done
				fi
				if [ $(expr `date +%s` - $(stat -c %Y ${PW_LOGPOWER})) -gt ${PW_LOG_INTERVAL_ABNORMAL} ]; then
					echo "($(date +'%Y-%m-%d %H:%M:%S')) -   ${OFFSITE_VOLTIN}'V - ${OFFSITE_WATTS}'W - ${OFFSITE_BATT_CAP}'% Battery - ${OFFSITE_BATT_RUNTIME}'mins - OFF/LOW POWER!!" >> ${PW_LOGPOWER}
				fi
			fi
		
		else
			if [ ! -f ${PW_TMPFOLDER}/power.offsite.ups.losscomm ]; then
				touch ${PW_TMPFOLDER}/power.offsite.ups.losscomm
				
			elif [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/power.offsite.ups.losscomm)) -ge 120 ]; then
				echo "($(date +'%Y-%m-%d %H:%M:%S')) -   0.0'V -   0'% Battery - Restarting NUT service" >> ${PW_LOGFILE}
				[ "${PW_OFFSITE_MONITOR}" == "${IP}" ] && systemctl restart nut-driver || ${SSHCMD} root@${PW_OFFSITE_MONITOR} 'systemctl restart nut-driver'
				sleep 10s
				touch ${PW_TMPFOLDER}/power.offsite.ups.losscomm
			fi
		fi
		
		end=`date +%s`; runtime=$((end-start))
		# echo -e "script runtime: ${runtime}s"; [ ${runtime} -lt ${runEvery} ] && echo "Sleeping for $(expr ${runEvery} - ${runtime})s"
		echo "${log_start}~${runtime}~offsite-power" >> ${PW_LOGFOLDER}/service.scantimes
		[ ${runtime} -lt ${runEvery} ] && sleep $(expr ${runEvery} - ${runtime})s ###|| echo "Not sleeping, ran for ${runtime}s previsoulsy"
	done
}


POWERLOGGER_SERVICE(){
	SENDPOWER "POWER LOGGING Service Startup" &
	while true; do
		start=$(date +%s)
		log_start=$(date "+%Y-%m-%d %H:%M:%S")
		
		LogDataTime=`date +'%Y-%m-%d %H:%M:%S'`
		source ${PW_FOLDER}/defaults.inc
		
		if [[ "${IP}" != "10.6.1"* ]]; then
		
			INVSTATSINFO=$(curl -m 3 -s "http://${PW_INVERTER_IP}/stats.json")
			if [ "${INVSTATSINFO}" != "" ]; then
				INPUTV=`echo ${INVSTATSINFO} | jq '.inputs .inV' | tr -d $'\r'`
				INPUTA=`echo ${INVSTATSINFO} | jq '.inputs .inA' | tr -d $'\r'`
				OUTPUTV=`echo ${INVSTATSINFO} | jq '.outputs .outV' | tr -d $'\r'`
				OUTPUTA=`echo ${INVSTATSINFO} | jq '.outputs .outA' | tr -d $'\r'`
				OUTPUTW=`echo ${INVSTATSINFO} | jq '.outputs .outW' | tr -d $'\r'`
				BATTV=`echo ${INVSTATSINFO} | jq '.inputs .battV' | tr -d $'\r'`
				BATTA=`echo ${INVSTATSINFO} | jq '.inputs .xfA' | tr -d $'\r'`
			
				QRY="INSERT INTO power_data (sensorid, date, volt, amp) VALUES ('${PW_POWERSENSOR_ID['inv-in']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${INPUTV}','${INPUTA}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['inv-out']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${OUTPUTV}','${OUTPUTA}','${OUTPUTW}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				QRY="INSERT INTO power_data (sensorid, date, volt, amp) VALUES ('${PW_POWERSENSOR_ID['battery']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${BATTV}','${BATTA}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), volt = '${INPUTV}', amp = '${INPUTA}' WHERE sensorid='${PW_POWERSENSOR_ID['inv-in']}'"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), volt = '${OUTPUTV}', amp = '${OUTPUTA}' WHERE sensorid='${PW_POWERSENSOR_ID['inv-out']}'"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), volt = '${BATTV}', amp = '${BATTA}' WHERE sensorid='${PW_POWERSENSOR_ID['battery']}'"

			
				QRY="INSERT INTO inv_jsonstats (date, data) VALUES (CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${INVSTATSINFO}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			fi
		
			if [ "$(CHECK_HOST ${PW_UPS_IP})" != "false" ]; then
				SVRRM_VOLT=$(snmpwalk -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.2.1.1 | sed 's/.*: //')
				SVRRM_VOLT=`echo "scale=1; ${SVRRM_VOLT}/10" | tr -d $'\r' | bc`
				SVRRM_WATT=$(snmpwalk -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.4.1.1 | sed 's/.*: //')
				SVRRM_AMP=$(snmpwalk -v 1 -c public ${PW_UPS_IP} iso.3.6.1.4.1.850.1.1.3.1.3.3.2.1.3.1.1 | sed 's/.*: //')
				SVRRM_AMP=`echo "scale=2; ${SVRRM_AMP}/100" | tr -d $'\r' | bc`
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['total']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${SVRRM_VOLT}','${SVRRM_AMP}','${SVRRM_WATT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${SVRRM_WATT}' WHERE sensorid='${PW_POWERSENSOR_ID['total']}'"
			fi
		
			if [ "$(CHECK_HOST ${PW_APCPDU_IP})" != "false" ]; then
				APCPDU_AMP=$(snmpwalk -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.2.3.1.1.2.1 | sed 's/.*: //')
				APCPDU_AMP=`echo "scale=1; ${APCPDU_AMP}/10" | tr -d $'\r' | bc`
				if [ "${SVRRM_VOLT}" != "" ]; then
					APCPDU_WATT=`echo "scale=2; ${APCPDU_AMP}*${SVRRM_VOLT}" | tr -d $'\r' | bc`
					QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['server-rack']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${SVRRM_VOLT}','${APCPDU_AMP}','${APCPDU_WATT}')"
					${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${APCPDU_WATT}' WHERE sensorid='${PW_POWERSENSOR_ID['server-rack']}'"
				else
					QRY="INSERT INTO power_data (sensorid, date, amp) VALUES ('12',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${APCPDU_AMP}')"
				fi
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			fi
		
			if [ "${SVRRM_VOLT}" != "" ] && [ "${APCPDU_AMP}" != "" ]; then
				NETRK_AMP=`echo "scale=2; ${SVRRM_AMP}-${APCPDU_AMP}" | tr -d $'\r' | bc`
				NETRK_WATT=$(ROUND_NUMBER `echo "scale=2; ${SVRRM_WATT}-${APCPDU_WATT}" | tr -d $'\r' | bc` 0)
			
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['network-rack']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${SVRRM_VOLT}','${NETRK_AMP}','${NETRK_WATT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${NETRK_WATT}' WHERE sensorid='${PW_POWERSENSOR_ID['network-rack']}'"
			fi
		
			AIRCON_INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS['ServerRoom-AC']}:8888/status/${PW_SENSOR_DEVICEID['ServerRoom-AC']} | jq '.dps')
			if [ "${AIRCON_INFO}" != "" ]; then
				AIRCON_AMP=$(echo "${AIRCON_INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				AIRCON_AMP=$(ROUND_NUMBER $(echo "scale=3; ${AIRCON_AMP}/1000" | tr -d $'\r' | bc -l) 2)
				AIRCON_WATT=$(echo "${AIRCON_INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				AIRCON_WATT=$(echo "scale=1; ${AIRCON_WATT}/10" | tr -d $'\r' | bc -l)
				AIRCON_VOLT=$(echo "${AIRCON_INFO}" | grep '"20":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				AIRCON_VOLT=$(echo "scale=3; ${AIRCON_VOLT}/10" | tr -d $'\r' | bc -l)
		
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['ServerRoom-AC']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${AIRCON_VOLT}','${AIRCON_AMP}','${AIRCON_WATT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${AIRCON_WATT}' WHERE sensorid='${PW_POWERSENSOR_ID['ServerRoom-AC']}'"
			
			else
				AIRCON_WATT=0
				AIRCON_AMP=0
			fi
		
			if [ "${SVRRM_WATT}" != "" ]; then
				SVRRM_AMP_WAC=$(echo "scale=2; ${SVRRM_AMP}+${AIRCON_AMP}" | tr -d $'\r' | bc -l)
				SVRRM_WATT_WAC=$(echo "scale=2; ${SVRRM_WATT}+${AIRCON_WATT}" | tr -d $'\r' | bc -l)
				QRY="INSERT INTO power_data (sensorid, date, amp, watt) VALUES ('${PW_POWERSENSOR_ID['total-wac']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${SVRRM_AMP_WAC}','${SVRRM_WATT_WAC}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${SVRRM_WATT_WAC}' WHERE sensorid='${PW_POWERSENSOR_ID['total-wac']}'"
			fi
		
			### KYLE
			KYLE_INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS['KP-Power']}:8888/status/${PW_SENSOR_DEVICEID['KP-Power']} | jq '.dps')
			if [ "${KYLE_INFO}" != "" ]; then
				KYLE_AMP=$(echo "${KYLE_INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_AMP=$(ROUND_NUMBER $(echo "scale=3; ${KYLE_AMP}/1000" | tr -d $'\r' | bc -l) 2)
				KYLE_WATT=$(echo "${KYLE_INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_WATT=$(echo "scale=1; ${KYLE_WATT}/10" | tr -d $'\r' | bc -l)
				KYLE_VOLT=$(echo "${KYLE_INFO}" | grep '"20":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_VOLT=$(echo "scale=3; ${KYLE_VOLT}/10" | tr -d $'\r' | bc -l)
			
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['KP-Power']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${KYLE_VOLT}','${KYLE_AMP}','${KYLE_WATT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				${mysql_conn} -e "USE servermonitor; UPDATE latest_sensor_data SET date = CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'), watt = '${KYLE_WATT}' WHERE sensorid='${PW_POWERSENSOR_ID['KP-Power']}'"
			
			else
				KYLE_AMP=0
				KYLE_WATT=0
			fi
			KYLE_INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS['KP-SAS']}:8888/status/${PW_SENSOR_DEVICEID['KP-SAS']} | jq '.dps')
			if [ "${KYLE_INFO}" != "" ]; then
				KYLE_AMP=$(echo "${KYLE_INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_AMP=$(ROUND_NUMBER $(echo "scale=3; ${KYLE_AMP}/1000" | tr -d $'\r' | bc -l) 2)
				KYLE_WATT=$(echo "${KYLE_INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_WATT=$(echo "scale=1; ${KYLE_WATT}/10" | tr -d $'\r' | bc -l)
				KYLE_VOLT=$(echo "${KYLE_INFO}" | grep '"20":' | cut -d' ' -f 4 | sed 's/,//g' | tr -d $'\r')
				KYLE_VOLT=$(echo "scale=3; ${KYLE_VOLT}/10" | tr -d $'\r' | bc -l)
			
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['KP-SAS']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${KYLE_VOLT}','${KYLE_AMP}','${KYLE_WATT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			
			else
				KYLE_AMP=0
				KYLE_WATT=0
			fi
			
		
			[ "${PW_OFFSITE_MONITOR}" == "${IP}" ] && upsinfo=$(upsc offsite-ups 2>&1) || upsinfo=$(${SSHCMD} root@${PW_OFFSITE_MONITOR} 'upsc offsite-ups' 2>&1)
			if [ "$(echo "${upsinfo}" | grep 'input.voltage:')" != "" ]; then
				OFFSITE_VOLTOUT=$(echo "${upsinfo}" | grep 'output.voltage:' | sed 's/.*: //' | tr -d $'\r')
				OFFSITE_LOAD=$(echo "${upsinfo}" | grep 'ups.load:' | sed 's/.*: //' | tr -d $'\r')
				OFFSITE_LOAD=`echo "scale=2; ${OFFSITE_LOAD}/100" | tr -d $'\r' | bc`
				OFFSITE_WATTS=`echo "scale=2; ${OFFSITE_LOAD}*$(echo "${upsinfo}" | grep 'ups.realpower.nominal:' | sed 's/.*: //')" | tr -d $'\r' | bc`
				OFFSITE_AMPS=`echo "scale=2; ${OFFSITE_WATTS}/${OFFSITE_VOLTOUT}" | tr -d $'\r' | bc`
			
				if (( $(bc <<<"${OFFSITE_WATTS} < 100") )); then
					TOTAL_MISC_WATTS=0; TOTAL_MISC_AMPS=0
					for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
						IFS=: read -r AMP WATT VOLT <<< $(GET_TUYA_POWER ${mSENSOR}); unset IFS
						TOTAL_MISC_WATTS=`echo "scale=2; ${TOTAL_MISC_WATTS}+${WATT}" | tr -d $'\r' | bc`
						TOTAL_MISC_AMPS=`echo "scale=2; ${TOTAL_MISC_AMPS}+${AMP}" | tr -d $'\r' | bc`
					done
					if (( $(bc <<<"${OFFSITE_WATTS} < ${TOTAL_MISC_WATTS}") )); then
						OFFSITE_WATTS=${TOTAL_MISC_WATTS}
						OFFSITE_AMPS=${TOTAL_MISC_AMPS}
					fi
				fi
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['offsite-ups']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${OFFSITE_VOLTOUT}','${OFFSITE_AMPS}','${OFFSITE_WATTS}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			fi
		
			for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
				IFS=: read -r AMP WATT VOLT <<< $(GET_TUYA_POWER ${mSENSOR}); unset IFS
				if [ "${VOLT}" != "" ] && [ "${PW_POWERSENSOR_ID[${mSENSOR}]}" != "" ]; then
					QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID[${mSENSOR}]}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${VOLT}','${AMP}','${WATT}')"
					${mysql_conn} -e "USE servermonitor; ${QRY}"
				fi
			done
		
			for SENSOR in ${PW_SENSOR_ORD[@]}; do
				[[ "${PW_HOST_IDRACS[${SENSOR}]}" = "10.6."* ]] && ESXI_PASS=${PW_ESXI_PASS_KP} || ESXI_PASS=${PW_ESXI_PASS}
				if [ "${PW_HOST_IDRACS[${SENSOR}]}" != "" ] && [ ! -f ${PW_TMPFOLDER}/${SENSOR}.down ] && [ "$(ipmitool -I lanplus -H ${PW_HOST_IDRACS[${SENSOR}]} -U ${PW_ESXI_USER} -P "${ESXI_PASS}" chassis power status | grep 'Power is on')" != "" ]; then
					HOST_WATT_SENSORS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1 -O vq | sed -e 's/"//g')
					if [[ "${HOST_WATTS}" != *"Timeout"* ]] && [ "${HOST_WATT_SENSORS}" != "" ]; then
						IFS=$'\n'
						read -rd '' -a HOST_WATT_SENSORS <<<"${HOST_WATT_SENSORS}"
						unset IFS
						if [ ! -f ${PW_TMPFOLDER}/${SENSOR}.disable ] || ([ -f ${PW_TMPFOLDER}/${SENSOR}.disable ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/${SENSOR}.disable)) -ge 120 ]); then
							[ -f ${PW_TMPFOLDER}/shutdown.${PW_HOST_ADDRESSES[${SENSOR}]} ] && rm -f ${PW_TMPFOLDER}/shutdown.${PW_HOST_ADDRESSES[${SENSOR}]}
							[ -f ${PW_TMPFOLDER}/shutdown.ALL ] && rm -f ${PW_TMPFOLDER}/shutdown.ALL
							[[ "${PW_OFFSITE_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.OFFSITE
							[[ "${PW_MAINSITE_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.MAINSITE
							[[ "${PW_MAIN_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.MAIN
							[[ "${PW_SYS_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.SYS
							rm -f ${PW_TMPFOLDER}/${SENSOR}.disable
						fi
					
					
						PS1='0.0'; PS2='0.0'; HOST_WATTS=0
						for s in {1..5}; do
							DP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1.${s} | sed 's/.*: //')
							if [[ "${DP}" = *"System Board"* ]]; then
								found=1
								HOST_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
					
							elif [[ "${DP}" = *"PS1"* ]]; then
								PS1=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							elif [[ "${DP}" = *"PS2"* ]]; then
								PS2=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							fi
						done
						if [ ${found} -eq 1 ] && [ "${HOST_WATTS}" != "0" ] && [ "${HOST_WATTS}" != "" ] && [[ "${HOST_WATTS}" != *"Timeout"* ]]; then
							[ "${PS1}" != "0.0" ] && PS1=`echo "scale=1; ${PS1}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS1} < 1") )) && [[ "${PS1}" = *"."* ]] && PS1="0${PS1}"
							[ "${PS2}" != "0.0" ] && PS2=`echo "scale=1; ${PS2}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS2} < 1") )) && [[ "${PS2}" = *"."* ]] && PS2="0${PS2}"
							HOST_AMPS=`echo "scale=1; ${PS1}+${PS2}" | tr -d $'\r' | bc`
							QRY="INSERT INTO power_data (sensorid, date, amp, watt) VALUES ('${PW_POWERSENSOR_ID[${SENSOR}]}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${HOST_AMPS}','${HOST_WATTS}')"
							${mysql_conn} -e "USE servermonitor; ${QRY}"
						fi
					fi
				fi
			done
			
#############################################################
		else ################# KYLE #########################
			if [ "$(CHECK_HOST ${PW_UPS_IP})" != "false" ]; then
				## VERTIV
				# UPS_VOLTIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				# UPS_VOLTOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.2.1 | sed 's/.*: //')
				# UPS_LOAD=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.2.2.1.11.3 | sed 's/.*: //')
				# UPS_LOAD=`echo "scale=2; ${UPS_LOAD}/10" | tr -d $'\r' | bc`
				# UPS_AMPSIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.3.3.1.4.1 | sed 's/.*: //')\
				# UPS_AMPSIN=`echo "scale=2; ${UPS_AMPSIN}/10" | tr -d $'\r' | bc`
				# UPS_AMPSOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.3.1 | sed 's/.*: //')\
				# UPS_AMPSOUT=`echo "scale=2; ${UPS_AMPSOUT}/10" | tr -d $'\r' | bc`
				# UPS_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.2.2.1.8.3 | sed 's/.*: //')
				# UPS_BATT_RUNTIME=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.18.0 | sed 's/.*: //')
				# UPS_BATT_VOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.10.0 | sed 's/.*: //')
				# UPS_BATT_CAP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.4.1.476.1.42.3.5.1.19.0 | sed 's/.*: //')
				
				## APC
				UPS_VOLTIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.3.3.1.3.1 | sed 's/.*: //')
				UPS_VOLTOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.2.1 | sed 's/.*: //')
				UPS_LOAD=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.4.4.1.5.1 | sed 's/.*: //')
				UPS_AMPSIN=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.3.3.1.4.1 | sed 's/.*: //')\
				#UPS_AMPSIN=`echo "scale=2; ${UPS_AMPSIN}/10" | tr -d $'\r' | bc`
				UPS_AMPSOUT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.3.1 | sed 's/.*: //')\
				UPS_AMPSOUT=`echo "scale=2; ${UPS_AMPSOUT}/10" | tr -d $'\r' | bc`
				# UPS_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} iso.3.6.1.2.1.33.1.4.4.1.4.1 | sed 's/.*: //')
				UPS_WATTS=`echo "scale=2; ${UPS_VOLTOUT}*${UPS_AMPSOUT}" | tr -d $'\r' | bc`
				UPS_BATT_RUNTIME=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.3.0 | sed 's/.*: //')
				UPS_BATT_VOLT=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.5.0 | sed 's/.*: //')
				UPS_BATT_VOLT=`echo "scale=2; ${UPS_BATT_VOLT}/10" | tr -d $'\r' | bc`
				UPS_BATT_CAP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_UPS_IP} .1.3.6.1.2.1.33.1.2.4.0 | sed 's/.*: //')
				
				QRY="INSERT INTO power_data (sensorid, date, volt, amp) VALUES ('${PW_POWERSENSOR_ID['ups-input']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${UPS_VOLTIN}','${UPS_AMPSIN}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID['ups-output']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${UPS_VOLTOUT}','${UPS_AMPSOUT}','${UPS_WATTS}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
				QRY="INSERT INTO power_data (sensorid, date, volt) VALUES ('${PW_POWERSENSOR_ID['ups-battery']}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${UPS_BATT_VOLT}')"
				${mysql_conn} -e "USE servermonitor; ${QRY}"
			fi
			
			for mSENSOR in "${PW_POWERSENSOR_MISC[@]}"; do
				IFS=: read -r AMP WATT VOLT <<< $(GET_TUYA_POWER ${mSENSOR}); unset IFS
				if [ "${VOLT}" != "" ] && [ "${PW_POWERSENSOR_ID[${mSENSOR}]}" != "" ]; then
					QRY="INSERT INTO power_data (sensorid, date, volt, amp, watt) VALUES ('${PW_POWERSENSOR_ID[${mSENSOR}]}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${VOLT}','${AMP}','${WATT}')"
					${mysql_conn} -e "USE servermonitor; ${QRY}"
				fi
			done
			
			for SENSOR in ${PW_SENSOR_ORD[@]}; do
				[[ "${PW_HOST_IDRACS[${SENSOR}]}" = "10.6."* ]] && ESXI_PASS=${PW_ESXI_PASS_KP} || ESXI_PASS=${PW_ESXI_PASS}
				if [ "${PW_HOST_IDRACS[${SENSOR}]}" != "" ] && [ ! -f ${PW_TMPFOLDER}/${SENSOR}.down ] && [ "$(ipmitool -I lanplus -H ${PW_HOST_IDRACS[${SENSOR}]} -U ${PW_ESXI_USER} -P "${ESXI_PASS}" chassis power status | grep 'Power is on')" != "" ]; then
					HOST_WATT_SENSORS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1 -O vq | sed -e 's/"//g')
					if [[ "${HOST_WATTS}" != *"Timeout"* ]] && [ "${HOST_WATT_SENSORS}" != "" ]; then
						IFS=$'\n'
						read -rd '' -a HOST_WATT_SENSORS <<<"${HOST_WATT_SENSORS}"
						unset IFS
						if [ ! -f ${PW_TMPFOLDER}/${SENSOR}.disable ] || ([ -f ${PW_TMPFOLDER}/${SENSOR}.disable ] && [ $(expr `date +%s` - $(stat -c %Y ${PW_TMPFOLDER}/${SENSOR}.disable)) -ge 120 ]); then
							[ -f ${PW_TMPFOLDER}/shutdown.${PW_HOST_ADDRESSES[${SENSOR}]} ] && rm -f ${PW_TMPFOLDER}/shutdown.${PW_HOST_ADDRESSES[${SENSOR}]}
							[ -f ${PW_TMPFOLDER}/shutdown.ALL ] && rm -f ${PW_TMPFOLDER}/shutdown.ALL
							[[ "${PW_OFFSITE_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.OFFSITE
							[[ "${PW_MAINSITE_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.MAINSITE
							[[ "${PW_MAIN_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.MAIN
							[[ "${PW_SYS_HOSTS}" = *"${PW_HOST_ADDRESSES[${SENSOR}]}"* ]] && rm -f ${PW_TMPFOLDER}/shutdown.SYS
							rm -f ${PW_TMPFOLDER}/${SENSOR}.disable
						fi
					
					
						PS1='0.0'; PS2='0.0'; HOST_WATTS=0
						for s in {1..5}; do
							DP=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.8.1.${s} | sed 's/.*: //')
							if [[ "${DP}" = *"System Board"* ]]; then
								found=1
								HOST_WATTS=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
					
							elif [[ "${DP}" = *"PS1"* ]]; then
								PS1=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							elif [[ "${DP}" = *"PS2"* ]]; then
								PS2=$(snmpwalk -t 1 -r 0 -v 1 -c public ${PW_HOST_IDRACS[${SENSOR}]} iso.3.6.1.4.1.674.10892.5.4.600.30.1.6.1.${s} | sed 's/.*: //')
							fi
						done
						if [ ${found} -eq 1 ] && [ "${HOST_WATTS}" != "0" ] && [ "${HOST_WATTS}" != "" ] && [[ "${HOST_WATTS}" != *"Timeout"* ]]; then
							[ "${PS1}" != "0.0" ] && PS1=`echo "scale=1; ${PS1}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS1} < 1") )) && [[ "${PS1}" = *"."* ]] && PS1="0${PS1}"
							[ "${PS2}" != "0.0" ] && PS2=`echo "scale=1; ${PS2}/10" | tr -d $'\r' | bc` && (( $(bc <<<"${PS2} < 1") )) && [[ "${PS2}" = *"."* ]] && PS2="0${PS2}"
							HOST_AMPS=`echo "scale=1; ${PS1}+${PS2}" | tr -d $'\r' | bc`
							QRY="INSERT INTO power_data (sensorid, date, amp, watt) VALUES ('${PW_POWERSENSOR_ID[${SENSOR}]}',CONVERT_TZ('${LogDataTime}', 'America/Chicago', 'UTC'),'${HOST_AMPS}','${HOST_WATTS}')"
							${mysql_conn} -e "USE servermonitor; ${QRY}"
						fi
					fi
				fi
			done
			
			
		fi
		
		if ([ "$(compgen -G "${PW_TMPFOLDER}/temp.*")" != "" ] && [ "$(compgen -G "${PW_TMPFOLDER}/temp.*CPU*")" = "" ]) || [ "$(compgen -G "${PW_TMPFOLDER}/power.*.low")" != "" ]; then
			runEvery=${PW_MYSQL_LOG_INTERVAL_ABNORMAL}
		else
			runEvery=${PW_MYSQL_LOG_INTERVAL_NORMAL}
		fi
		end=`date +%s`; runtime=$((end-start))
		# echo -e "script runtime: ${runtime}s"; echo "Sleeping for $(( (runEvery*60) - runtime ))s"
		echo "${log_start}~${runtime}~powerlogger" >> ${PW_LOGFOLDER}/service.scantimes
		
		[ ${runtime} -lt $((runEvery*60)) ] && sleep $(( (runEvery*60) - runtime ))s
		
	done
}

HOSTPOWER(){
	if [ "${PW_iDRACHOST_SHORTNAMES[${1}]}" != "" ]; then
		idracip=${1}
	elif [ "${PW_ESXI_HOST_NAMES[${1}]}" != "" ]; then
		tmp=${PW_ESXI_HOST_NAMES[${1}]}
		idracip=${PW_HOST_IDRACS[${tmp}]}
	elif [ "${PW_HOST_IDRACS[iDS-vMS-Host${1}]}" != "" ]; then
		idracip=${PW_HOST_IDRACS[iDS-vMS-Host${1}]}
	elif ([ "${1::1}" = "o" ] || [ "${1::1}" = "O" ]) && [ "${PW_HOST_ADDRESSES[OFF-vMS-Host${1: -1}]}" != "" ]; then
		idracip=${PW_HOST_IDRACS[OFF-vMS-Host${1: -1}]}
	elif [ "${PW_HOST_IDRACS[${1}]}" != "" ]; then
		idracip=${PW_HOST_IDRACS[${1}]}
	else
		idracip=''
	fi
	[[ "${idracip}" = "10.6.1."* ]] && ESXI_PASS=${PW_ESXI_PASS_KP} || ESXI_PASS=${PW_ESXI_PASS}
		
	echo -e "\n${idsCL[Yellow]}POWERING ${2^^} '${PW_iDRACHOST_SHORTNAMES[${idracip}]}'"
	DIVIDER . yellow ${PRI_WIDTH}
	
	if [ "${idracip}" != "" ]; then
		
		if [ "${2^^}" = "ON" ] || [ "${2^^}" = "OFF" ] || [ "${2^^}" = "STATUS" ]; then
			if [ "${idracip}" = "${PW_HOST_IDRACS[${PW_ESXI_HOST_NAMES[${PW_ISCSI_PRI_HOST}]}]}" ] && [ "${2^^}" = "ON" ]; then
				MSG="Powering ON the SAS Enclosure"
				c=0; MSG_SPC=''; spc1=`expr ${HC_CW} - ${#MSG}`; until [ ${c} = ${spc1} ]; do MSG_SPC="${MSG_SPC} "; ((c++)); done
				echo -en "\n${idsCL[LightCyan]}${MSG}${MSG_SPC}: "
				if [ ${TESTMODE} -eq 0 ]; then
					current_status=$(snmpwalk -t 3 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4.14 | sed 's/.*: //')
					if [ "${current_status}" != "" ] && [ "${current_status}" != "1" ]; then
						run=$(snmpset -v 1 -c private ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4.14 i 1 >/dev/null 2>&1)
						sleep 3s
						echo -e "${idsCL[Green]}Done${idsCL[Default]}\n"
					elif [ "${current_status}" = "1" ]; then
						echo -e "${idsCL[Green]}SAS Enclosure Already Powered ON${idsCL[Default]}\n"
					fi
				else
					echo -e "${idsCL[Yellow]}(TEST MODE)${idsCL[Default]}"
				fi
			fi
			
			if [ ${TESTMODE} -eq 0 ]; then
				current_status=$(ipmitool -I lanplus -H ${idracip} -U ${PW_ESXI_USER} -P "${ESXI_PASS}" chassis power status | grep "Power is ${2,,}")
				if [ "${current_status}" = "" ]; then
					echo -e "${idsCL[Green]}"
					ipmitool -I lanplus -H ${idracip} -U ${PW_ESXI_USER} -P "${ESXI_PASS}" chassis power ${2,,}
				else
					echo -e "\n${idsCL[LightCyan]}Host is already Powered ${2^^}${idsCL[Default]}"

				fi
			else
				echo -e "\n${idsCL[Yellow]}(TEST MODE)"
			fi
			echo -e "${idsCL[Default]}"
			
			if [ "${idracip}" = "${PW_HOST_IDRACS[${PW_ESXI_HOST_NAMES[${PW_ISCSI_PRI_HOST}]}]}" ] && [ "${2^^}" = "OFF" ]; then
				MSG="Powering OFF the SAS Enclosure"
				c=0; MSG_SPC=''; spc1=`expr ${HC_CW} - ${#MSG}`; until [ ${c} = ${spc1} ]; do MSG_SPC="${MSG_SPC} "; ((c++)); done
				echo -en "${idsCL[LightCyan]}${MSG}${MSG_SPC}: "
				if [ ${TESTMODE} -eq 0 ]; then
					if [ "$(CHECK_HOST ${PW_ISCSI_PRI_HOST})" = "false" ]; then
						run=$(snmpset -v 1 -c private ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4.14 i 2 >/dev/null 2>&1)
						sleep 3s
						echo -e "${idsCL[Green]}Done${idsCL[Default]}\n"
					else
						echo -e "${idsCL[LightRed]}'${PW_iDRACHOST_SHORTNAMES[${idracip}]}' is not offline, not powering down\n"
					fi
				else
					echo -e "${idsCL[Yellow]}(TEST MODE)${idsCL[Default]}"
				fi
			fi
		else
			echo -e "${idsCL[LightRed]}'${2^^}' command is not recognized${idsCL[Default]}"
		fi
	else
		echo -e "${idsCL[LightRed]}Host cannot be found for '${1}'${idsCL[Default]}"
	fi
	echo -e "${idsCL[Default]}\n"
}

PDUCONTROL(){
	function exitspacing {
		echo -e "\n\033[K\n\033[K"
		exit 0
	}
	trap exitspacing EXIT
	
	while [ $# -gt 0 ]; do
		case "$1" in
			-port) PORT_SEL=${2};;
		esac
		shift 1
	done
	echo
	DIVIDER . yellow ${PRI_WIDTH}
	echo -e "${idsCL[Yellow]}APC-PDU Power Control"
	DIVIDER true yellow ${PRI_WIDTH}
	until [ "${PORTSEL^^}" = "E" ]; do
		[ "${PORT_SEL}" != "" ] && PORTSEL=${PORT_SEL}
		if [ "${PORTSEL}" = "" ]; then
			PORT_DESC=$(snmpwalk -t 3 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.2 -O vq 2> /dev/null | sed -e 's/"//g')
			PORT_POWER=$(snmpwalk -t 3 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4 -O vq 2> /dev/null | sed -e 's/"//g')
			IFS=$'\n'
			read -rd '' -a PORT_DESC <<<"${PORT_DESC}"
			read -rd '' -a PORT_POWER <<<"${PORT_POWER}"
			unset IFS
			for p in "${!PORT_DESC[@]}"; do
				port=$(expr ${p} + 1)
				[ ${PORT_POWER[${p}]} -eq 1 ] && portpower_disp="${idsCL[Green]}ON" || portpower_disp="${idsCL[LightRed]}OFF"
				[ ${port} -lt 10 ] && pp=" ${port}" || pp=${port}
				c=0; spc=''; spc1=`expr 28 - ${#PORT_DESC[${p}]}`; until [ ${c} = ${spc1} ]; do spc="${spc} "; ((c++)); done
				echo -e "${pp}) ${idsCL[LightCyan]}${PORT_DESC[${p}]}${spc}${idsCL[Default]}: ${portpower_disp}${idsCL[Default]}"
			done
			echo -e ""
			echo -e ""
			echo -e "(${idsCL[Yellow]}E${idsCL[Default]})xit"
			echo -e ""
			echo -e "\033[5A"
			# until [ "${PORTSEL}" != "" ]; do
				echo -en "\n${idsCL[LightCyan]}Enter the port number to control: ${idsCL[Default]}"
				read PORTSEL
				echo
			# done
		fi
	
		[ "${PORTSEL^^}" = "E" ] && exit 0
		
		[ "${PORTSEL}" != "" ] && tp=$(expr ${PORTSEL} - 1)
		if [ "${PORTSEL}" != "" ] && [[ "${PORTSEL}" =~ ^[0-9]+$ ]] && [ "${PORT_DESC[${tp}]}" != "" ] && [ ${PORTSEL} -ne 0 ]; then
			# portsel_power=$(snmpwalk -t 3 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4.${PORTSEL} -O vq 2> /dev/null | sed -e 's/"//g')
			[ ${PORT_POWER[${tp}]} -eq 1 ] && portsel_power_disp="${idsCL[Green]}ON" || portsel_power_disp="${idsCL[LightRed]}OFF"
			[ ${PORT_POWER[${tp}]} -eq 2 ] && portsel_change_power_disp="${idsCL[Green]}ON" || portsel_change_power_disp="${idsCL[LightRed]}OFF"

			# portdesc=$(snmpwalk -t 3 -r 0 -v 1 -c public ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.2.${PORTSEL} -O vq 2> /dev/null | sed -e 's/"//g')
			DIVIDER . yellow 60
			echo -e "${idsCL[Yellow]}Port ${idsCL[LightYellow]}${PORTSEL}${idsCL[Default]}) ${idsCL[LightCyan]}${PORT_DESC[${tp}]}  ${idsCL[Default]}: ${portsel_power_disp}${idsCL[Default]}\n"
		
			echo -en "${idsCL[LightCyan]}Are you sure you wish to turn ${portsel_change_power_disp}${idsCL[LightCyan]} (port ${PORTSEL}) ${idsCL[Yellow]}${PORT_DESC[${tp}]}${idsCL[Default]} (y/N): "
			read -n 1 portchange_confirm
		    case "${portchange_confirm}" in
		        [Yy])
					[ ${PORT_POWER[${tp}]} -eq 1 ] && portsel_change=2 || portsel_change=1
					echo -en "\n\n${idsCL[LightCyan]}Turning ${portsel_change_power_disp}${idsCL[LightCyan]} port ${idsCL[Yellow]}${PORTSEL}${idsCL[Default]} ... "
					run=$(snmpset -v 1 -c private ${PW_APCPDU_IP} .1.3.6.1.4.1.318.1.1.12.3.3.1.1.4.${PORTSEL} i ${portsel_change} >/dev/null 2>&1)
					echo -e "${idsCL[Green]}Done${idsCL[Default]}"
					echo
					;;

			esac
			[ "${PORT_SEL}" = "" ] && unset PORTSEL
		else
			echo -e "\n${idsCL[LightRed]}Not a valid port number${idsCL[Default]}"
			unset PORTSEL

		fi
		[ "${PORT_SEL}" != "" ] && exit 0 || echo
	done
	
}

SENDPOWER(){
	st_power=`${PW_SCRIPT} check power -m -p -r`
	SENDNOTICE "${1}" "${st_power}"
}

OFFSITE_SENDPOWER(){
	st_power=`${PW_SCRIPT} check temp -o -S -r -x usage; ${PW_SCRIPT} check power -o -p -r`
	SENDNOTICE "${1}" "${st_power}" 0 cosmic
}

GET_TUYA_POWER(){
	INFO=$(curl -m 3 -s http://${PW_REMOTE_SENSORS[${1}]}:8888/status/${PW_SENSOR_DEVICEID[${1}]} | jq '.dps')
	if [ "${INFO}" != "" ]; then
		WATT=-1
		if [ "$(echo "${INFO}" | grep '"18":')" != "" ]; then
			AMP=$(echo "${INFO}" | grep '"18":' | cut -d' ' -f 4 | sed 's/,//g')
			AMP=$(ROUND_NUMBER $(echo "scale=3; ${AMP}/1000" | tr -d $'\r' | bc -l) 2)
			WATT=$(echo "${INFO}" | grep '"19":' | cut -d' ' -f 4 | sed 's/,//g')
			WATT=$(echo "scale=1; ${WATT}/10" | tr -d $'\r' | bc -l)
			VOLT=$(echo "${INFO}" | grep '"20":' | cut -d' ' -f 4 | sed 's/,//g')
			VOLT=$(echo "scale=1; ${VOLT}/10" | tr -d $'\r' | bc -l)
		elif [ "$(echo "${INFO}" | grep '"6":')" != "" ]; then
			AMP=$(echo "${INFO}" | grep '"4":' | cut -d' ' -f 4 | sed 's/,//g')
			AMP=$(ROUND_NUMBER $(echo "scale=3; ${AMP}/1000" | tr -d $'\r' | bc -l) 2)
			WATT=$(echo "${INFO}" | grep '"5":' | cut -d' ' -f 4 | sed 's/,//g')
			WATT=$(echo "scale=1; ${WATT}/10" | tr -d $'\r' | bc -l)
			VOLT=$(echo "${INFO}" | grep '"6":' | cut -d' ' -f 4 | sed 's/,//g')
			VOLT=$(echo "scale=1; ${VOLT}/10" | tr -d $'\r' | bc -l)
		fi
		[ "${WATT}" != "-1" ] && echo "${AMP}:${WATT}:${VOLT}" || echo "0:0:0"
	fi
}