ADCS | Autonomous Digital Control Station - Rocket Test

Don't try to use setjmp()/longjmp() to re-enter a main-level function from an ISR. This calls for disaster, because the ISR is never finished correctly. You might like to use assembly to work around, but this is really fragile. I'm not sure that this works at all on AVRs.

Since your baudrate is 38400, one byte needs at least some 250µs to transfer. Assumed that your message has a minimum of 4 bytes, the time to transfer a message is at least 1ms.

There are multiple possible solutions; your question might be closed because they are opinion-based...

However, here are some ideas:

Since a message can arrive only once per millisecond or less, your application don't need to be much faster than that.

Divide your main tasks into separated steps, each running faster than 1 ms. You might like to use a state machine, for example to allow slower I/O to finish.

After each step, check for a completed message. Using a loop avoids code duplication.

Use a timer interrupt to do the repeated work. Divide it in short tasks, a state machine does magic here, too.

Use an otherwise unused interrupt to signal the end of the message. Its ISR may run a bit longer, because it will not be called often. This ISR can handle the message and change the state of the application.

You need to think about interrupt priorities with much care.

The endless loop in main() will effectively be empty, like for (;;) {}.

I thin you're misunderstanding the role of the Root CA certificate here as well as the concept of the certificate chain.

When your subordinate CA issues a certificate to an end-entity (such as IIS, for example) the only connection the issued certificate has with the subordinate CA is that the name of the CA is embedded within the certificate (the Issuer field) and that this certificate is signed by the CA's private key with this signature also embedded as part of the certificate. The CA certificate is not attached to your certificate in any other way.

When you double-click on the certificate in Windows, it shows you details of that certificate. When you look at the Certificate Path tab, it simply shows you as much of the chain as it can work out. It will look at the issuer of your certificate and if it has access to the Sub CA certificate from it's certificate store or by downloading it from the repository, it will list it too. That CA certificate also has an issuer (the Root CA in your case) and if it has access to that within its certificate store, it will also list it in the Certificate Path.

The Root CA is installed in a specific certificate store called the trust-anchor store. This is where you (or your admins) install root certificates that you have verified and have decided to trust. These are used to build certificate chains. That is, if your certificate chains to a root CA certificate in this trust-anchor store, then you are implicitly trusting your certificate. If a certificate doesn't chain to a root CA certificate in your trust-anchor store, then you don't trust that certificate. It is this latter which you're seeing at the moment. That is, you haven't installed the root CA certificate in your trust-anchor store.

In Windows, the trust-anchor store is shown as a subfolder of your Certificates MMC called Trusted Root Certification Authorities.

You can manually import your root CA into this trust-anchor store (right-click, All Tasks > Import..., or you can use Active Directory or Group Policy to distribute them to all or some computers.

Once you have your root CA installed in your trust-anchor store, you should be able to view the whole chain and won't get the The issuer of this certificate could not be found. message.

It would seem data is pointing to an array, not a single 8 bit int, and that:

1. The first element of the array is a pointer into the arrays adcState and adcMessageId

2. The second and third elements of the array comprise a data value for the array adcMessageId

3. As commenter @Eugene Sh. pointed out, data[2] is promoted to an int before shifting, so no bits are lost.

The pointer notation uint8_t * is as valid as array notation uint8_t [] in a function signature for passing an array; it's often how char * strings are passed, and arrays decay to a pointer to their first element when passed to functions anyway.

A different way to think about the problem is that you want to look at the first "word" in the column Name where "word" is the collection of characters from the start of the string to the first space.

String matching in SSIS is case-sensitive so you'll want to force the first word to lower/upper case - however your master list of titles is cased (and then ensure the title list is all lower/upper case).

I am an advocate of making life easier on yourself so I'll add a Derived Column, actually lots of derived columns, that will identify the position of the first space in Name and I'll call this FirstSpace

Add a new column, called FirstSpace. The expression we want to use is FINDSTRING

adcValue is getting optimized away because the compiler doesn't "see" the variable change in the ISR (it can't tell if the ISR will ever be called). Therefore, it'll just be replaced with a constant. The way to fix this is to mark it volatile, which tells the compiler not to assume anything about the variable and prevents the compiler from optimizing it away.

Now, on top of this, adcValue is a double type. In general, you want to avoid using floating point (and especially double) variables in devices without an FPU. Specifically, the conversion between integer and floating point types takes a LOT of cycles. Like, on the order of hundreds of cycles. You probably don't want this in your ISR.

If you really need the variable to be a float, I suggest doing the conversion outside of the ISR. You'd have two variables, the static volatile uint16_t wAdcValue, and local to where you need a float, you'd assign float fAdcValue = (float) wAdcValue; Note that any floating point manipulation will require more processing and flash usage to handle it.

ARM is a risk device, so 27 cycles is roughly equal to 27 instructions, IIRC. You may find that you're going to need a higher clock rate to meet your timing requirements. What OS are you running? Do you have access to the cache controller? You may need to lock data buffers into the cache to get high enough performance. Also, keep your sums and raw data physically close in memory as your system will allow.

I am not convinced your perf issue is entirely the consequence of how you are stepping through your data array, but here's a more streamlined approach than what you are using:

A simple (crude, but might just work) solution is to count zero-crossings over time. I am not sure what timer support the CodeVision library provides, but I'll assume you have a 1 millisecond resolution tick count and a 1 millisecond resolution delay. If not you'll have to provide your own using a timer peripheral.

I got it working, looks like it wasn't the understanding of the PIC the problem, but the XC8 compiler instead.. I thought the RTCWREN bit had to be checked before enable the RTCEN

You can use ICertView COM interface to query Request.RawRequest column from CA database for required request. You will get request in a PKCS#10 or PKCS#7/CMC format.