void
dumpmem(uint8_t *addr, uint16_t len)
{
for(uint16_t i = 0; i < len; i += 16) {
uint8_t l = len;
if(l > 16)
l = 16;
DH(i,4);
DC(':'); DC(' ');
for(uint8_t j = 0; j < l; j++) {
DH2(addr[j]);
if(j&1)
DC(' ');
}
DC(' ');
for(uint8_t j = 0; j < l; j++) {
if(addr[j] >= ' ' && addr[j] <= '~')
DC(addr[j]);
else
DC('.');
}
addr += 16;
DNL();
}
DNL();
}
/* evolve hk values from Nics to Nshss */
double DDhk(double k, double N, double hk, double Dhk, double Ni, double step, double ai, double *H_array, double *DH_array)
{
double DDhk_val;
DDhk_val = -(3 +(DH(N, Ni, step, DH_array)/H(N, Ni, step, H_array)))*(Dhk)
-pow(k/(A(N, ai)*H(N, Ni, step, H_array)),2)*hk;
return DDhk_val;
}
void
kopp_fc_func(char *in)
{
int SingleBlkOnly=0; // Default: we will send key off if Keycode >= 0x80
uint32_t LastWatchdog;
uint8_t blkTXcode=0x00;
uint8_t inhex_dec[kopp_fc_Command_char]; // in_decbin: decimal value of hex commandline
uint8_t hblen = fromhex(in+2, inhex_dec, strlen(in));
strcpy(ErrorMSG,"ok");
// If parameter 2 = "t" then "Transmitt Free Control Telegram"
SingleBlkOnly=0; // Default: we will send key off if Keycode >= 0x80
if((in[1] == 't') || (in[1] == 's'))
// Transmitt Command
// =================
{
kopp_fc_tx_on = 1; // Transmitt activated
if (in[15]=='J') printon[0]='Y'; else printon[0]='N'; // Sollen wir Daten ausgeben (Zeitstempel etc)
if(in[1] == 's') SingleBlkOnly=1; // Command = "s", -> If KeyCode > 0x80 we will send no !! Key Off Code
LastWatchdog=ticks; // I guess, Watchdog reset was done shortly before
BlockStartTime=ticks;
// print some status Information
if (printon[0]=='Y')
{
DS_P(PSTR("Transmitt\r\n"));
DS_P(PSTR("commandlineparameter: "));
DS(in);
DS_P(PSTR("\r\nStringlength: "));
DU(strlen(in),0);
DS_P(PSTR("\r\nNext Character (int) after parameter (should be line end character): "));
DU((int)in[strlen(in)],0);
DS_P(PSTR("\r\nAmount of Bytes (Hex) found inside command line parameter: "));
DU(hblen,0);
DS_P(PSTR("\r\n"));
// following code to check whether ticks uses full 32 bits or will be reset afer 125 ticks
DS_P(PSTR("Tick Timer: "));
DH((uint16_t)(( BlockStartTime>>16) & 0xffff),4);
DH((uint16_t)(BlockStartTime & 0xffff),4);
DS_P(PSTR("\r\n"));
}
int main()
{
DeltaHeap<unsigned int> DH(100, &hashfun);
for (unsigned int i = 10; i > 0; i--) {
cout << "Adding item " << i << " with priority " << (float) i << endl;
DH.add(i, (float) i);
}
cout << "Promote 9 to have value 3.0" << endl;
DH.add(9, 3.0);
cout << "Demote 6 to have value 8.0" << endl;
DH.add(6, 8.0);
unsigned int u = DH.min();
float p = DH.minPriority();
cout << "The minimum element is " << u << " with priority " << p << endl;
p = DH.minPriority();
u = DH.popMin();
cout << "Popped the minimum element " << u << " with priority " << p << endl;
p = DH.minPriority();
u = DH.popMin();
cout << "Popped the minimum element " << u << " with priority " << p << endl;
p = DH.minPriority();
u = DH.popMin();
cout << "Popped the minimum element " << u << " with priority " << p << endl;
cout << "Adding element " << u << " with priority 0.0" << endl;
DH.add(u, 0.0);
DH.deleteAllValues();
cout << "DH size is " << DH.size() << endl;
clrandom rng;
DH.add(10, -1E16);
cout << "top priority = " << -DH.minPriority() << endl;
return 0;
}
/**
* FSAL_closedir :
* Free the resources allocated for reading directory entries.
*
* \param dir_descriptor (input):
* Pointer to a directory descriptor filled by FSAL_opendir.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes can be returned :
* ERR_FSAL_IO, ...
*/
fsal_status_t CEPHFSAL_closedir(fsal_dir_t * extdescriptor,
fsal_op_context_t * p_context /* IN */ )
{
cephfsal_dir_t* descriptor = (cephfsal_dir_t*) extdescriptor;
struct ceph_mount_info *cmount = descriptor->ctx.export_context->cmount;
int rc = 0;
/* sanity checks */
if(!descriptor)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_closedir);
TakeTokenFSCall();
rc = ceph_ll_releasedir(cmount, DH(descriptor));
ReleaseTokenFSCall();
if (rc < 0)
Return(posix2fsal_error(rc), 0, INDEX_FSAL_closedir);
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_closedir);
}
void
read_eeprom(char *in)
{
uint8_t hb[2], d;
uint16_t addr;
#ifdef HAS_ETHERNET
if(in[1] == 'i') {
if(in[2] == 'm') { display_ee_mac(EE_MAC_ADDR);
} else if(in[2] == 'd') { DH2(erb(EE_USE_DHCP));
} else if(in[2] == 'a') { display_ee_ip4(EE_IP4_ADDR);
} else if(in[2] == 'n') { display_ee_ip4(EE_IP4_NETMASK);
} else if(in[2] == 'g') { display_ee_ip4(EE_IP4_GATEWAY);
} else if(in[2] == 'N') { display_ee_ip4(EE_IP4_NTPSERVER);
} else if(in[2] == 'o') { DH2(erb(EE_IP4_NTPOFFSET));
} else if(in[2] == 'p') {
DU(eeprom_read_word((uint16_t *)EE_IP4_TCPLINK_PORT), 0);
}
} else
#endif
if(in[1] == 'M') { display_ee_mac(EE_DUDETTE_MAC); }
else if(in[1] == 'P') { display_ee_bytes(EE_DUDETTE_PUBL, 16); }
else {
hb[0] = hb[1] = 0;
d = fromhex(in+1, hb, 2);
if(d == 2)
addr = (hb[0] << 8) | hb[1];
else
addr = hb[0];
d = erb((uint8_t *)addr);
DC('R'); // prefix
DH(addr,4); // register number
DS_P( PSTR(" = ") );
DH2(d); // result, hex
DS_P( PSTR(" / ") );
DU(d,2); // result, decimal
}
DNL();
}
void
rf_router_func(char *in)
{
if(in[1] == 0) { // u: display id and router
DH2(rf_router_myid);
DH2(rf_router_target);
DNL();
#ifdef RFR_DEBUG
} else if(in[1] == 'd') { // ud: Debug
DH((uint16_t)ticks, 4); DC('.');
DH2(rf_router_sendtime);
DNL();
} else if(in[1] == 's') { // us: Statistics
DH(nr_t,1); DC('.');
DH(nr_f,1); DC('.');
DH(nr_e,1); DC('.');
DH(nr_k,1); DC('.');
DH(nr_h,1); DC('.');
DH(nr_r,1); DC('.');
DH(nr_plus,1);
DNL();
#endif
} else if(in[1] == 'i') { // uiXXYY: set own id to XX and router id to YY
fromhex(in+2, &rf_router_myid, 1);
ewb(EE_RF_ROUTER_ID, rf_router_myid);
fromhex(in+4, &rf_router_target, 1);
ewb(EE_RF_ROUTER_ROUTER, rf_router_target);
} else { // uYYDATA: send data to node with id YY
rb_reset(&RFR_Buffer);
while(*++in)
rb_put(&RFR_Buffer, *in);
rf_router_send(0);
}
}
void
fhtsend(char *in)
{
uint8_t hb[6], l; // Last byte needed for 8v checksum
l = fromhex(in+1, hb, 5);
if(l < 4) {
if(hb[0] == 1) { // Set housecode, clear buffers
if(l == 3) {
ewb(EE_FHTID , hb[1]); // 1.st byte: 80b relevant
ewb(EE_FHTID+1, hb[2]); // 1.st+2.nd byte: 8v relevant
fht_init();
return;
} else {
DH2(fht_hc0);
DH2(fht_hc1);
}
#ifdef HAS_FHT_80b
} else if(hb[0] == 2) { // Return the 80b buffer
fht80b_print(l==1 || hb[1]==1);
} else if(hb[0] == 3) { // Return the remaining fht buffer
#if FHTBUF_SIZE > 255
DH(fht_bufspace(),4);
#else
DH2(fht_bufspace());
#endif
#endif
#ifdef HAS_FHT_8v
} else if(hb[0] == 0x10) { // Return the 8v buffer
uint8_t na=0;
for(int i = 0; i < FHT_8V_NUM; i++) {
if(fht8v_buf[2*i] == FHT_8V_DISABLED)
continue;
if(na)
DC(' ');
DH2(i);
DC(':');
DH2(fht8v_buf[2*i]);
DH2(fht8v_buf[2*i+1]);
na++;
}
if(na==0)
DS_P( PSTR("N/A") );
} else if(hb[0] == 0x11) { // Return the next 8v timeout
DH2(fht8v_timeout/125);
#endif
}
DNL();
} else {
#ifdef HAS_FHT_8v
if(hb[0]>=fht_hc0 &&
hb[0]< fht_hc0+FHT_8V_NUM &&
hb[1]==fht_hc1) { // FHT8v mode commands
if(hb[3] == FHT8V_CMD_PAIR) {
addParityAndSend(in, FHT_CSUM_START, 2);
} else if(hb[3] == FHT8V_CMD_SYNC){// start syncprocess for _all_ 8v's
fht8v_ctsync = hb[4]; // use it to shorten the sync-time
fht8v_timeout=1;
// Cheating on the 1%
uint8_t cnt = 0;
for(uint8_t i = 0 ; i < FHT_8V_NUM; i++ )
if(fht8v_buf[2*i] != FHT_8V_DISABLED )
cnt++;
credit_10ms += (4*fht8v_ctsync); // should be 3.75 = 75ms / 2 / 10
} else { // Valve position
uint8_t idx = (hb[0]-fht_hc0)*2;
fht8v_buf[idx ] = hb[3]; // Command or 0xff for disable this
fht8v_buf[idx+1] = hb[4]; // slot (valve)
}
return;
}
#endif
#ifdef HAS_FHT_80b
if(!fht_addbuf(in)) // FHT80b mode: Queue everything
DS_P( PSTR("EOB\r\n") );
#endif
}
}
/**
* FSAL_readdir :
* Read the entries of an opened directory.
*
* \param descriptor (input):
* Pointer to the directory descriptor filled by FSAL_opendir.
* \param start_position (input):
* Cookie that indicates the first object to be read during
* this readdir operation.
* This should be :
* - FSAL_READDIR_FROM_BEGINNING for reading the content
* of the directory from the beginning.
* - The end_position parameter returned by the previous
* call to FSAL_readdir.
* \param get_attr_mask (input)
* Specify the set of attributes to be retrieved for directory entries.
* \param buffersize (input)
* The size (in bytes) of the buffer where
* the direntries are to be stored.
* \param dirents (output)
* Adress of the buffer where the direntries are to be stored.
* \param end_position (output)
* Cookie that indicates the current position in the directory.
* \param count (output)
* Pointer to the number of entries read during the call.
* \param end_of_dir (output)
* Pointer to a boolean that indicates if the end of dir
* has been reached during the call.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes can be returned :
* ERR_FSAL_IO, ...
*/
fsal_status_t CEPHFSAL_readdir(fsal_dir_t *extdescriptor,
fsal_op_context_t * p_context, /* IN */
fsal_cookie_t extstart,
fsal_attrib_mask_t attrmask,
fsal_mdsize_t buffersize,
fsal_dirent_t *dirents,
fsal_cookie_t *extend,
fsal_count_t *count,
fsal_boolean_t *end_of_dir)
{
int rc = 0;
fsal_status_t status;
struct dirent de;
cephfsal_dir_t* descriptor = (cephfsal_dir_t*) extdescriptor;
struct ceph_mount_info *cmount = descriptor->ctx.export_context->cmount;
loff_t start = ((cephfsal_cookie_t*) extstart.data)->cookie;
loff_t* end = &((cephfsal_cookie_t*) extend->data)->cookie;
unsigned int max_entries = buffersize / sizeof(fsal_dirent_t);
/* sanity checks */
if(!descriptor || !dirents || !end || !count || !end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
*end_of_dir = FALSE;
*count = 0;
TakeTokenFSCall();
(void) ceph_seekdir(cmount, DH(descriptor), start);
while ((*count <= max_entries) && !(*end_of_dir)) {
struct stat st;
memset(&dirents[*count], sizeof(fsal_dirent_t), 0);
memset(&de, sizeof(struct dirent), 0);
memset(&st, sizeof(struct stat), 0);
int stmask = 0;
TakeTokenFSCall();
rc = ceph_readdirplus_r(cmount, DH(descriptor), &de, &st, &stmask);
if (rc < 0) /* Error */
Return(posix2fsal_error(rc), 0, INDEX_FSAL_readdir);
else if (rc == 1) {
/* Got a dirent */
cephfsal_handle_t* entryhandle
= (cephfsal_handle_t*) &(dirents[*count].handle.data);
cephfsal_cookie_t* entrycookie
= (cephfsal_cookie_t*) &(dirents[*count].cookie);
/* skip . and .. */
if(!strcmp(de.d_name, ".") || !strcmp(de.d_name, ".."))
continue;
entryhandle->data.vi.ino.val = st.st_ino;
entryhandle->data.vi.snapid.val = st.st_dev;
status = FSAL_str2name(de.d_name, FSAL_MAX_NAME_LEN,
&(dirents[*count].name));
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_readdir);
entrycookie->data.cookie = ceph_telldir(cmount, DH(descriptor));
dirents[*count].attributes.asked_attributes = attrmask;
status =
posix2fsal_attributes(&st,
&(dirents[*count].attributes));
if(FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(dirents[*count].attributes
.asked_attributes);
FSAL_SET_MASK(dirents[*count].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
if (*count != 0) {
dirents[(*count)-1].nextentry = &(dirents[*count]);
}
(*count)++;
} else if (rc == 0) /* EOF */
*end_of_dir = TRUE;
else{
/* Can't happen */
abort();
}
} /* while */
(*end) = ceph_telldir(cmount, DH(descriptor));
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
