<?php
require('../includes/header.php');

   
 
?>


<!doctype html>
<html class="no-js" lang="en">


<head>
    <meta charset="utf-8">
    <meta http-equiv="x-ua-compatible" content="ie=edge">
    <title>TUTORIAL || POWER LINKS CTG</title>
    <meta name="description" content="">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    
    
    <meta property="og:url"                content="https://powerlinksctg.com/" />
<meta property="og:type"               content="article" />
<meta property="og:title"              content="POWER LINKS CTG" />
<meta property="og:description"        content="POWERLINKSCTG has been proud to serve local businesses for many years, providing high quality and reliable electrical services you can trust. No matter what issue you’re experiencing with your business’s electricity, we guarantee that we will quickly identify the problem and find a lasting solution." />
<meta property="og:image"              content="https://powerlinksctg.com/plc/images/about/voltage.png" />
<meta property="fb:app_id"             content="https://www.facebook.com/powerlinksctg/" />
    
    <!-- Place favicon.ico in the root directory -->
    <link rel="shortcut icon" type="image/x-icon" href="../images/icon.png">
    <link rel="apple-touch-icon" href="apple-touch-icon.png">

<style>
#more {display: none;}

</style>	
	

</head>

<body>
    
<div class="profile-tabs">
<section class="htc__blog__area ptb--150 bg__white">
            <div class="container">
                <div class="row">
                	<div class="col-md-6 col-lg-6 col-sm-12 col-xs-12">
                		<div class="htc__blog__wrap clearfix blog--one">
	                        <!-- Start Single Blog -->
                            <div class="blog">
                                
                                <div  id="navigator" class="tab-content">
                                    
                                <div id="AbuotSalary" class="tab-pane active">
                                    <div class="col-xs-12">
                        <div class="section__title text-center">
                            <h2 class="title__line">Ampere To </br><span class="text--theme">Watts /Kilowatts </span> Calculator</h2>
                        </div>
                    </div>
                       <form method="post" action="calculator.php">
        <select name="operation" style=" display: inline">
		        	<option value="AC Single Phase">AC Single Phase</option>
		            <option value="AC three phase line to line voltage">AC three phase line to line voltage</option>
		            <option value="AC three phase line to neutral voltage">AC three phase line to neutral voltage</option>
		            
		 </select>
		 </br>
        <label for="y">Current (amps)</label></br>
		        <input name="number1" type="text" class="form-control" placeholder="Amps" style=" display: inline" />
		      </br>  
			<label for="y">Voltage (volts)</label></br>
		        <input name="number2" type="text" class="form-control" placeholder="Volts" style=" display: inline" />
		        </br>
		        <label for="y">Power factor (≤1)</label></br>
		        <input id="txtNumber" type="text"  name="pf" min="0" max="1" placeholder="Power factor (PF)" required="true" 
		        class="form-control" style=" display: inline" />
		        </br>
		        <span id="errorMsg" style="display:none; color:red;">You Can Give Score Power factor 0.1 To 1 Only</span>
		        </br>
		        <input id="errorMsg1" name="submit" type="submit" style="" value="Calculate" class="btn btn-primary" />
		        
		    </form>
		    	<div style="color:#fff; background-color: #fcc236;font-weight:bold; text-align: center; margin-top: 21px;" >	
			<?php
			
				// If the submit button has been pressed
				if(isset($_POST['submit']))
				{
					// Check number values
					if(is_numeric($_POST['number1']) && is_numeric($_POST['number2']) && is_numeric($_POST['pf']))
					{
						// Calculate total
						if($_POST['operation'] == 'AC Single Phase')
						{
							$total = $_POST['number1'] * $_POST['number2']* $_POST['pf'];
							$tota2 = $_POST['number1'] * $_POST['number2']* $_POST['pf']/1000;
						}
						if($_POST['operation'] == 'AC three phase line to line voltage')
						{
							$total = 1.73205081*$_POST['number1'] * $_POST['number2']* $_POST['pf'];
							$tota2 = 1.73205081*$_POST['number1'] * $_POST['number2']* $_POST['pf']/1000;	
						}
						if($_POST['operation'] == 'AC three phase line to neutral voltage')
						{
							$total = 3*$_POST['number1'] * $_POST['number2']* $_POST['pf'];
							$tota2 = 3*$_POST['number1'] * $_POST['number2']* $_POST['pf']/1000;	
						}
						
						
						// Print total to the browser
						echo "
					       Amp = {$_POST['number1']} , {$_POST['operation']} = {$_POST['number2']} , Pf = {$_POST['pf']} 
					       <h2> Kilowatts: {$tota2} KW </br> Watts: {$total} W</h2>";
					} else {
						
						// Print error message to the browser
						echo 'Numeric values are required';
					
					}
				}
			
			?>
		     </div>
		    
	   
		
		<hr>
		    
                      </div>  
                      

                      
                      <div id="Salary" class="tab-pane">
                          <div class="col-xs-12">
                        <div class="section__title text-center">
                            <h2 class="title__line">Kaisar <span class="text--theme">Hossain</span></h2>
                        </div>
                    </div>
                                <form method="post" action="calculator.php">
        <select name="operation" style=" display: inline">
		        	<option value="AC Single Phase">AC Single Phase</option>
		            <option value="AC three phase line to line voltage">AC three phase line to line voltage</option>
		            <option value="AC three phase line to neutral voltage">AC three phase line to neutral voltage</option>
		            
		 </select>
		 </br>
        <label for="y">Current (amps)</label></br>
		        <input name="number1" type="text" class="form-control" style=" display: inline" />
		      </br>  
			<label for="y">Voltage (volts)</label></br>
		        <input name="number2" type="text" class="form-control" style=" display: inline" />
		        </br>
		        <label for="y">Power factor (≤1)</label></br>
		        <input id="txtNumber" type="text"  name="pf" min="0" max="1"  required="true" 
		        class="form-control" style=" display: inline" />
		        </br>
		        <span id="errorMsg" style="display:none; color:red;">You Can Give Score Power factor 0.1 To 1 Only</span>
		        </br>
		        <input id="errorMsg1" name="submit" type="submit" style="" value="Calculate" class="btn btn-primary" />
		        
		    </form>
                      </div>
                      
                      
                      
                      
                      <div id="Monthlyfilter" class="tab-pane">
                          <div class="col-xs-12">
                        <div class="section__title text-center">
                            <h2 class="title__line">22222 <span class="text--theme">22222</span></h2>
                        </div>
                    </div>
                                <form method="post" action="calculator.php">
        <select name="operation" style=" display: inline">
		        	<option value="AC Single Phase">AC Single Phase</option>
		            <option value="AC three phase line to line voltage">AC three phase line to line voltage</option>
		            <option value="AC three phase line to neutral voltage">AC three phase line to neutral voltage</option>
		            
		 </select>
		 </br>
        <label for="y">Current (amps)</label></br>
		        <input name="number1" type="text" placeholder="Amps" class="form-control" style=" display: inline" />
		      </br>  
			<label for="y">Voltage (volts)</label></br>
		        <input name="number2" type="text" placeholder="Volts" class="form-control" style=" display: inline" />
		        </br>
		        <label for="y">Power factor (≤1)</label></br>
		        <input id="txtNumber" type="text" placeholder="Power factor" name="pf" min="0" max="1"  required="true" 
		        class="form-control" style=" display: inline" />
		        </br>
		        <span id="errorMsg" style="display:none; color:red;">You Can Give Score Power factor 0.1 To 1 Only</span>
		        </br>
		        <input id="errorMsg1" name="submit" type="submit" style="" value="Calculate" class="btn btn-primary" />
		        
		    </form>
		    

    

		    
		    
                      </div></div>
                     
                            </div>
	                        <!-- End Single Blog -->
	                        
	                        
                    	</div>
                	</div>
                	
                	<div class="col-md-6 col-lg-6 col-sm-12 col-xs-12 smt-40 xmt-40">
                		<div class="htc__page__sidebar">
                			
                			<!-- Start Single -->
                			<div class="htc__category bg__gray sidebar__separator">
                				<h2 class="sidebar__title"><svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-calculator-fill" viewBox="0 0 16 16">
  <path d="M2 2a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V2zm2 .5v2a.5.5 0 0 0 .5.5h7a.5.5 0 0 0 .5-.5v-2a.5.5 0 0 0-.5-.5h-7a.5.5 0 0 0-.5.5zm0 4v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5zM4.5 9a.5.5 0 0 0-.5.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1zM4 12.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5zM7.5 6a.5.5 0 0 0-.5.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1zM7 9.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5zm.5 2.5a.5.5 0 0 0-.5.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1zM10 6.5v1a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5zm.5 2.5a.5.5 0 0 0-.5.5v4a.5.5 0 0 0 .5.5h1a.5.5 0 0 0 .5-.5v-4a.5.5 0 0 0-.5-.5h-1z"/>
