void SystemProperties::ReadCallback(const prop_info* pi,
void (*callback)(void* cookie, const char* name,
const char* value, uint32_t serial),
void* cookie) {
// Read only properties don't need to copy the value to a temporary buffer, since it can never
// change.
if (is_read_only(pi->name)) {
uint32_t serial = Serial(pi);
if (pi->is_long()) {
callback(cookie, pi->name, pi->long_value(), serial);
} else {
callback(cookie, pi->name, pi->value, serial);
}
return;
}
while (true) {
uint32_t serial = Serial(pi); // acquire semantics
size_t len = SERIAL_VALUE_LEN(serial);
char value_buf[len + 1];
memcpy(value_buf, pi->value, len);
value_buf[len] = '\0';
// TODO: see todo in Read function
atomic_thread_fence(memory_order_acquire);
if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
callback(cookie, pi->name, value_buf, serial);
return;
}
}
}
int main(void)
{
for(int i=0;i<MY_N;i++)
{
scanf("%c", &eps[i]) ;
eps[i] -= '0' ;
if(eps[i]!=0 && eps[i]!=1) i-- ;
}
//for(int i=0;i<MY_N;i++) eps[i] = rand()%2 ;
std::cout << Frequency(MY_N, eps) << std::endl ;
std::cout << BlockFrequency(MY_N/100, MY_N, eps) << std::endl ;
std::cout << Runs(MY_N, eps) << std::endl ;
std::cout << LongestRunOfOnes(MY_N, eps) << std::endl ;
//std::cout << Rank(MY_N, eps) << std::endl ;
//std::cout << DiscreteFourierTransform(MY_N, eps) << std::endl ;
//std::cout << NonOverlappingTemplateMatchings(10, MY_N, eps) << std::endl ;
//std::cout << OverlappingTemplateMatchings(10, MY_N, eps) << std::endl ;
std::cout << Universal(MY_N, eps) << std::endl ;
std::cout << LinearComplexity(1000, MY_N, eps) << std::endl ;
std::cout << Serial(5, MY_N, eps) << std::endl ;
//std::cout << ApproximateEntropy(5, MY_N, eps) << std::endl ;
std::cout << CumulativeSums(MY_N, eps) << std::endl ;
//std::cout << RandomExcursions(MY_N, eps) << std::endl ;
//std::cout << RandomExcursionsVariant(MY_N, eps) << std::endl ;
return 0 ;
}
bool RNGTester::Test(unsigned char *eps, int n)
{
double p_value = 1.0 ;
std::cout << std::fixed << std::setprecision(6) ;
p_value = std::min(p_value, Frequency(n, eps) ) ;
p_value = std::min(p_value, BlockFrequency(n/100, n, eps) ) ;
p_value = std::min(p_value, Runs(n, eps) ) ;
p_value = std::min(p_value, LongestRunOfOnes(n, eps) ) ;
//p_value = std::min(p_value, Rank(n, eps) ) ;
//p_value = std::min(p_value, DiscreteFourierTransform(n, eps) ) ;
//p_value = std::min(p_value, NonOverlappingTemplateMatchings(10, n, eps) ) ;
//p_value = std::min(p_value, OverlappingTemplateMatchings(10, n, eps) ) ;
p_value = std::min(p_value, Universal(n, eps) ) ;
p_value = std::min(p_value, LinearComplexity(1000, n, eps) ) ;
p_value = std::min(p_value, Serial(5, n, eps) ) ;
//p_value = std::min(p_value, ApproximateEntropy(5, n, eps) ) ;
p_value = std::min(p_value, CumulativeSums(n, eps) ) ;
//p_value = std::min(p_value, RandomExcursions(n, eps) ) ;
//p_value = std::min(p_value, RandomExcursionsVariant(n, eps) ) ;
std::cout << "p_value = " << p_value << std::endl ;
return (p_value>=0.01) ;
}
ParNonlinearForm::ParNonlinearForm(ParFiniteElementSpace *pf)
: NonlinearForm(pf), pGrad(Operator::Hypre_ParCSR)
{
X.MakeRef(pf, NULL);
Y.MakeRef(pf, NULL);
MFEM_VERIFY(!Serial(), "internal MFEM error");
}
/**
* Serial object constructor tests.
*/
void SerialTest::Constructor() {
// create a Serial object
CPPUNIT_ASSERT_NO_THROW(Serial("/dev/ttyS0"));
// create a Serial object from a nonexistent file
CPPUNIT_ASSERT_THROW(Serial("f00bar"), std::runtime_error);
// create a Serial object from a file that is not a character device
CPPUNIT_ASSERT_THROW(Serial("bogus_serial_dev"), std::runtime_error);
/// @Todo Implement test to create a Serial object from a character device
/// file that can't be opened (no permission for example).
/// @Todo Implement test to create a Serial object that can't determine
/// and save it's mode.
}
void
TraceManager::ClearTrace()
{
append_serial = modify_serial = Serial();
trace_dirty = true;
trace.clear();
n_points = 0;
predicted = TracePoint::Invalid();
}
Serial::Serial() : Serial("/dev/ttyUSB0", 9600, false, false, 0, 0) {
#else
Serial::Serial() : Serial("\\\\.\\COM1", 9600, false, false, 0, 0) {
#endif
}
#ifndef _WIN32
Serial::Serial(const char *file, int baudRate, bool useParity, bool extraStopBit, unsigned char readMinChars, unsigned char readTimeout) : fd(0),
tty{0} {
//Set up serial interface
//http://linux.die.net/man/3/termios
fd = open(file, O_RDWR | O_NOCTTY);
if(fd < 0) {
Log::logf(Log::ERR, "Serial connection initialization failed!\n");
throw std::runtime_error("serial initialization failed");
}
//Input/output flags
tty.c_iflag = 0; //No input processing
if(useParity) {
tty.c_iflag |= INPCK; //Enable input parity checking
}
tty.c_oflag = 0; //No output processing
//Control flags
tty.c_cflag = CSIZE; //Character size mask
tty.c_cflag |= CS8; //8 data bits
if(useParity) {
tty.c_cflag &= PARENB; //Enable output parity generation and input parity checking
} else {
tty.c_cflag &= ~PARENB; //Disable parity generation
}
if(extraStopBit) {
tty.c_cflag &= CSTOPB; //2 stop bits
} else {
tty.c_cflag &= ~CSTOPB; //1 stop bit
}
tty.c_cflag |= CREAD; //Enable read
tty.c_cflag |= CLOCAL; //Ignore control lines
tty.c_cflag &= ~PARODD; //Even parity, if used
//Local flags
tty.c_lflag = 0; //No local processing: use non-canonical (raw) mode, disable echo, etc.
//Control characters
tty.c_cc[VMIN] = readMinChars; //Block on read until specified number of characters have been read
tty.c_cc[VTIME] = readTimeout; //Time-based read, or timeout for blocking read
//Set intial baud rate
setBaudRate(baudRate, false);
//Flush serial port and apply settings
if(tcsetattr(fd, TCSAFLUSH, &tty) != 0) {
Log::logf(Log::ERR, "Error applying serial port settings: %s\n", strerror(errno));
throw std::runtime_error("serial initialization failed");
}
Log::logf(Log::INFO, "Serial connection initialized!\n");
}
const String CTestResource::Image() const
{
String str;
str.Format(_T("%10s %20s %8s"),(LPCTSTR)HostPort(),(LPCTSTR)Target(),(LPCTSTR)Serial());
if(IsLocked()){
str+=_T(" [RL]");
}
return str;
}
void LowPowerRestore(void) {
// Enable required GPIO clocks - Ports A, B and C
RCC->AHBENR |= (RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN | RCC_AHBENR_GPIOCEN);
Serial(PB_10, PB_11,"pc"); // re-enable USB serial
pc.baud(115200);
pc.printf("..Wake!\r\n");
sensor.pinsOn(); // re-enable sensor pins
Radio.IoReInit(); // re-enable radio pins
Radio.Standby();
Radio.EnableRadioIRQs(); // Re-enable the radio IRQs
}
void
nist_test_suite()
{
if ( (testVector[0] == 1) || (testVector[TEST_FREQUENCY] == 1) )
Frequency(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_BLOCK_FREQUENCY] == 1) )
BlockFrequency(tp.blockFrequencyBlockLength, tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_CUSUM] == 1) )
CumulativeSums(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_RUNS] == 1) )
Runs(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_LONGEST_RUN] == 1) )
LongestRunOfOnes(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_RANK] == 1) )
Rank(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_FFT] == 1) )
DiscreteFourierTransform(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_NONPERIODIC] == 1) )
NonOverlappingTemplateMatchings(tp.nonOverlappingTemplateBlockLength, tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_OVERLAPPING] == 1) )
OverlappingTemplateMatchings(tp.overlappingTemplateBlockLength, tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_UNIVERSAL] == 1) )
Universal(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_APEN] == 1) )
ApproximateEntropy(tp.approximateEntropyBlockLength, tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_RND_EXCURSION] == 1) )
RandomExcursions(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_RND_EXCURSION_VAR] == 1) )
RandomExcursionsVariant(tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_SERIAL] == 1) )
Serial(tp.serialBlockLength,tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_LINEARCOMPLEXITY] == 1) )
LinearComplexity(tp.linearComplexitySequenceLength, tp.n);
if ( (testVector[0] == 1) || (testVector[TEST_FFT80] == 1) )
DiscreteFourierTransform80(tp.n);
}
int SerialData::Serial(CMonitorList &MonitorList,Groups *pGroups,Subsequent *pSubsequent,TASKMAP &TaskMap,bool out)
{
if(m_filename.empty())
return -1;
FILE *pf=NULL;
if(out)
pf=fopen(m_filename.c_str(),"w");
else
pf=fopen(m_filename.c_str(),"r");
if(pf==NULL)
return -2;
int nret=Serial(pf,MonitorList,pGroups,pSubsequent,TaskMap,out);
fclose(pf);
return nret;
}
int SystemProperties::Read(const prop_info* pi, char* name, char* value) {
while (true) {
uint32_t serial = Serial(pi); // acquire semantics
size_t len = SERIAL_VALUE_LEN(serial);
memcpy(value, pi->value, len + 1);
// TODO: Fix the synchronization scheme here.
// There is no fully supported way to implement this kind
// of synchronization in C++11, since the memcpy races with
// updates to pi, and the data being accessed is not atomic.
// The following fence is unintuitive, but would be the
// correct one if memcpy used memory_order_relaxed atomic accesses.
// In practice it seems unlikely that the generated code would
// would be any different, so this should be OK.
atomic_thread_fence(memory_order_acquire);
if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
if (name != nullptr) {
size_t namelen = strlcpy(name, pi->name, PROP_NAME_MAX);
if (namelen >= PROP_NAME_MAX) {
async_safe_format_log(ANDROID_LOG_ERROR, "libc",
"The property name length for \"%s\" is >= %d;"
" please use __system_property_read_callback"
" to read this property. (the name is truncated to \"%s\")",
pi->name, PROP_NAME_MAX - 1, name);
}
}
if (is_read_only(pi->name) && pi->is_long()) {
async_safe_format_log(
ANDROID_LOG_ERROR, "libc",
"The property \"%s\" has a value with length %zu that is too large for"
" __system_property_get()/__system_property_read(); use"
" __system_property_read_callback() instead.",
pi->name, strlen(pi->long_value()));
}
return len;
}
}
}
int uart_init(uart32_t baudrate)
{
Serial(&rx_buffer, &tx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRIE, U2X);
begin(baudrate);
}
/**
* Main is used to:
* Initialize drivers
* Create threads
* Pass drivers structures to threads
*/
int main( void ) {
/*
* Enable internal 32 MHz ring oscillator and wait until it's
* stable. Set the 32 MHz ring oscillator as the main clock source.
*/
CLKSYS_Enable( OSC_RC32MEN_bm );
CLKSYS_Prescalers_Config( CLK_PSADIV_1_gc, CLK_PSBCDIV_1_1_gc );
do {} while ( CLKSYS_IsReady( OSC_RC32MRDY_bm ) == 0 );
CLKSYS_Main_ClockSource_Select( CLK_SCLKSEL_RC32M_gc );
//Enable watchdog timer, which will be reset by timer
WDT_EnableAndSetTimeout( WDT_PER_1KCLK_gc );
/*
* Do all configuration and create all tasks and queues before scheduler is started.
* It is possible to put initialization of peripherals like displays into task functions
* (which will be executed after scheduler has started) if fast startup is needed.
* Interrupts are not enabled until the call of vTaskStartScheduler();
*/
// Enable the Round-Robin Scheduling scheme.Round-Robin scheme ensures that no low-level
// interrupts are “starved”, as the priority changes continuously
PMIC_EnableRoundRobin();
//Create and start the timer, which will reset Watch Dog Timer
xTimerStart(xTimerCreate((signed char*)"WDT",500, pdTRUE, 0, watchdogTimerCallback), 0);
//---------Use USART on PORTC----------------------------
Serial usartFTDI = Serial(&USARTE0, BAUD9600, 128, 10);
// Initialize SPI slave on port D
SpiSlave spiSlave = SpiSlave(&SPIC,false,SPI_MODE_1_gc,64);
// Initialize SPI master on port C
SpiMaster spiMaster = SpiMaster(&SPID, false, SPI_MODE_1_gc, false, SPI_PRESCALER_DIV4_gc);
SpiDevice spiDevice = SpiDevice(&spiMaster, &PORTD, SPI_SS_bm);
//---------Start LED task for testing purposes-----------
ledRGB = LedGroup(3);
ledRGB.add(&PORTF, 0x04,1 );//R
ledRGB.add(&PORTF, 0x08,1 );//G
ledRGB.add(&PORTF, 0x02,1 );//B
ledRGB.set(BLUE);
LedProcessorThread ledRGBEThread = LedProcessorThread(&ledRGB, GREEN, 500, "RGB", 64, configLOW_PRIORITY);
LedGroup ledString = LedGroup(7);
ledString.add(&PORTA, 0x02, 0);
ledString.add(&PORTA, 0x04, 0);
ledString.add(&PORTA, 0x08, 0);
ledString.add(&PORTA, 0x10, 0);
ledString.add(&PORTA, 0x20, 0);
ledString.add(&PORTA, 0x40, 0);
ledString.add(&PORTA, 0x80, 0);
LedProcessorThread ledStringThread = LedProcessorThread(&ledString, "STR", 64, configLOW_PRIORITY);
// ***** Start main Looper
Looper looper = Looper(10, "LPR", 750, configNORMAL_PRIORITY);
//XXX why it is not working if on the heap not on the stack?
//ExampleHandler *exampleHandler = (ExampleHandler*) pvPortMalloc(sizeof(ExampleHandler));
//*exampleHandler = ExampleHandler(looper, spiDevice, ledStringQueue, usartFTDI);
ExampleHandler exampleHandler = ExampleHandler(&looper, &spiDevice, &ledStringThread, &usartFTDI);
// ****** Register commands for the interpreter
CommandInterpreter interpreter = CommandInterpreter();
interpreter.registerCommand(Strings_SpiExampleCmd, Strings_SpiExampleCmdDesc, &exampleHandler, EVENT_RUN_SPI_TEST);
interpreter.registerCommand(Strings_BlinkCmd, Strings_BlinkCmdDesc, &exampleHandler, EVENT_BLINK);
CommandInterpreterThread cmdIntThreadFTDI = CommandInterpreterThread(&interpreter, 32, &usartFTDI, "I12", 128, configNORMAL_PRIORITY);
PinChangeController pinChangeController = PinChangeController();
pinChangeController.registerOnPinChangeListener(&exampleHandler, &PORTD, PIN2_bm, PORT_OPC_TOTEM_gc, PORT_ISC_RISING_gc);
// ****** Start stand-alone tasks
SpiSlaveThread spiSlaveThread = SpiSlaveThread(&spiSlave, &usartFTDI, "SLV", 128, configLOW_PRIORITY);
/* Start scheduler. Creates idle task and returns if failed to create it.
* vTaskStartScheduler never returns during normal operation. It is unlikely that XMEGA port will need to
* dynamically create tasks or queues. To ensure stable work, create ALL tasks and ALL queues before
* vTaskStartScheduler call.
* Interrupts would be enabled by calling PMIC_EnableLowLevel();*/
vTaskStartScheduler();
/* Should never get here, stop execution and report error */
while(true) ledRGB.set(PINK);
return 0;
}
int main(int argc, char *argv[])
{
int DEBUG_LEVEL = 0;
if(argc >= 2)
{
DEBUG_LEVEL = atoi(argv[1]);
}
CLog * Log= new CLog; //inits the log
CERGO_SERIAL Serial(DEBUG_LEVEL) ; // inits the Serial class
CERGO_GPS GPS(DEBUG_LEVEL) ; // inits the GPS CLASS
CERGO_INTERNET * Internet = new CERGO_INTERNET(DEBUG_LEVEL); // inits the INTERNET class
std::deque <uint8_t> test_list;
int counter = 0;
int data_int = 0;
bool internet_light_set = false;
//Adds restarted message to log
Log ->add("\n############################################################ \n\n \t\t ERGO-PIXLE RESTARTED \n\n############################################################ \n ");
Serial.setval_gpio(1,24);
Serial.serial_setup(1337);
std::deque <uint8_t> data_list; // list to store serial data
std::stringstream test_string;
std::thread ([&] { Internet->manage_list(); }).detach();
while(true) // main management loop
{
usleep(200);
counter = Serial.data_read(data_list); // checks for incomming data
while(!data_list.empty())
{
if(DEBUG_LEVEL >= 2)
{
test_list = data_list;
}
data_int =GPS.Read_data(data_list);
if(data_int == 5)
{
if(DEBUG_LEVEL >=2)
{
printf("fix data\n");
}
}
if(data_int == 4)
{
if(DEBUG_LEVEL >=2)
{
printf("POS DATA\n");
}
}
else if( data_int == 3)//sends the serial data to be parsed
{
Serial.setval_gpio(1,18);
GPS.packatize();
Internet->set_check_archive(true);
Serial.setval_gpio(0,18);
if(DEBUG_LEVEL >=3)
{
printf("Good data!");
while(!test_list.empty())
{
printf("0x%X ",test_list.front());
test_list.pop_front();
}
printf("\n\n");
}
}
else if(data_int == 2)
{
if(DEBUG_LEVEL >=3)
{
printf("Not enough data!");
while(!test_list.empty())
{
printf("0x%X ",test_list.front());
test_list.pop_front();
}
printf("\n\n");
}
break;
}
else if (data_int == 0)
{
if(DEBUG_LEVEL >=3)
{
printf("Bad checksum!");
while(!test_list.empty())
{
printf("0x%X ",test_list.front());
test_list.pop_front();
}
printf("\n\n");
}
}
}
if(Internet->get_internet_availiable() )
{
if(!internet_light_set)
{
internet_light_set =true;
Serial.setval_gpio(1,23);
}
}
else
{
if(internet_light_set)
{
internet_light_set= false;
Serial.setval_gpio(0,23);
}
}
}
}
CResetAttributes::ResetResult CTestResource::Reset(LogFunc *pfnLog, void *pfnLogparam)
{
String strReset;
strReset.Format(_T("port(%s,%d) %s"),Serial(),Baud(),ResetString());
return CResetAttributes(strReset).Reset(pfnLog,pfnLogparam);
}
int main(){
Mecanismo P = Mecanismo(2);
cube I1__; I1__.zeros(3,3,2);
I1__.slice(0) << 0 << 0 << 0 << endr
<< 0 << 107.307e-6 + 146.869e-6 << 0 << endr
<< 0 << 0 << 107.307e-6 + 146.869e-6 << endr;
I1__.slice(1) << 0 << 0 << 0 << endr
<< 0 << 438.0e-6 << 0 << endr
<< 0 << 0 << 438.0e-6 << endr;
cube I2__; I2__.zeros(3,3,2);
I2__.slice(0) << 0 << 0 << 0 << endr
<< 0 << 107.307e-6 + 188.738e-6 << 0 << endr
<< 0 << 0 << 107.307e-6 + 188.738e-6 << endr;
I2__.slice(1) << 0 << 0 << 0 << endr
<< 0 << 301.679e-6 << 0 << endr
<< 0 << 0 << 301.679e-6 << endr;
Serial RR1 = Serial(2, {0.12, 0.16}, {0.06, 0.078},{0.062, 0.124}, I1__ , {0, 0, 9.8}, &fDH_RR);
Serial RR2 = Serial(2, {0.12, 0.16}, {0.06, 0.058},{0.062, 0.097}, I2__ , {0, 0, 9.8}, &fDH_RR);
Serial **RR_ = new Serial* [2];
RR_[0] = &RR1;
RR_[1] = &RR2;
//Matrizes que descrevem a arquitetura do mecanismo
double l0 = 0.05;
mat D_ = join_vert((mat)eye(2,2),2);
mat E_ = join_diag( Roty(0)(span(0,1),span(0,2)), Roty(PI)(span(0,1),span(0,2)) );
mat F_ = zeros(4,4);
vec f_ = {l0,0,-l0,0};
Parallel Robot = Parallel(2, &P, RR_, 2, {2,4}, D_, E_, F_, f_);
Reference RefObj = Reference(0.12, {0.08, 0.16}, {-0.08, 0.4});
//Plotar área de trabalho
uint nx = 96.0;
uint ny = 56.0;
double lx = 0.24;
double ly = 0.28;
double xi = -lx;
double xf = lx;
double yi = 0.0;
double yf = ly;
double dx = (xf-xi)/(nx-1);
double dy = (yf-yi)/(ny-1);
double dl = 0.5*(dx+dy);
Mat<int> M; M.zeros(nx,ny);
field<mat> fZ_(nx,ny);
field<mat> fMh_(nx,ny);
field<vec> fgh_(nx,ny);
field<vec> fa1_(nx,ny);
field<vec> fa2_(nx,ny);
field<vec> fa12_(nx,ny);
for(uint i=0; i<nx; i++){
for(uint j=0; j<ny; j++){
fZ_(i,j).zeros(2,2);
fMh_(i,j).zeros(2,2);
fgh_(i,j).zeros(2);
fa1_(i,j).zeros(2);
fa2_(i,j).zeros(2);
fa12_(i,j).zeros(2);
}
}
vec v1_ = {1,0};
vec v2_ = {0,1};
vec v12_ = {1,1};
double r = 0.07;
double x0 = 0.0;
double y0 = 0.17;
uint rows = nx;
uint cols = ny;
vec q0_ = {0.823167, 1.81774, 0.823167, 1.81774};
GNR2 gnr2 = GNR2("RK6", &Robot, 1e-6, 30);
//gnr2.Doit(q0_, {0.05,0.08});
//cout << gnr2.convergiu << endl;
//cout << gnr2.x_ << endl;
//cout << gnr2.res_ << endl;
//cout << gnr2.n << endl;
double x;
double y;
mat A2_;
for(uint i=0; i<rows; i++){
for(uint j=0; j<cols; j++){
x = xi + i*dx;
y = yi + j*dy;
gnr2.Doit(q0_, {x, y});
if(gnr2.convergiu){
q0_ = gnr2.x_;
A2_ = join_horiz(Robot.Ah_, join_horiz(Robot.Ao_.col(1), Robot.Ao_.col(3)) );
if(abs(det(Robot.Ao_)) < 1.6*1e-6 || abs(det(A2_)) < 1e-11 ) M(i,j) = 2;
else{
M(i,j) = 1;
Robot.Doit(Robot.q0_, join_vert(v1_, -solve(Robot.Ao_, Robot.Ah_*v1_)) );
fZ_(i,j) = Robot.Z_;
fMh_(i,j) = Robot.dy->Mh_;
fgh_(i,j) = Robot.dy->gh_;
fa1_(i,j) = Robot.dy->vh_;
Robot.Doit(Robot.q0_, Robot.C_*v2_);
fa2_(i,j) = Robot.dy->vh_;
Robot.Doit(Robot.q0_, Robot.C_*v12_);
fa12_(i,j) = Robot.dy->vh_ - fa1_(i,j) - fa2_(i,j);
}
}
gnr2.convergiu = false;
if( ((x - x0)*(x - x0) + (y - y0)*(y - y0) <= (r+dl)*(r+dl) ) && ((x - x0)*(x - x0) + (y - y0)*(y - y0) >= (r-dl)*(r-dl) ) && (M(i,j) != 2) )
M(i,j) = 3;
}
}
for(uint i=0; i<rows; i++){
for(uint j=0; j<cols; j++){
cout << M(i,j) << ";" ;
if(j==cols-1) cout << endl;
}
}
fZ_.save("fZ_field");
fMh_.save("fMh_field");
fgh_.save("fgh_field");
fa1_.save("fa1_field");
fa2_.save("fa2_field");
fa12_.save("fa12_field");
return 0;
}
int main( int argc, char *argv[] )
{
FILE *output, *input; // File pointers for the data that will be read in and written out.
double programRunTime; // The amount of time a this program took to complete execution.
int processCount; // The total number of processes we have including PI_Main.
int workerCount; // The max number of workers this program run can utilize.
// Setup our program, calculate how many workers we have.
processCount = PI_Configure( &argc, &argv );
workerCount = processCount - 1;
PI_StartTime();
if(argc != 2){ // If after setting up our program, we don't have a string for a file argument, abort this run.
return ExitFailure(", Error: No input file specified.", __FILE__, __LINE__);
}
// Create the workers based off worker count, and the channels/bundles between the workers and PI_Main.
SetupWorkers(workerCount);
//**********//
PI_StartAll();
//**********//
// File opening
output = fopen("pal.out", "a");
input = fopen(argv[1], "r");
// File error checking.
if(output==NULL){
return ExitFailure("Could not open output file 'pal.out' for appending in current directory.", __FILE__, __LINE__);
}
if(input==NULL){
return ExitFailure("Could not open input file for reading, from path in argv[1].", __FILE__, __LINE__);
}
else{
printf(">> Input file is: '%s'\n", argv[1]);
}
// Run serial or parallel algorithm.
if(workerCount == 0){
Serial(input, output);
}
else{
Parallel(input, output, workerCount);
}
// Clean up our program run.
fclose(output);
fclose(input);
free(toWorker);
free(Worker);
free(result);
printf(">> Exiting... <<\n");
programRunTime = PI_EndTime();
printf("\n\n>>< PROGRAM EXECUTION TIME: (%.2f)s ><<\n\n\n", programRunTime);
PI_StopMain(0);
return EXIT_SUCCESS;
}
