linux cnc 源码,linuxcnc源码分析

LinuxCNC 命令更新

while (!done) {

// read command

if (0 != emcCommandBuffer->peek()) {

// got a new command, so clear out errors

taskPlanError = 0;

taskExecuteError = 0;

}

emcCommandBuffer->peek()->|

Description: nml.cc

NMLTYPE NML::peek()

{

error_type = NML_NO_ERROR;

if (fast_mode) {

cms->peek();

switch (cms->status) {

case CMS_READ_OLD:

return (0);

case CMS_READ_OK:

if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) {

rcs_print_error

("NML: New data recieved but type of %d is invalid.\n",

(int)((NMLmsg *) cms->subdiv_data)->type);

return -1;

}

return (((NMLmsg *) cms->subdiv_data)->type);

default:

set_error();

return -1;

}

}

if (NULL == cms) {

if (error_type != NML_INVALID_CONFIGURATION) {

error_type = NML_INVALID_CONFIGURATION;

rcs_print_error("NML::peek: CMS not configured.\n");

}

return (-1);

}

if (cms->is_phantom) {

if (NULL != phantom_peek) {

return ((*phantom_peek) ());

} else {

return (0);

}

}

if (!cms->force_raw) {

cms->set_mode(CMS_READ);

}

cms->peek();

if (!cms->force_raw) {

if (cms->status == CMS_READ_OK) {

if (-1 == format_output()) {

error_type = NML_FORMAT_ERROR;

return (-1);

}

}

}

switch (cms->status) {

case CMS_READ_OLD:

return (0);

case CMS_READ_OK:

if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) {

rcs_print_error

("NML: New data recieved but type of %d is invalid.\n",

(int)((NMLmsg *) cms->subdiv_data)->type);

return -1;

}

return (((NMLmsg *) cms->subdiv_data)->type);

default:

set_error();

return -1;

}

}

cms->peek()

* Description: cms.cc

CMS_STATUS CMS::peek()

{

internal_access_type = CMS_PEEK_ACCESS;

status = CMS_STATUS_NOT_SET;

blocking_timeout = 0;

main_access(data);

return (status);

}

* Description: shmem.cc

main_access(data) :

/* Access the shared memory buffer. */

CMS_STATUS SHMEM::main_access(void *_local)

{

/* Check pointers. */

if (shm == NULL) {

second_read = 0;

return (status = CMS_MISC_ERROR);

}

if (bsem == NULL && not_zero(blocking_timeout)) {

rcs_print_error

("No blocking semaphore available. Can not call blocking_read(%f).\n",

blocking_timeout);

second_read = 0;

return (status = CMS_NO_BLOCKING_SEM_ERROR);

}

mao.read_only = ((internal_access_type == CMS_CHECK_IF_READ_ACCESS) ||

(internal_access_type == CMS_PEEK_ACCESS) ||

(internal_access_type == CMS_READ_ACCESS));

switch (mutex_type) {

case NO_MUTEX:

break;

case MAO_MUTEX:

case MAO_MUTEX_W_OS_SEM:

switch (mem_get_access(&mao)) {

case -1:

rcs_print_error("SHMEM: Can't take semaphore\n");

second_read = 0;

return (status = CMS_MISC_ERROR);

case -2:

if (timeout > 0) {

rcs_print_error("SHMEM: Timed out waiting for semaphore.\n");

rcs_print_error("buffer = %s, timeout = %lf sec.\n",

BufferName, timeout);

}

second_read = 0;

return (status = CMS_TIMED_OUT);

default:

break;

}

toggle_bit = mao.toggle_bit;

break;

case OS_SEM_MUTEX:

if (sem == NULL) {

second_read = 0;

return (status = CMS_MISC_ERROR);

}

switch (sem->wait()) {

case -1:

rcs_print_error("SHMEM: Can't take semaphore\n");

second_read = 0;

return (status = CMS_MISC_ERROR);

case -2:

if (timeout > 0) {

rcs_print_error("SHMEM: Timed out waiting for semaphore.\n");

rcs_print_error("buffer = %s, timeout = %lf sec.\n",

BufferName, timeout);

}

second_read = 0;

return (status = CMS_TIMED_OUT);

default:

break;

}

break;

case NO_INTERRUPTS_MUTEX:

rcs_print_error("Interrupts can not be disabled.\n");

second_read = 0;

return (status = CMS_MISC_ERROR);

break;

case NO_SWITCHING_MUTEX:

rcs_print_error("Interrupts can not be disabled.\n");

return (status = CMS_MISC_ERROR);

break;

default:

rcs_print_error("SHMEM: Invalid mutex type.(%d)\n", mutex_type);

second_read = 0;

return (status = CMS_MISC_ERROR);

break;

}

if (second_read > 0 && enable_diagnostics) {

disable_diag_store = 1;

}

/* Perform access function. */

internal_access(shm->addr, size, _local);

disable_diag_store = 0;

if (NULL != bsem &&

(internal_access_type == CMS_WRITE_ACCESS

|| internal_access_type == CMS_WRITE_IF_READ_ACCESS)) {

bsem->flush();

}

switch (mutex_type) {

case NO_MUTEX:

break;

case MAO_MUTEX:

case MAO_MUTEX_W_OS_SEM:

mem_release_access(&mao);

break;

case OS_SEM_MUTEX:

sem->post();

break;

case NO_INTERRUPTS_MUTEX:

rcs_print_error("Can not restore interrupts.\n");

break;

case NO_SWITCHING_MUTEX:

rcs_print_error("Can not restore interrupts.\n");

break;

}

switch (internal_access_type) {

case CMS_READ_ACCESS:

if (NULL != bsem && status == CMS_READ_OLD &&

(blocking_timeout > 1e-6 || blocking_timeout < -1E-6)) {

if (second_read > 10 && total_subdivisions <= 1) {

status = CMS_MISC_ERROR;

rcs_print_error

("CMS: Blocking semaphore error. The semaphore wait has returned %d times but there is still no new data.\n",

second_read);

second_read = 0;

return (status);

}

second_read++;

bsem->timeout = blocking_timeout;

int bsem_ret = bsem->wait();

if (bsem_ret == -2) {

status = CMS_TIMED_OUT;

second_read = 0;

return (status);

}

if (bsem_ret == -1) {

rcs_print_error("CMS: Blocking semaphore error.\n");

status = CMS_MISC_ERROR;

second_read = 0;

return (status);

}

main_access(_local);

}

break;

case CMS_WRITE_ACCESS:

case CMS_WRITE_IF_READ_ACCESS:

break;

default:

break;

}

second_read = 0;     return (status); }