</svg>  CATEGORIES</h2>
                				<ul class="cat__list">
                		<li class="nav-item"><a  href="/plc/tutorials/calculator.php" data-toggle=""> Amperes To Watts /Kilowatts Calculator</a></li>
						<li class="nav-item"><a   href="/plc/tutorials/amp_to_kva.php" data-toggle="">Amperes to KVA / VA Calculator</a></li>
						<li class="nav-item"><a   href="/plc/tutorials/amps_to_volts.php" data-toggle="">Ampere To Volts / Ohms Calculator</a></li>
						<li class="nav-item"><a  href="/plc/tutorials/watts_to_amps.php" data-toggle="">Watts to Amps Calculator</a></li>
						<li class="nav-item"><a   href="/plc/tutorials/amp_to_watts.php" data-toggle="">=============</a></li>
						<li class="nav-item"><a   href="/plc/tutorials/single-Item.php" data-toggle="">============</a></li>
						<li class="nav-item"><a  href="/plc/tutorials/amp_to_watts.php" data-toggle="">============</a></li>
                			</div>
                			<!-- End Single -->
                		
                		</div>
                	</div>
                </div>
            </div>
        </section>
        </div>
    <hr>
calculator


		

		<hr>
<script>
$("#txtNumber" ).keyup(function() {
  if($('#txtNumber').val()<0.1 || $('#txtNumber').val()>1 ){
      $('#errorMsg').show();
  }
  else{
    $('#errorMsg').hide();
  }
});
</script>

