Power PowerControlKnob::findLowestPowerLimitRequest()
{
if (m_requests.size() == 0)
{
const auto& pl1Capabilities = m_powerControl->getCapabilities().getCapability(PowerControlType::PL1);
return pl1Capabilities.getMaxPowerLimit();
}
else
{
Power lowestPower;
for (auto request = m_requests.begin(); request != m_requests.end(); request++)
{
if (lowestPower.isValid() == false)
{
lowestPower = request->second;
}
else
{
if (request->second < lowestPower)
{
lowestPower = request->second;
}
}
}
return lowestPower;
}
}
void StartInstance::Launch()
{
isInit = true;
VirtualMachine *vm = new VirtualMachine();
if (isInit)
{
Power *p = new Power();
std::cout << "V1" << std::endl;
map->seeMap();
std::cout << "-----------" << std::endl;
map = p->findPowerOnMap(map);
std::cout << "V2" << std::endl;
map->seeMap();
std::cout << "-----------" << std::endl;
vm->setMap(map->getMap());
vm->Launch(*map->getMap());
}
else
{
std::string error = "Error Initialisation";
throw myException(error);
}
}
// TODO: Expand to allow for more functions.
// TODO: When parsing e^(f(z)), use Exponential class instead of Power class.
// Evaluates the given expression tree on the given variable value.
ComplexNumber evaluate_tree(const ExpressionTreeNode *root, const ComplexNumber z) {
if (root->is_op_node()) {
ExpressionTreeBinaryOp *temp = (ExpressionTreeBinaryOp *) root;
ComplexNumber left = evaluate_tree(temp->get_left(), z);
ComplexNumber right = evaluate_tree(temp->get_right(), z);
// Find the appropriate operator, apply, then return.
if (temp->get_operator() == PLUS) {
return left + right;
} else if (temp->get_operator() == MINUS) {
return left - right;
} else if (temp->get_operator() == TIMES) {
return left * right;
} else if (temp->get_operator() == DIVIDE) {
return left / right;
} else { // temp->get_operator() == EXP
Power p (right);
return p.eval(left);
}
} else if (root->is_func_node()) {
ExpressionTreeFunction *temp = (ExpressionTreeFunction *) root;
ComplexNumber arg = evaluate_tree(temp->get_argument(), z);
// Find the appropriate function, evaluate, then return.
if (temp->get_function() == LOG) {
Logarithm l (1, 0);
return l.eval(arg);
} else if (temp->get_function() == SIN) {
Sine s (1, 1, 0);
return s.eval(arg);
} else if (temp->get_function() == COS) {
Cosine c (1, 1, 0);
return c.eval(arg);
} else { // temp->get_function() == TAN
Tangent t (1, 1, 0);
return t.eval(arg);
}
} else if (root->is_leaf_node()) {
ExpressionTreeLeaf *temp = (ExpressionTreeLeaf *) root;
return temp->get_val(); // Return the value itself
} else if (root->is_const_node()) {
ExpressionTreeConstant *temp = (ExpressionTreeConstant *) root;
// Return the corresponding mathematical constant
if (temp->get_constant() == e) {
return E;
} else if (temp->get_constant() == pi) {
return PI;
} else { // temp->get_constant() == phi
return PHI;
}
} else { // root->is_var_node()
return z;
}
}
Expression * Division::shallowReduce(Context& context, AngleUnit angleUnit) {
Expression * e = Expression::shallowReduce(context, angleUnit);
if (e != this) {
return e;
}
Power * p = new Power(operand(1), new Rational(-1), false);
Multiplication * m = new Multiplication(operand(0), p, false);
detachOperands();
p->shallowReduce(context, angleUnit);
replaceWith(m, true);
return m->shallowReduce(context, angleUnit);
}
std::shared_ptr<XmlNode> PowerControlKnob::getXml() const
{
auto knobStatus = XmlNode::createWrapperElement("power_control_status");
if (m_powerControl->supportsPowerControls())
{
auto pl1Capabilities = m_powerControl->getCapabilities().getCapability(PowerControlType::PL1);
knobStatus->addChild(pl1Capabilities.getXml());
Power currentPowerLimit = m_powerControl->getPowerLimitPL1();
auto powerControl = XmlNode::createDataElement("power_limit", currentPowerLimit.toString());
knobStatus->addChild(powerControl);
}
return knobStatus;
}
void Power::throwIfInvalid(const Power& power) const
{
if (power.isValid() == false)
{
throw dptf_exception("Power is invalid.");
}
}
Bool Power::operator==(const Power& rhs) const
{
// Do not throw an exception if power is not valid.
if (this->isValid() == true && rhs.isValid() == true)
{
return (this->m_power == rhs.m_power);
}
else if (this->isValid() == false && rhs.isValid() == false)
{
return true;
}
else
{
return false;
}
}
void PowerControlKnob::limit(UIntN target)
{
if (canLimit(target))
{
try
{
getPolicyServices().messageLogging->writeMessageDebug(PolicyMessage(
FLF, "Calculating request to limit power controls.", getParticipantIndex(), getDomainIndex()));
const auto& pl1Capabilities = m_powerControl->getCapabilities().getCapability(PowerControlType::PL1);
Power minimumPowerLimit = pl1Capabilities.getMinPowerLimit();
Power stepSize = pl1Capabilities.getPowerStepSize();
Power nextPowerLimit(pl1Capabilities.getMaxPowerLimit());
Power targetRequest = getTargetRequest(target);
if (targetRequest >= pl1Capabilities.getMaxPowerLimit())
{
// limit one step from current power
Power currentPower = m_powerControl->getAveragePower();
getPolicyServices().messageLogging->writeMessageDebug(PolicyMessage(
FLF, "Current power is " + currentPower.toString() + ".", getParticipantIndex(), getDomainIndex()));
nextPowerLimit = calculateNextLowerPowerLimit(currentPower, minimumPowerLimit, stepSize, targetRequest);
}
else
{
// limit one step size down
nextPowerLimit = std::max((int)targetRequest - (int)stepSize, (int)minimumPowerLimit);
}
m_requests[target] = nextPowerLimit;
stringstream message;
message << "Requesting to limit power to " << nextPowerLimit.toString() << ".";
getPolicyServices().messageLogging->writeMessageDebug(
PolicyMessage(FLF, message.str(), getParticipantIndex(), getDomainIndex()));
}
catch (std::exception& ex)
{
getPolicyServices().messageLogging->writeMessageDebug(
PolicyMessage(FLF, ex.what(), getParticipantIndex(), getDomainIndex()));
throw ex;
}
}
}
Bool PowerControlKnob::commitSetting()
{
try
{
if (m_powerControl->supportsPowerControls())
{
// find lowest power limit in request
Power lowestPowerLimit = snapToCapabilitiesBounds(findLowestPowerLimitRequest());
// set new power status
Power currentPowerLimit = m_powerControl->getPowerLimitPL1();
if (currentPowerLimit != lowestPowerLimit)
{
stringstream messageBefore;
messageBefore << "Attempting to change power limit to " << lowestPowerLimit.toString() << ".";
getPolicyServices().messageLogging->writeMessageDebug(
PolicyMessage(FLF, messageBefore.str(), getParticipantIndex(), getDomainIndex()));
m_powerControl->setPowerLimitPL1(lowestPowerLimit);
stringstream messageAfter;
messageAfter << "Changed power limit to " << lowestPowerLimit.toString() << ".";
getPolicyServices().messageLogging->writeMessageDebug(
PolicyMessage(FLF, messageAfter.str(), getParticipantIndex(), getDomainIndex()));
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
catch (std::exception& ex)
{
getPolicyServices().messageLogging->writeMessageDebug(
PolicyMessage(FLF, ex.what(), getParticipantIndex(), getDomainIndex()));
throw ex;
}
}
std::string DomainPlatformPowerControl_001::createStatusStringForLimitValue(PlatformPowerLimitType::Type limitType)
{
try
{
if (isEnabled(limitType))
{
Power powerLimit = getPlatformPowerLimit(getParticipantIndex(), getDomainIndex(),
limitType);
return powerLimit.toString();
}
else
{
return "DISABLED";
}
}
catch (...)
{
return "ERROR";
}
}
std::string DomainPowerControl_001::createStatusStringForLimitValue(PowerControlType::Type controlType)
{
try
{
if (isEnabled(controlType))
{
Power powerLimit = getPowerLimit(getParticipantIndex(), getDomainIndex(), controlType);
return powerLimit.toString();
}
else
{
return "DISABLED";
}
}
catch (primitive_not_found_in_dsp)
{
return "NOT SUPPORTED";
}
catch (...)
{
return "ERROR";
}
}
void shutdown() {
display.shutdown();
radio::disable();
audio_codec.reset();
clock_manager.shutdown();
power.shutdown();
// TODO: Wait a bit for supplies to discharge?
chSysDisable();
systick_stop();
hackrf::one::reset();
}
int main(void)
{
char i = 0;
Systick_Init();
button.rise(&toggle);
while (1)
{
Delay(250);
led1 = !led1;
if(i >= 20)
{
i = 0;
led1 = 0;
power.stop();
}
else i++;
}
}
void init() {
for(const auto& pin : pins) {
pin.init();
}
/* Configure other pins */
LPC_SCU->SFSI2C0 =
(1U << 3)
| (1U << 11)
;
power.init();
gpio_max5864_select.set();
gpio_max5864_select.output();
gpio_max2837_select.set();
gpio_max2837_select.output();
led_usb.setup();
led_rx.setup();
led_tx.setup();
clock_manager.init();
clock_manager.set_reference_ppb(persistent_memory::correction_ppb());
clock_manager.run_at_full_speed();
clock_manager.start_audio_pll();
audio_codec.init();
clock_manager.enable_first_if_clock();
clock_manager.enable_second_if_clock();
clock_manager.enable_codec_clocks();
radio::init();
touch::adc::init();
}
int main(){
Power *p = new Power();
// printf("ResistanceVal : %f",p->ResistanceVal());
int loop=1;
while(loop){
printf("Enter one of the Menu items:\n");
printf("1.Resistance:\n");
printf("2.Current:\n");
printf("3.Band colors:\n");
printf("4.Exit:\n");
int inp;
float r,c;
char str1[8],str2[8],str3[8];
scanf("%d",&inp);
switch(inp){
case 1 :
printf("Enter Resistance\n");
scanf("%f",&r);
p->ChangeResistance(r);
printf("ResistanceVal:=%f\n",p->ResistanceVal());
printf("CurrentVal:=%f\n",p->CurrentVal());
printf("VoltageVal:=%f\n",p->VoltageVal());
printf("Power:=%f\n",p->get_power());
break;
case 2 :
printf("Enter Current\n");
scanf("%f",&c);
p->ChangeCurrent(c);
printf("ResistanceVal:=%f\n",p->ResistanceVal());
printf("CurrentVal:=%f\n",p->CurrentVal());
printf("VoltageVal:=%f\n",p->VoltageVal());
printf("Power:=%f\n",p->get_power());
break;
case 3 :
printf("Enter First String\n");
gets(str1);
printf("Enter Second String\n");
gets(str2);
printf("Enter Third String\n");
gets(str3);
p->BandResistance(str1,str2,str3);
printf("ResistanceVal:=%f\n",p->ResistanceVal());
printf("CurrentVal:=%f\n",p->CurrentVal());
printf("VoltageVal:=%f\n",p->VoltageVal());
printf("Power:=%f\n",p->get_power());
break;
case 4 :
loop=0;
break;
}
}
return 0;
}
namespace portapack {
portapack::IO io {
portapack::gpio_dir,
portapack::gpio_lcd_rd,
portapack::gpio_lcd_wr,
portapack::gpio_io_stbx,
portapack::gpio_addr,
portapack::gpio_lcd_te,
portapack::gpio_unused,
};
lcd::ILI9341 display;
I2C i2c0(&I2CD0);
SPI ssp0(&SPID1);
SPI ssp1(&SPID2);
wolfson::wm8731::WM8731 audio_codec { i2c0, portapack::wm8731_i2c_address };
si5351::Si5351 clock_generator {
i2c0, hackrf::one::si5351_i2c_address
};
ClockManager clock_manager {
i2c0, clock_generator
};
ReceiverModel receiver_model {
clock_manager
};
TransmitterModel transmitter_model {
clock_manager
};
uint8_t bl_tick_counter = 0;
class Power {
public:
void init() {
/* VAA powers:
* MAX5864 analog section.
* MAX2837 registers and other functions.
* RFFC5072 analog section.
*
* Beware that power applied to pins of the MAX2837 may
* show up on VAA and start powering other components on the
* VAA net. So turn on VAA before driving pins from MCU to
* MAX2837.
*/
/* Turn on VAA */
gpio_vaa_disable.clear();
gpio_vaa_disable.output();
/* 1V8 powers CPLD internals.
*/
/* Turn on 1V8 */
gpio_1v8_enable.set();
gpio_1v8_enable.output();
/* Set VREGMODE for switching regulator on HackRF One */
gpio_vregmode.set();
gpio_vregmode.output();
}
void shutdown() {
gpio_1v8_enable.clear();
gpio_vaa_disable.set();
}
private:
};
static Power power;
void init() {
for(const auto& pin : pins) {
pin.init();
}
/* Configure other pins */
LPC_SCU->SFSI2C0 =
(1U << 3)
| (1U << 11)
;
power.init();
gpio_max5864_select.set();
gpio_max5864_select.output();
gpio_max2837_select.set();
gpio_max2837_select.output();
led_usb.setup();
led_rx.setup();
led_tx.setup();
clock_manager.init();
clock_manager.set_reference_ppb(persistent_memory::correction_ppb());
clock_manager.run_at_full_speed();
clock_manager.start_audio_pll();
audio_codec.init();
clock_manager.enable_first_if_clock();
clock_manager.enable_second_if_clock();
clock_manager.enable_codec_clocks();
radio::init();
touch::adc::init();
}
void shutdown() {
display.shutdown();
radio::disable();
audio_codec.reset();
clock_manager.shutdown();
power.shutdown();
// TODO: Wait a bit for supplies to discharge?
chSysDisable();
systick_stop();
hackrf::one::reset();
}
extern "C" {
void __late_init(void) {
reset();
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
/* After this call, scheduler, systick, heap, etc. are available. */
/* By doing chSysInit() here, it runs before C++ constructors, which may
* require the heap.
*/
chSysInit();
}
}
} /* namespace portapack */
// Override.
ComplexNumber NthRoot::eval(const ComplexNumber z) const {
Power power (1 / n);
return power.eval(z);
}
