ElectroYou

Buongiorno a tutti,
vorrei fare il negato di questa funzione:
digitalWrite (f4, (HIGH&&(f & B1000)));

ho provato:

digitalWrite (~(f4, (HIGH &&(f & B1000))));
~ digitalWrite (f4, (HIGH &&(f & B1000)));
digitalWrite ~(f4, (HIGH &&(f & B1000)));

ma mi da sempre errore.

qualcuno sa darmi qualche dritta?

ciao e grazie
Antonio

L'unica espressione in quella riga è:

Codice: Seleziona tutto

HIGH && (f & B1000)

siccome HIGH vale sempre 1, da 1 && qualcosa si ottiene la booleanità (1 o 0) di quel qualcosa, e in questo caso il qualcosa è:

Codice: Seleziona tutto

f & B1000

cioè il valore della variabile 'f' con tutti i bit azzerati tranne il bit3.

Per me in questo contesto è difficile capire cosa esattamente vorresti negare.

Il livello in uscita ottenuto con quella digitalWrite?
E poi, negazione a livello di bit (operatore ~), oppure negazione logica (operatore !) ?

Probabilmente è il secondo caso, e allora bastava negare la booleanità dell'espressione:

Codice: Seleziona tutto

!(HIGH &&(f & B1000)))

aduri ha scritto:vorrei fare il negato di questa funzione:
digitalWrite (f4, (HIGH&&(f & B1000)));

~ digitalWrite (f4, (HIGH &&(f & B1000)));

Sarebbe possibile, se la funzione restituisse un valore che andrebbe comunque assegnato ad una variabile di tipo opportuno.

aduri ha scritto:digitalWrite (~(f4, (HIGH &&(f & B1000))));

Sarebbe possibile, se la funzione accettasse un valore e non due.

aduri ha scritto:digitalWrite ~(f4, (HIGH &&(f & B1000)));

ma mi da sempre errore.

Ovviamente, le chiamate alle funzione in C prevedono le ( dopo il nome della funzione

aduri ha scritto:qualcuno sa darmi qualche dritta?

Prima studiare la documentazione di digitalWrite:

Poi negare l'unico argomento della funzione che ha senso negare.

Grazie delle risposte,
comunque io vorrei ottenere una negazione bit a bit
se ho 1010 vorrei ottenere 0101.

ciao
Antonio

Ho risolto cosi':

digitalWrite (f1, !(HIGH &&(f & B0010)));

se puo' essere utile a qualcuno.

ciao e grazie
Antonio

Stai scrivendo cose senza senso.
HIGH && (f & B1000) passato come secondo parametro alla digitalWrite fa inutilmente 2 casting, il primo di (f & B1000) da intero a booleano per poter fare && ed il secondo da booleano a uint8_t che è il tipo del secondo parametro della digitalWrite.
HIGH e true (come false e LOW) son cose diverse, anche se di solito hanno lo stesso valore.
A che serve fare HIGH && qualsiasicosa?
comunque qualsiasicosa, per poter essere data in pasto a &&, deve poter essere trasformata in bool, HIGH viene "trasformato" in true e && true non cambia nulla.
Puoi quindi passare direttamente (f & B1000) oppure il nuovo (f & B0010) alla digitalWrite che al suo interno poi lo confronterà con LOW.

B1000 e B0010 sono costanti diverse: prima fai riferimento ad una poi all'altra, non che sia in sé un problema, ma l'importante è che le usi bene per quel che ti serve.


Inoltre prima chiedi un not bitwise, poi usi il not booleano.... Perché?

GioArca67 ha scritto:Inoltre prima chiedi un not bitwise, poi usi il not booleano.... Perché?

Probabilmente vuole scrivere un bit (o il suo contrario) di una variabile sull'uscita. E probabilmente l'inversione bitwise che serve in questo caso è uno xor (^) sul singolo bit, e non un'inversione dei bit dell'intera variabile (~). In alternativa con la negazione logica (!) sul risultato dell'espressione si ottiene lo stesso effetto finale.

Considerando che la digitalWrite applica un implicito cast a boolean (falso se zero, vero se diverso da zero), entrambi questi modi andavano bene:

Codice: Seleziona tutto

digitalWrite(pin_uscita, !(variabile & B0010));

Codice: Seleziona tutto

digitalWrite(pin_uscita, (variabile ^ B0010) & B0010);

djnz ha scritto:Considerando che la digitalWrite applica un implicito cast a boolean (falso se zero, vero se diverso da zero),

Questa la digitalWrite()

Codice: Seleziona tutto

void digitalWrite(uint8_t pin, uint8_t val)
{
        uint8_t timer = digitalPinToTimer(pin);
        uint8_t bit = digitalPinToBitMask(pin);
        uint8_t port = digitalPinToPort(pin);
        volatile uint8_t *out;

        if (port == NOT_A_PIN) return;

        // If the pin that support PWM output, we need to turn it off
        // before doing a digital write.
        if (timer != NOT_ON_TIMER) turnOffPWM(timer);

        out = portOutputRegister(port);

        uint8_t oldSREG = SREG;
        cli();

        if (val == LOW) {
                *out &= ~bit;
        } else {
                *out |= bit;
        }

        SREG = oldSREG;
}



Non fa cast a boolean in ingresso, ma accetta uint8_t, che poi usa nel confronto con LOW

Grazie per la precisazione, non effettua tecnicamente un cast, ma ottiene lo stesso risultato: scrive zero sul pin se il valore è zero (LOW), e uno se diverso da zero.