<script>
$("#txtNumber" ).keyup(function() {
  if($('#txtNumber').val()<0.1 || $('#txtNumber').val()>1 ){
      $('#errorMsg1').hide();
  }
  else{
    $('#errorMsg1').show();
  }
});
</script>
=====================================

<script>
function myFunction() {
  var dots = document.getElementById("dots");
  var moreText = document.getElementById("more");
  var btnText = document.getElementById("myBtn");

  if (dots.style.display === "none") {
    dots.style.display = "inline";
    btnText.innerHTML = "Read more"; 
    moreText.style.display = "none";
  } else {
    dots.style.display = "none";
    btnText.innerHTML = "Read less"; 
    moreText.style.display = "inline";
  }
}
</script>


=================



	<title>Amps to Watts Calculator | Ampere To Watt Converter </title>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	
		    



<!-- ad begins -->

<div class="container" style="margin:0px">
<h2>Ampere To Watt Converter</h2>
<span id="dots"></span><span id="more">
<form>


<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12">
<label>Find</label>
<span class="width_100"> 
<select id="chname" onchange="focFunction();calculate()">
<option value="dc">DC</option>
<option value="ac1">AC-Single Phase</option>
<option value="ac2">AC-Three Phase</option>
</select> </span>
</div>
</br>
<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12">
<label>Amps</label>
<span><input id="ahname" type="text" >
</span> <span  id="aunit"></span>
</div>

<div id="qhname" class="col-md-7 col-lg-9 col-sm-12 col-xs-12" style="display: inline;">
<label>Select voltage type</label>
<span class="group_con_80"> 
<select id="shname" onchange="focFunction();calculate()">
<option value="ll">Line to line voltage</option>
<option value="ln">Line to neutral voltage</option>
</select> </span>
</div>

<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12">
<label>Volt</label>
<span class="width_100"><input id="vhname" type="text" class="easypositive">
</span> <span class="units" id="vunit"></span>
</div>

<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12" style="display: inline;" id="thname">
<label>Power Factor</label>
<span class="width_100"><input id="phname" type="text" class="easypositive">
</span> <span class="units" id="punit"></span>
</div>

<input class="col-md-7 col-lg-9 col-sm-12 col-xs-12" type="button"
value="Calculate" onclick="calculate()" style="visibility: visible;">
<input class="col-md-7 col-lg-9 col-sm-12 col-xs-12" type="reset"
value="Reset" onclick="clr()" style="visibility: visible;">
<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12" id="dynErrDisp">Enter Amps</div><div id="calciScroll"></div>

<div class="col-md-7 col-lg-9 col-sm-12 col-xs-12"><label>Watt</label><span class="width_100">
    <input class="col-md-7 col-lg-9 col-sm-12 col-xs-12" id="whname" type="text" class="easypositive" readonly="">
</span> <span class="col-md-7 col-lg-9 col-sm-12 col-xs-12" id="wunit">W</span>
</div>

</form>
</div></span>
		    <button onclick="myFunction()" id="myBtn">Read more</button></div>
	
