<?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">
    
    <!-- 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>	
<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>	

</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="amps_to_ volts.php" class="tab-pane active">
                                    <div class="col-xs-12">
                        <div class="section__title text-center">
                            <h2 class="title__line">Amperes To <span class="text--theme"></br> Volts With Watts / Ohms </span> Calculator</h2>
                        </div>
                    </div>
                       <form method="post" action="amps_to_volts.php">
        <select name="operation" style=" display: inline" class="country" id="txtNumber">
		        	<option value="Amp To Volt With Watts">Amp To Volt With Watts</option>
		            <option value="Amp To Volt With Ohms">Amp To Volt With Ohms</option>
		      
		 </select>
		 </br>
		
		 </br>
        <label id="dynErrDisp" for="y">Watts</label></br>
		        <input name="number1" type="text" placeholder="selected Option Watts = Watts / Ohms = Ohms" class="form-control" style=" display: inline" />
		      </br>  
			<label for="y">Amps </label></br>
		        <input name="number2" type="text" placeholder="Amps" class="form-control" style=" display: inline" />
		        </br>
		        
		        
		        <input  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']))
					{
						// Calculate total
						if($_POST['operation'] == 'Amp To Volt With Watts')
						{
							$total = $_POST['number1'] / $_POST['number2'];
							$tota2 = $_POST['number1'] * $_POST['number2']/1000;
						}
						if($_POST['operation'] == 'Amp To Volt With Ohms')
						{
							$total = $_POST['number1'] * $_POST['number2'];
							$tota2 = 1.73205081*$_POST['number1'] * $_POST['number2']/1000;	
						}
						if($_POST['operation'] == 'AC three phase line to neutral voltage')
						{
							$total = 3*$_POST['number1'] * $_POST['number2'];
							$tota2 = 3*$_POST['number1'] * $_POST['number2']/1000;	
						}
						
						
						// Print total to the browser
						echo "
					       Watts = {$_POST['number1']} , Amps = {$_POST['number2']} , {$_POST['operation']},
					       <h2> Volts: {$total} Volts ";
					} else {
						
						// Print error message to the browser
						echo 'Numeric values are required';
					
					}
				}
			
			?>
		     </div>
		    
	   
		
		<hr>
		    
                      </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">CATEGORIES</h2>
                				<ul class="cat__list">
                		<li class="nav-item"><a class="nav-link active" href="/plc/tutorials/calculator.php" data-toggle="">Ampere To Watts / Kilowatts Converter</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_kva.php" data-toggle="">Amps to KVA / VACalculator</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amps_to_volts.php" data-toggle="">Ampere To Volts / Ohms Calculator</a></li>
						<li class="nav-item"><a class="nav-link active" href="/plc/tutorials/amp_to_watts.php" data-toggle="">Abuot Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Monthly filter</a></li>
						<li class="nav-item"><a class="nav-link active" href="/plc/tutorials/amp_to_watts.php" data-toggle="">Abuot Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Monthly filter</a></li>
						<li class="nav-item"><a class="nav-link active" href="/plc/tutorials/amp_to_watts.php" data-toggle="">Abuot Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Salary</a></li>
						<li class="nav-item"><a class="nav-link"  href="/plc/tutorials/amp_to_watts.php" data-toggle="">Monthly filter</a></li>
                				</ul>
                			</div>
                			<!-- End Single -->
                		
                		</div>
                	</div>
                </div>
            </div>
        </section>
        </div>
    <hr>
calculator


		

		<hr>

<script>
$(document).ready(function(){
    $("select.country").change(function(){
        var selectedCountry = $(this).children("option:selected").val();
        alert("You have selected - " + selectedCountry);
    });
});
</script>

</script>
		<script type="text/javascript">
		function alert(val)
		{
		    $("#dynErrDisp").show();
		    $("#dynErrDisp").html(val);
		}
		$(document).ready(function() {
			closeModal();
		});
		</script>





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

</body>
</html>



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