/// Create a thread and add it to Active Threads and set it to state READY
osThreadId osThreadCreate(osThreadDef_t *thread_def, void *argument)
{
osThreadId thread;
int size;
size = thread_def->stack_size;
if (size == 0)
{
size = 4096;
}
thread = rt_thread_create(thread_def->name, thread_def->entry, argument, size, thread_def->priority, thread_def->tick);
if (thread != RT_NULL)
rt_thread_startup(thread);
return thread;
}
rt_err_t remote_init(const char * uart_name)
{
uart = rt_device_find(uart_name);
RT_ASSERT(uart != RT_NULL);
rt_device_set_rx_indicate(uart, byte_recv);
rt_device_open(uart, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX);
rt_sem_init(&remote_sem,"remote",0,RT_IPC_FLAG_FIFO);
remote_thread = rt_thread_create("remote",remote_thread_entry,RT_NULL,512,9,3);
rt_thread_startup(remote_thread);
return RT_EOK;
}
void application_init()
{
static rt_bool_t inited = RT_FALSE;
if (inited == RT_FALSE) /* 避免重复初始化而做的保护 */
{
rt_thread_t tid;
tid = rt_thread_create("wb",
application_entry, RT_NULL,
2048 * 2, 25, 10);
if (tid != RT_NULL)
rt_thread_startup(tid);
inited = RT_TRUE;
}
}
int ft5406_hw_init(void)
{
rt_thread_t tid;
rt_device_t dev;
dev = rt_device_find(I2CBUS_NAME);
if (!dev) return -1;
if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
return -1;
FTDEBUG("ft5406 set i2c bus to %s\n", I2CBUS_NAME);
_i2c_bus = (struct rt_i2c_bus_device *)dev;
{
gpio_pin_config_t pin_config =
{
kGPIO_DigitalOutput, 0,
};
CLOCK_EnableClock(kCLOCK_Gpio2);
/* Enable touch panel controller */
GPIO_PinInit(GPIO, 2, 27, &pin_config);
GPIO_WritePinOutput(GPIO, 2, 27, 1);
rt_thread_delay(50);
GPIO_WritePinOutput(GPIO, 2, 27, 0);
rt_thread_delay(50);
GPIO_WritePinOutput(GPIO, 2, 27, 1);
}
rt_sem_init(&_tp_sem, "touch", 0, RT_IPC_FLAG_FIFO);
tid = rt_thread_create("touch", _touch, RT_NULL,
2048, 10, 20);
if (!tid)
{
rt_device_close(dev);
return -1;
}
rt_thread_startup(tid);
return 0;
}
int rt_application_init()
{
rt_thread_t init_thread;
Device_CAN2_regist(); // Device CAN2 Init
#if (RT_THREAD_PRIORITY_MAX == 32)
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
256, 8, 20); // thread null
#endif
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
return 0;
}
void rt_application_init(void)
{
rt_thread_t tid;
#ifdef RT_USING_HEAP
tid = rt_thread_create("main", main_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(tid != RT_NULL);
#else
rt_err_t result;
tid = &main_thread;
result = rt_thread_init(tid, "main", main_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(result != RT_EOK);
#endif
rt_thread_startup(tid);
}
sys_thread_t sys_thread_new(const char *name,
lwip_thread_fn thread,
void *arg,
int stacksize,
int prio)
{
rt_thread_t t;
RT_DEBUG_NOT_IN_INTERRUPT;
/* create thread */
t = rt_thread_create(name, thread, arg, stacksize, prio, 20);
RT_ASSERT(t != RT_NULL);
/* startup thread */
rt_thread_startup(t);
return t;
}
int rt_application_init(void)
{
rt_thread_t init_thread = NULL;
rt_thread_init(&thread_sys_monitor,
"sys_monitor",
thread_entry_sys_monitor,
RT_NULL,
thread_sys_monitor_stack,
sizeof(thread_sys_monitor_stack),
thread_sys_monitor_prio, 5);
rt_thread_startup(&thread_sys_monitor);
init_thread = rt_thread_create("sys init", sys_init_thread,
NULL, 512, 10, 10);
if (init_thread != NULL) {
rt_thread_startup(init_thread);
}
return 0;
}
rt_err_t appNRF24L01Init(void)
{
rt_err_t status;
rt_thread_t init_thread;
status = RF24L01_Check();
if(status == RT_EOK) {
init_thread = rt_thread_create("appNRF24L01",
rt_appNRF24L01_thread_entry, RT_NULL,
2048, 8, 20);
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
else
status = RT_ERROR;
}else
status = RT_ERROR;
return status;
}
void USB_cable(void)
{
rt_device_t dev = RT_NULL;
SD_CardInfo * sdio_info = RT_NULL;
dev = rt_device_find("sd0");
if(dev != RT_NULL)
{
dev_sdio = dev;
sdio_info = (SD_CardInfo *)dev->user_data;
Mass_Memory_Size[0] = sdio_info->CardCapacity;
Mass_Block_Size[0] = 512;//sdio_info->CardBlockSize;
Mass_Block_Count[0] = Mass_Memory_Size[0] / Mass_Block_Size[0];
}
else
{
rt_kprintf("\r\nNo find the device sd0 !!!!");
}
/* 3:NAND */
/* usb msc up*/
Set_System();
Set_USBClock();
USB_Interrupts_Config();
USB_Init();
#if (USB_USE_AUTO_REMOVE == 1)
/* delete the other thread */
/* create msc_thread */
{
rt_thread_t msc_thread;
msc_thread = rt_thread_create("msc_thread",
msc_thread_entry, RT_NULL,
1024, RT_THREAD_PRIORITY_MAX-1,1);
if (msc_thread != RT_NULL) rt_thread_startup(msc_thread);
}
#endif
}
int main(void)
{
int i, k, prio, bprio;
task[0] = rt_task_init_schmod(0, NTASKS - 1, 0, 0, SCHED_FIFO, CPUS_ALLOWED);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
for (i = 0; i < NTASKS; i++) {
sem[i] = rt_typed_sem_init(0, RESEMT, RES_SEM);
}
rt_sem_wait(sem[0]);
for (i = 1; i < NTASKS; i++) {
rt_thread_create(tskfun, (void *)i, 0);
rt_receive(NULL, &k);
rt_printk("AFTER TSKNR %d CREATED > (TSKNR-PRI):\n", i);
for (k = 0; k < i; k++) {
rt_get_priorities(task[k], &prio, &bprio);
rt_printk("%d-%d|", k, prio);
}
rt_get_priorities(task[i], &prio, &bprio);
rt_printk("%d-%d\n\n", i, prio);
}
rt_sem_signal(sem[0]);
rt_printk("FINAL > (TSKNR-PRI):\n");
for (k = 0; k < (NTASKS - 1); k++) {
rt_get_priorities(task[k], &prio, &bprio);
rt_printk("%d-%d|", k, prio);
}
rt_get_priorities(task[NTASKS - 1], &prio, &bprio);
rt_printk("%d-%d\n\n", (NTASKS - 1), prio);
for (i = 0; i < NTASKS; i++) {
rt_sem_delete(sem[i]);
}
return 0;
}
// rtt应用程序初始化
void rt_application_init(void)
{
rt_thread_t tid;
#ifdef RT_USING_HEAP // 此处已开启
// 此处进入main函数中 创建了一个主任务入口
tid = rt_thread_create("main", main_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(tid != RT_NULL);
#else
rt_err_t result;
tid = &main_thread;
result = rt_thread_init(tid, "main", main_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(result != RT_EOK);
#endif
rt_thread_startup(tid); // 启动当前创建的任务，在调度器启动后才会真正的调用
}
void rt_hw_adc_init(void)
{
adc.type = RT_Device_Class_Char;
adc.rx_indicate = RT_NULL;
adc.tx_complete = RT_NULL;
adc.init = rt_adc_init;
adc.open = RT_NULL;
adc.close = RT_NULL;
adc.read = RT_NULL;
adc.write = RT_NULL;
adc.control = rt_adc_control;
adc.user_data = RT_NULL;
adc_thread = rt_thread_create("adc", adc_thread_entry, RT_NULL, 384, 26, 5);
if(adc_thread != RT_NULL)
rt_thread_startup(adc_thread);
/* register a character device */
rt_device_register(&adc, "adc", RT_DEVICE_FLAG_RDWR);
}
int rs485_system_init(void)
{
rt_err_t result;
rt_thread_t init_thread;
rs485_send_mut = rt_mutex_create("rs485mut",RT_IPC_FLAG_FIFO);
rs485_data_init();
uart1_dev_my = (struct _uart_dev_my*)rt_malloc(sizeof(struct _uart_dev_my));
if (uart1_dev_my == RT_NULL)
{
rt_kprintf("no memory for shell\n");
return -1;
}
memset(uart1_dev_my, 0, sizeof(struct _uart_dev_my));
rt_sem_init(&(uart1_dev_my->rx_sem), "rs485rx", 0, 0);
uart1_dev_my->device = RT_NULL;
uart1_rs485_set_device();
uart1_sem = rt_sem_create("uart1_sem",0, RT_IPC_FLAG_FIFO);
init_thread = rt_thread_create("rs485",rt_rs485_thread_entry, RT_NULL,
4092, 8, 21);
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
// init_thread = rt_thread_create("rsdecode",rt_rs485_decode_thread_entry, RT_NULL,
// 512, 8, 21);
// if (init_thread != RT_NULL)
// rt_thread_startup(init_thread);
return 0;
}
void calibration_init(void)
{
rt_thread_t tid;
rt_device_t device = rt_device_find("touch");
if (device == RT_NULL)
{
rt_kprintf("RTGUI: no touch device to calibrate\n");
return;
}
if (_cali_restore && (_cali_restore()==RT_TRUE))
{
return;
}
tid = rt_thread_create("cali", calibration_entry, RT_NULL, 1024, 20, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
}
int rt_application_init(void)
{
rt_thread_t tid;
rt_err_t result;
tid = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, 3, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
/* init led thread */
result = rt_thread_init(&led_thread, "led",
led_thread_entry, RT_NULL,
(rt_uint8_t *)&led_stack[0], sizeof(led_stack),
20, 5);
if (result == RT_EOK)
{
rt_thread_startup(&led_thread);
}
return 0;
}
void Commander::Init(const char *name)
{
rt_thread_t recv_thread;
dev = rt_device_find(name);
if(dev == RT_NULL)
{
rt_kprintf("can not find %s!\n", name);
return ;
}
recv_event = rt_event_create("cmdrecv",RT_IPC_FLAG_FIFO);
if(recv_event==RT_NULL)
{
rt_kprintf("commander recv event create error!\n");
return ;
}
rt_device_set_rx_indicate(dev,data_rx_callback);
rt_device_open(dev,RT_DEVICE_FLAG_INT_RX|RT_DEVICE_FLAG_RDWR);
recv_thread = rt_thread_create("cmd_recv",recv_thread_entry,RT_NULL,1024,12,5);
if(recv_thread != RT_NULL)
rt_thread_startup(recv_thread);
}
int rt_application_init()
{
rt_thread_t init_thread;
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX/3, 20);
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
//------- init led1 thread
rt_thread_init(&thread_led1,
"led_demo",
rt_thread_entry_led1,
RT_NULL,
&thread_led1_stack[0],
sizeof(thread_led1_stack),11,5);
rt_thread_startup(&thread_led1);
return 0;
}
int termios_test(int argc, char **argv)
{
rt_thread_t tid;
if(argc < 2)
{
rt_kprintf("Please input device name...\n");
return -1;
}
term_param.dev = argv[1];
term_param.baud_rate = ((argc >= 3) ? atoi(argv[2]) : Default_baud_rate);
tid = rt_thread_create("termtest",
termios_test_entry, (void *)&term_param,
512, RT_THREAD_PRIORITY_MAX/3, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
return 0;
}
int rt_application_init()
{
rt_thread_t tid;
tid = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX/3, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
#if 0
//------- init led2 thread
rt_thread_init(&thread_led2,
"led2",
rt_thread_entry_led2,
RT_NULL,
&thread_led2_stack[0],
sizeof(thread_led2_stack),11,5);
rt_thread_startup(&thread_led2);
#endif
return 0;
}
int LCDPANELProcessInit(void)
{
rt_thread_t init_thread;
IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); // Enable write access to IWDG_PR and IWDG_RLR registers
IWDG_SetPrescaler(IWDG_Prescaler_32); // IWDG counter clock: 40KHz(LSI) / 32 = 1.25 KHz
IWDG_SetReload(1250); // Set counter reload value to 1250
IWDG_ReloadCounter(); // Reload IWDG counter
IWDG_Enable(); // Enable IWDG (the LSI oscillator will be enabled by hardware)
init_thread = rt_thread_create( "lcdpanel",
LCDPANELProcess_thread_entry,
RT_NULL,
4096,20,10);
if( init_thread != RT_NULL )
{
rt_thread_startup(init_thread);
}
return 0;
}
int manager_tasks(void)
{
int contIdTask = 0;
rt_set_periodic_mode();
rt_make_hard_real_time();
printf("************** Iniciando escalonamento **************\n");
//rt_set_oneshot_mode();
start_rt_timer(0);
tick_period = nano2count(TICK_PERIOD); // 0.05 segundos...
delay_start_timeline = tick_period * 20; // Delay: 2 segundo(s)
start_timeline = rt_get_time() + delay_start_timeline;
printf("TICK_PERIOD ================> %llu\n", tick_period);
/**
* TASK(S)
*/
contIdTask = 0;//TASK:0
arrayThreadParams[contIdTask].idTask = contIdTask;
arrayThreadParams[contIdTask].periodo = tick_period * 320; // ~= 16 segundos
// arrayThreadParams[contIdTask].deadline = 0.0013;
arrayThreadParams[contIdTask].deadline = arrayThreadParams[contIdTask].periodo;
arrayThreadParams[contIdTask].prioridade = 4;
// arrayThreadParams[contIdTask].cpuFrequencyMin = VALOR_DEFAULT_FREQ_MIN_DESABILITADA; // KHz
arrayThreadParams[contIdTask].cpuFrequencyMin = 3000000; // KHz
arrayThreadParams[contIdTask].cpuFrequencyInicial = 3000000; // KHz
arrayThreadParams[contIdTask].cpuVoltageInicial = AMD_ATHLON_II_X2_250_TENSAO_FREQ_1800000_KHZ; // Volts
Thread_Task = rt_thread_create(init_task, &arrayThreadParams[contIdTask], 0);
// Aguarda interrupcao do usuario... ou a conclusao dos periodos de todas as tarefas criadas...
while(!getchar());
stop_rt_timer();
return 0;
}
int main(void)
{
RT_TASK *mytask;
RT_MSGQ *smbx;
int bthread;
char msg[] = "let's end the game";
mytask = rt_thread_init(nam2num("MAIN"), 2, 0, SCHED_FIFO, 0xF);
smbx = rt_msgq_init(nam2num("SMSG"), 0, 0);
bthread = rt_thread_create(bfun, 0, 0x8000);
printf("IF NOTHING HAPPENS IS OK, TYPE ENTER TO FINISH.\n");
getchar();
end = 1;
rt_msg_send(smbx, msg, sizeof(msg), 1);
rt_thread_join(bthread);
rt_task_delete(mytask);
printf("MAIN TASK ENDS.\n");
return 0;
}
void calibration_init()
{
rt_device_t device;
device = rt_device_find("touch");
if (device == RT_NULL)
return; /* no such device */
touch_screen_calibrated = rt_sem_create("tc_cali", 0, RT_IPC_FLAG_FIFO);
if (touch_screen_calibrated == RT_NULL)
return;
calibration_ptr = (struct calibration_session*)rt_malloc(sizeof(struct calibration_session));
rt_memset(calibration_ptr, 0, sizeof(struct calibration_data));
calibration_ptr->device = device;
rt_device_control(calibration_ptr->device, RT_TOUCH_CALIBRATION, (void*)calibration_data_post);
calibration_ptr->tid = rt_thread_create("cali", calibration_entry, RT_NULL,
2048, 20, 5);
if (calibration_ptr->tid != RT_NULL)
rt_thread_startup(calibration_ptr->tid);
}
int wavplay(int argc, char **argv)
{
rt_thread_t tid = RT_NULL;
if (argc != 2)
{
printf("Usage:\n");
printf("wavplay song.wav\n");
return 0;
}
memset(file_name, 0, sizeof(file_name));
memcpy(file_name, argv[1], strlen(argv[1]));
tid = rt_thread_create("wayplay",
wavplay_thread_entry,
RT_NULL,
1024 * 8,
22,
10);
if (tid != RT_NULL)
rt_thread_startup(tid);
}
sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
{
rt_thread_t t;
struct lwip_thread* lwip_th;
/* create lwip thread */
lwip_th = (struct lwip_thread*) rt_malloc (sizeof(struct lwip_thread));
RT_ASSERT(lwip_th != RT_NULL);
/* create thread */
t = rt_thread_create(name, thread, arg, stacksize, prio, 20);
RT_ASSERT(t != RT_NULL);
t->user_data = (rt_uint32_t)lwip_th;
/* init lwip_thread */
lwip_th->magic = LWIP_THREAD_MAGIC;
lwip_th->timeouts.next = RT_NULL;
lwip_th->tid = t;
/* startup thread */
rt_thread_startup(t);
return t;
}
int rt_application_init(void)
{
rt_thread_t tid;
rt_err_t result;
tid = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX / 3, 20);
if (tid != RT_NULL) rt_thread_startup(tid);
/* init led thread */
// result = rt_thread_init(&led_thread,
// "led",
// led_thread_entry,
// RT_NULL,
// (rt_uint8_t*)&led_stack[0],
// sizeof(led_stack),
// 20,
// 5);
// if (result == RT_EOK)
// {
// rt_thread_startup(&led_thread);
// }
return 0;
}
/**
* This function will create a rms object and allocate rms object memory and stack
*/
rt_rms_t rt_rms_create(const char *name,
void (*entry)(void *parameter),
void *parameter,
rt_uint32_t stack_size,
rt_uint32_t tick,
rt_uint8_t period,
rt_uint8_t wcet)
{
struct rt_rms *rms;
rms = (struct rt_rms *)rt_object_allocate(RT_Object_Class_Thread, name);
if(rms->thread == RT_NULL)
return RT_NULL;
/* create a thread object */
#ifndef RT_RMS_ACCURACY
#define RT_RMS_ACCURACY 1
#endif
rms->thread = rt_thread_create(name, entry, parameter, stack_size, period / RT_RMS_ACCURACY, tick);
_rt_rms_init(rms, period, wcet);
return rms;
}
int calc_grid_energies_excl_mgrid(float* atoms, float* grideners, long int numplane, long int numcol, long int numpt, long int natoms, float gridspacing, unsigned char* excludepos, int maxnumprocs) {
// cionize_params* params, cionize_molecule* molecule, cionize_grid* grid) {
int i;
enthrparms *parms;
rt_thread_t * threads;
#if defined(THR)
int numprocs;
int availprocs = rt_thread_numprocessors();
if (params->maxnumprocs <= availprocs) {
numprocs = params->maxnumprocs;
} else {
numprocs = availprocs;
}
#else
int numprocs = 1;
#endif
printf("calc_grid_energies_excl_mgrid()\n");
/* DH: setup and compute long-range */
MgridParam mg_prm;
MgridSystem mg_sys;
Mgrid mg;
//MgridLattice *lattice;
int j, k;
int gridfactor;
double h, h_1;
int nspacings;
double *eh;
int ndim;
int ii, jj, kk;
int im, jm, km;
int ilo, jlo, klo;
double dx_h, dy_h, dz_h;
double xphi[4], yphi[4], zphi[4];
double t, en, c;
int koff, jkoff, index;
rt_timerhandle timer;
float totaltime;
memset(&mg_prm, 0, sizeof(mg_prm));
memset(&mg_sys, 0, sizeof(mg_sys));
/*
* set mgrid parameters
*
* make sure origin of mgrid's grid is at ionize's grid origin (0,0,0)
*
* length is (number of grid spacings) * (grid spacing),
* where the number of spacings is one less than number of grid points
*/
mg_prm.length = (numpt-1) * gridspacing;
mg_prm.center.x = 0.5 * mg_prm.length;
mg_prm.center.y = 0.5 * mg_prm.length;
mg_prm.center.z = 0.5 * mg_prm.length;
/* make sure domain and grid are both cubic */
if (numpt != numcol || numcol != numplane) {
printf("ERROR: grid must be cubic\n");
return -1;
}
/*
* grid used by mgrid needs spacing h >= 2
*
* determine grid factor: (2^gridfactor)*h_ionize = h_mgrid
*/
gridfactor = 0;
//nspacings = numpt - 1;
nspacings = numpt;
/* add one more spacing so that interpolation loop below will work */
h = gridspacing;
while (h < 2.0) {
h *= 2;
nspacings = ((nspacings & 1) ? nspacings/2 + 1 : nspacings/2);
gridfactor++;
}
mg_prm.nspacings = nspacings;
/* have to modify mgrid length */
mg_prm.length += h;
mg_prm.center.x = 0.5 * mg_prm.length;
mg_prm.center.y = 0.5 * mg_prm.length;
mg_prm.center.z = 0.5 * mg_prm.length;
h_1 = 1.0/h;
mg_prm.cutoff = CUTOFF;
mg_prm.boundary = MGRID_NONPERIODIC;
/* choice of splitting must be consistent with short-range below */
#if defined(CUBIC_TAYLOR2)
mg_prm.approx = MGRID_CUBIC;
mg_prm.split = MGRID_TAYLOR2;
#elif defined(QUINTIC1_TAYLOR3)
mg_prm.approx = MGRID_QUINTIC1;
mg_prm.split = MGRID_TAYLOR3;
#elif defined(HEPTIC1_TAYLOR4)
mg_prm.approx = MGRID_HEPTIC1;
mg_prm.split = MGRID_TAYLOR4;
/*
#elif defined(HERMITE_TAYLOR3)
mg_prm.approx = MGRID_HERMITE;
mg_prm.split = MGRID_TAYLOR3;
*/
#endif
mg_prm.natoms = natoms;
printf("natom = %d\n", mg_prm.natoms);
printf("mgrid center = %g %g %g\n",
mg_prm.center.x, mg_prm.center.y, mg_prm.center.z);
printf("mgrid length = %g\n", mg_prm.length);
printf("mgrid nspacings = %d\n", mg_prm.nspacings);
/* setup mgrid system */
mg_sys.f_elec = (MD_Dvec *) calloc(mg_prm.natoms, sizeof(MD_Dvec));
mg_sys.pos = (MD_Dvec *) calloc(mg_prm.natoms, sizeof(MD_Dvec));
mg_sys.charge = (double *) calloc(mg_prm.natoms, sizeof(double));
for (i = 0; i < mg_prm.natoms; i++) {
mg_sys.pos[i].x = atoms[4*i ];
mg_sys.pos[i].y = atoms[4*i + 1];
mg_sys.pos[i].z = atoms[4*i + 2];
mg_sys.charge[i] = atoms[4*i + 3];
}
/* setup mgrid solver and compute */
if (mgrid_param_config(&mg_prm)) {
printf("ERROR: mgrid_param_config() failed\n");
return -1;
}
printf("spacing = %g\n", mg_prm.spacing);
if (mgrid_init(&mg)) {
printf("ERROR: mgrid_init() failed\n");
return -1;
}
if (mgrid_setup(&mg, &mg_sys, &mg_prm)) {
printf("ERROR: mgrid_setup() failed\n");
return -1;
}
timer = rt_timer_create();
rt_timer_start(timer);
if (mgrid_force(&mg, &mg_sys)) {
printf("ERROR: mgrid_force() failed\n");
return -1;
}
/* DH: end setup and compute long-range */
printf(" using %d processors\n", numprocs);
/* allocate array of threads */
threads = (rt_thread_t *) calloc(numprocs * sizeof(rt_thread_t), 1);
/* allocate and initialize array of thread parameters */
parms = (enthrparms *) malloc(numprocs * sizeof(enthrparms));
for (i=0; i<numprocs; i++) {
parms[i].threadid = i;
parms[i].threadcount = numprocs;
parms[i].atoms = atoms;
parms[i].grideners = grideners;
parms[i].numplane = numplane;
parms[i].numcol = numcol;
parms[i].numpt = numpt;
parms[i].natoms = natoms;
parms[i].gridspacing = gridspacing;
parms[i].excludepos = excludepos;
}
#if defined(THR)
/* spawn child threads to do the work */
for (i=0; i<numprocs; i++) {
rt_thread_create(&threads[i], energythread, &parms[i]);
}
/* join the threads after work is done */
for (i=0; i<numprocs; i++) {
rt_thread_join(threads[i], NULL);
}
#else
/* single thread does all of the work */
energythread((void *) &parms[0]);
#endif
/* DH: tabulate and cleanup long-range */
/* interpolate from mgrid potential lattice */
eh = (double *)(mg.egrid[0].data); /* mgrid's long-range potential lattice */
ndim = mg.egrid[0].ni; /* number of points in each dimension of lattice */
for (kk = 0; kk < numplane; kk++) {
for (jj = 0; jj < numcol; jj++) {
for (ii = 0; ii < numpt; ii++) {
/* distance between atom and corner measured in grid points */
dx_h = (ii*gridspacing) * h_1;
dy_h = (jj*gridspacing) * h_1;
dz_h = (kk*gridspacing) * h_1;
/* find closest mgrid lattice point less than or equal to */
im = ii >> gridfactor;
jm = jj >> gridfactor;
km = kk >> gridfactor;
#if defined(CUBIC_TAYLOR2)
ilo = im-1;
jlo = jm-1;
klo = km-1;
/* find t for x dimension and compute xphi */
t = dx_h - ilo;
xphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
t--;
xphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
t--;
xphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
t--;
xphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);
/* find t for y dimension and compute yphi */
t = dy_h - jlo;
yphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
t--;
yphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
t--;
yphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
t--;
yphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);
/* find t for z dimension and compute zphi */
t = dz_h - klo;
zphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
t--;
zphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
t--;
zphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
t--;
zphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);
/* determine 64=4*4*4 eh grid stencil contribution to potential */
en = 0;
for (k = 0; k < 4; k++) {
koff = (k + klo) * ndim;
for (j = 0; j < 4; j++) {
jkoff = (koff + (j + jlo)) * ndim;
c = yphi[j] * zphi[k];
for (i = 0; i < 4; i++) {
index = jkoff + (i + ilo);
/*
ASSERT(&eh[index]
== mgrid_lattice_elem(&(mg.egrid[0]), i+ilo, j+jlo, k+klo));
*/
if (&eh[index] !=
mgrid_lattice_elem(&(mg.egrid[0]), i+ilo, j+jlo, k+klo)) {
printf("ndim=%d index=%d i+ilo=%d j+jlo=%d k+klo=%d\n"
"ia=%d ib=%d ni=%d\n"
"ja=%d jb=%d nj=%d\n"
"ka=%d kb=%d nk=%d\n",
ndim, index, i+ilo, j+jlo, k+klo,
mg.egrid[0].ia, mg.egrid[0].ib, mg.egrid[0].ni,
mg.egrid[0].ja, mg.egrid[0].jb, mg.egrid[0].nj,
mg.egrid[0].ka, mg.egrid[0].kb, mg.egrid[0].nk
);
abort();
}
en += eh[index] * xphi[i] * c;
}
}
}
/* end CUBIC */
#endif
//ENERGY(grid->eners[k*numcol*numpt + j*numpt + i]);
grideners[kk*numcol*numpt + jj*numpt + ii] += (float)en;
// (float) *((double *)mgrid_lattice_elem(lattice, i, j, k));
//ENERGY((float) *((double *)mgrid_lattice_elem(lattice, i, j, k)));
//ENERGY(grid->eners[k*numcol*numpt + j*numpt + i]*560.47254);
}
}
}
totaltime = rt_timer_timenow(timer);
printf("total time for mgrid: %.1f\n", totaltime);
rt_timer_destroy(timer);
/* cleanup mgrid */
mgrid_done(&mg);
free(mg_sys.f_elec);
free(mg_sys.pos);
free(mg_sys.charge);
/* DH: tabulate and cleanup long-range */
/* free thread parms */
free(parms);
free(threads);
return 0;
}
int main(int argc, char *argv[])
{
unsigned long sndnode;
long sndport, i, r;
RT_TASK *rcvtsk, *sndtsk;
struct sockaddr_in addr;
static MBX *sndmbx;
SERVER = atoi(argv[1]);
if (!(rcvtsk = rt_task_init_schmod(nam2num("RCVTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT RECEIVER TASK\n");
exit(1);
}
mbx = rt_mbx_init(nam2num("MBX"), 100);
athread = rt_thread_create(async_fun, NULL, 10000);
sndnode = 0;
if (argc == 3 && strstr(argv[2], "SndNode=")) {
inet_aton(argv[2] + 8, &addr.sin_addr);
sndnode = addr.sin_addr.s_addr;
}
if (!sndnode) {
inet_aton("127.0.0.1", &addr.sin_addr);
sndnode = addr.sin_addr.s_addr;
}
rt_set_oneshot_mode();
start_rt_timer(0);
while ((sndport = rt_request_port_mbx(sndnode, mbx)) <= 0 && sndport != -EINVAL);
while (!(sndmbx = RT_get_adr(sndnode, sndport, "SNDMBX"))) {
rt_sleep(nano2count(100000000));
}
sndtsk = RT_get_adr(sndnode, sndport, "SNDTSK");
printf("\nRECEIVER TASK RUNNING\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
while (!end) {
r = RT_mbx_receive(sndnode, -sndport, sndmbx, &i, sizeof(long));
rt_printk("RECEIVE %ld %ld\n", r, i);
if (SERVER) {
rt_sleep(nano2count(100000000));
} else {
while (!end && rt_waiting_return(sndnode, sndport)) {
rt_sleep(nano2count(1000000));
}
if (!end) {
unsigned long long retval;
long i1, i2;
int l1, l2;
if (rt_sync_net_rpc(sndnode, -sndport)) {
l1 = l2 = sizeof(long);
rt_get_net_rpc_ret(mbx, &retval, &i1, &l1, &i2, &l2, 0LL, MBX_RECEIVE);
rt_printk("RECEIVER ASYNC MSG: RETVAL = %d, MSG = %ld, LEN = %d.\n", (int)retval, i1, l1);
if (i1 < 0) {
end = 1;
break;
}
}
}
}
}
rt_mbx_delete(mbx);
rt_release_port(sndnode, sndport);
rt_make_soft_real_time();
rt_thread_join(athread);
rt_return(rt_receive(0, &i), i);
rt_task_delete(rcvtsk);
stop_rt_timer();
printf("\nRECEIVER TASK STOPS\n");
return 0;
}