<script type="text/javascript">
	var easyinputs = document.getElementsByTagName("INPUT");
	for (var ies = 0; ies < easyinputs.length; ies++)
	{
	    if (easyinputs[ies].type === 'button')
	    { 
		easyinputs[ies].style.visibility='hidden';
		if ((easyinputs[ies].offsetTop-10)<0)
		{
			document.getElementById("overlayLoader").style.top = (document.getElementById('dispCalcConts')
			.offsetTop+(document.getElementById('dispCalcConts').offsetHeight/4))+"px";
		}
		else
		{
			document.getElementById("overlayLoader").style.top = (easyinputs[ies].offsetTop-10)+"px";
		}
	    }
	    else
	    {
		document.getElementById("overlayLoader").style.top = (document.getElementById('dispCalcConts')
		.offsetTop+(document.getElementById('dispCalcConts').offsetHeight/4))+"px";
	    }
	    if (easyinputs[ies].type === 'reset')
	    { 
		easyinputs[ies].style.visibility='hidden';
	    }
	}
</script>

   
                
<script type="text/javascript">
	if(tblfilename!="allele-frequency-calculator.php") {
	  window._taboola = window._taboola || [];
	  _taboola.push({
	    mode: 'thumbnails-a',
	    container: 'taboola-below-article-thumbnails',
	    placement: 'Below Article Thumbnails',
	    target_type: 'mix'
	  });
	}
</script>

 

<script type="text/javascript">
	var chf_rss=true;
	function getPathFromUrl(url){return url.split("?")[0];}
	var curUrl = window.location.pathname; 
	var basName = curUrl.replace(/^.*[\/\\]/g, '');
	var curencyIndx = false;
</script>

<script src="jquery.min.js"></script>
<script src="common.js"></script>
<script src="jquery.sticky.js"></script>

<script>
var wresult;
function focFunction()
{
 var opt = $('#chname').val();

 if(opt=='dc')
 {
 document.getElementById('thname').style.display = 'none';
 document.getElementById('qhname').style.display = 'none';
 }
 else if(opt=='ac1')
 {
 document.getElementById('thname').style.display = 'inline';
 document.getElementById('qhname').style.display = 'none';
 }
 else if(opt=='ac2')
{
 document.getElementById('qhname').style.display = 'inline';
 document.getElementById('thname').style.display = 'inline';
}
}

 function calculate()
{
var ahname = easyCommonInputCalculation('a','','Amps');
var vhname = easyCommonInputCalculation('v','','Volt');

if((ahname!='')&&(vhname!=''))
{
var opt = $('#chname').val();
if(opt=='dc')
{
wresult = ahname*vhname;
var whname = easyCommonResultCalculation('w','easy');
$('#whname').val(easyRoundOf(whname,4));
}
else if(opt=='ac1')
{
var phname = easyCommonInputCalculation('p','','Power Factor');
if(phname<1.1)
{
	wresult = ahname*vhname*phname;
var whname = easyCommonResultCalculation('w','easy');
$('#whname').val(easyRoundOf(whname,4));
}
else
{
	alert('Enter the power factor between 0 and 1');
}
}
else if(opt=='ac2')
{
var opt1= $('#shname').val();
if(opt1=='ll')
{
var phname = easyCommonInputCalculation('p','','Power Factor');
if(phname<1.1)
{
wresult = ahname*vhname*phname*1.732;
var whname = easyCommonResultCalculation('w','easy');
$('#whname').val(easyRoundOf(whname,4));	
}
else
{
	alert('Enter the power factor between 0 and 1');
}

}
else
{
	
var phname = easyCommonInputCalculation('p','','Power Factor');
if(phname<1.1)
{
wresult = ahname*vhname*phname*3;
var whname = easyCommonResultCalculation('w','easy');
$('#whname').val(easyRoundOf(whname,4));
}
else
{
	alert('Enter the power factor between 0 and 1');
}
}
}
}
}
function clr()
{
 document.getElementById('thname').style.display = 'none';
 document.getElementById('qhname').style.display = 'none';
}
 </script>
		<script type="text/javascript">
		function alert(val)
		{
		    $("#dynErrDisp").show();
		    $("#dynErrDisp").html(val);
		}
		$(document).ready(function() {
			closeModal();
		});
		</script>

<script type="text/javascript">
	var mobiScrnWidth = $(window).width();
	function showhidetopcate(obj) {if (mobiScrnWidth < 480){var currightid = obj.id;if(currightid == "topcaterightbox")
	{$("#popcalcrightbox ul").hide();}else if(currightid == "popcalcrightbox") {$("#topcaterightbox ul").hide();}
	$("#"+currightid+" ul").show();}}
	$(document).ready(function(){if (mobiScrnWidth < 480){$("#popcalcrightbox ul").hide();
	$("#topcaterightbox ul").hide();}});
</script>

<script type="text/javascript">
if(tblfilename!="allele-frequency-calculator.php") {
  window._taboola = window._taboola || [];
  _taboola.push({flush: true});
}
</script> 

<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
</body>
</html>



<?php
require('../includes/footer.php');
?>