Itse huomannut lähes kaikessa koodaamisessa että kun tavallaan valmis koodi on niin kannattaa aloittaa alusta kun tiedetään tarkasti miten koodi on ajateltu toimivaksi itsellä ainakin tällä kerralla välistä jää paljon turhaa koodia pois enkä ole kertaakaan saanut koodia toimimaan laakista.
Autolaturi mökille varavoimaksi Arduinon avulla
Running - waiting välille tulee varmaa tila stopping ?No tässä olisi tällainen vuokaavio tästä ohjaussysteemistä. Jos tarvii tarkentaa jotain kohtaa, kertokaa niin päivitän kaavion.
Missä kaikissa tiloissa tarkastetaan jännite >15V ? Ilmeisesti aina tilasta riippumatta?
Tuossa mietin ainakin että kun startti ajaa konetta pyörittääkö se yli 300rpm eikö tuo raja kannattas nostaa jonnekin 1000rpm paikkeille vai paljonko tuollainen kone kiertää tyhjäkäynnillä.
Itse tekisin ehkä suoraan looppiin tuon yli15v jännitteen tutkimisen joka palauttaa heti tilan fail
Itse tekisin ehkä suoraan looppiin tuon yli15v jännitteen tutkimisen joka palauttaa heti tilan fail
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@Nasty76 , kaikki kierroslukuarvot ja todennäköisesti myös alarajajännite ovat tässä vaiheessa vielä valistuneita arvauksia ja niitä ehtii sitten hienosäätää, kun koko systeemi on toimivana. Esim. tuo 300 kierrosta minuutissa lienee sitä luokkaa, että siinä voidaan ajatella, että moottori on käynnistynyt. Tuskin starttimoottori noin lujaa pyörittää moottoria ja helppohan sitä on tarpeen mukaan muuttaa ylemmäs.
Moottorin ilmoitettu tyhjäkäynti on 1 400 kierrosta minuutissa, starttimoottori kuitenkin tulisi irroittaa jo paljon ennen tätä, eli kun moottori alkaa niin sanotusti putputtamaan. Tyhjäkäyntiähän ei käytännössä tulla käyttämään koskaan, sillä moottori käynnistyy suoraan siihen kierrosnopeuteen, mihin se on asetettu. Veikkaanpa jotain puolikaasua, ehkä luokkaa 2 000 - 3 000 kierrosta minuutissa. Sitä suuremmalla syyllä startin olisi hyvä irrota moottorista jo ajoissa.
Moottorin ilmoitettu tyhjäkäynti on 1 400 kierrosta minuutissa, starttimoottori kuitenkin tulisi irroittaa jo paljon ennen tätä, eli kun moottori alkaa niin sanotusti putputtamaan. Tyhjäkäyntiähän ei käytännössä tulla käyttämään koskaan, sillä moottori käynnistyy suoraan siihen kierrosnopeuteen, mihin se on asetettu. Veikkaanpa jotain puolikaasua, ehkä luokkaa 2 000 - 3 000 kierrosta minuutissa. Sitä suuremmalla syyllä startin olisi hyvä irrota moottorista jo ajoissa.
Stopping- tila ei ole välttämätön mutta arduinon kannalta moottorin sammuminen on kuitenkin hidas tapahtuma, loop() ajaa monta kertaa sen aikana kun kone sammuu (sekunteja kuitenkin koko tapahtuma).
Ja waiting- tilassa ei tietenkään saa olla koodia joka hämääntyy siitä että moottorilla on vielä kierroksia enemmän kuin 0.
Riippuu myös miten sammutus ja käynnistys tapahtuu, oikeastaanhan pitäisi ensin hallitusti lopettaa lataus (= pwm pienelle), kääntää sammutuslähtö ja sitten odottaa että kierrokset/tärinä ilmaisee että on seis.
2 ensimmäistä menee tilanvaihdossa running -> waiting mutta missä odotetaan että on oikeasti sammunut ?
Yksi tapa olla lisätä stopping- tila odotusta varten ja vasta kun todetaan että on oikeasti sammunut niin sammutuslähdön nollaus ja tilanvaihto -> waiting.
Toinen vaihtoehto on tietysti sammutuslähdön palautus ajo-asentoon vasta silloin kun käynnistetään. Tyyliin sammutuslähdön nollaus, odotetaan esim 200ms koska rele on hidas ja sitten starttilähtö päälle jne. Ja tässä välissä delay(200) on ihan ok eikä kannata tehdä ajastimella.
Ja waiting- tilassa ei tietenkään saa olla koodia joka hämääntyy siitä että moottorilla on vielä kierroksia enemmän kuin 0.
Riippuu myös miten sammutus ja käynnistys tapahtuu, oikeastaanhan pitäisi ensin hallitusti lopettaa lataus (= pwm pienelle), kääntää sammutuslähtö ja sitten odottaa että kierrokset/tärinä ilmaisee että on seis.
2 ensimmäistä menee tilanvaihdossa running -> waiting mutta missä odotetaan että on oikeasti sammunut ?
Yksi tapa olla lisätä stopping- tila odotusta varten ja vasta kun todetaan että on oikeasti sammunut niin sammutuslähdön nollaus ja tilanvaihto -> waiting.
Toinen vaihtoehto on tietysti sammutuslähdön palautus ajo-asentoon vasta silloin kun käynnistetään. Tyyliin sammutuslähdön nollaus, odotetaan esim 200ms koska rele on hidas ja sitten starttilähtö päälle jne. Ja tässä välissä delay(200) on ihan ok eikä kannata tehdä ajastimella.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No niin, jotain edistystä. Nyt sentään startti toimii, muttei ihan oikein, viiveet ovat ainakin simulla pidemmät mitä pitäisi olla. Nyt tila ei kuitenkaan vaihtele hallitsemattomasti. Loop-funktiossa on case-break juttu käytössä, en tiedä onko tuo ihan oikein laitettu.
Lisäksi jännä juttu kun lisäsin tuon STOPPING-tilan, mutta sille ei sitten löytynytkään käyttöä, niin halusin sen poistaa. Sitten kävi niin, että ei mene kääntäjästä läpi, jos tuone #define STOPPING 6 -rivin poistaa. Herja tulee liquid crystal-kirjastosta, joka kyllä on oikein asennettu. Lisäksi tuota STOPPING-tilaa ei esiinny missään koodissa.
Ajastimien osalta häikkää oli, eli tuossa koodissa pitää olla ainakin tuo .started komento käytössä, muuten ajastin ei lähde päälle. Saattaa toisaalta johtua myös, jos on loopissa, niin se pitäisi osata laittaa sinne koodin sisään.
Tässä ajastinkirjaston testikoodi:
Varsinainen koodi:
Lisäksi jännä juttu kun lisäsin tuon STOPPING-tilan, mutta sille ei sitten löytynytkään käyttöä, niin halusin sen poistaa. Sitten kävi niin, että ei mene kääntäjästä läpi, jos tuone #define STOPPING 6 -rivin poistaa. Herja tulee liquid crystal-kirjastosta, joka kyllä on oikein asennettu. Lisäksi tuota STOPPING-tilaa ei esiinny missään koodissa.
Ajastimien osalta häikkää oli, eli tuossa koodissa pitää olla ainakin tuo .started komento käytössä, muuten ajastin ei lähde päälle. Saattaa toisaalta johtua myös, jos on loopissa, niin se pitäisi osata laittaa sinne koodin sisään.
Tässä ajastinkirjaston testikoodi:
C++:
#include <neotimer.h>
Neotimer testTime = Neotimer(2000); //2 second
void setup() {
Serial.begin(250000);
}
void loop() {
if (!testTime.started()) {
testTime.start();
}
if (testTime.done()) {
Serial.println("Tulosta 2 sek valein.");
testTime.reset();
}
}Varsinainen koodi:
C++:
// Generator control system for car alternator (Ford with PWM controlled charging voltage) and small engine
#define DEBUG_STATUS // Serial debug, comment to disable, downmost values
//#define DEBUG_MAIN //Serial debug, comment to disable, uppermost main function values
// System status variables (motorStatus)
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5
#define STOPPING 6
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h> // Non-blocking timer from Neotimer library
Neotimer motorTime = Neotimer(10000); // 10 second timer for startup detection
Neotimer stepTime = Neotimer(1000); // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(15000); // 15 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)
Neotimer crankTime = Neotimer(4000); // 4 second timer, if problems to start, try at most 4 seconds continuous cranking
Neotimer crankWait = Neotimer(5000); // 5 second timer, if crank failed, wait 5 seconds before a new try
Neotimer voltageWait = Neotimer(2000); // 60 seconds timer, how long to wait with undervoltage & other assigned conditions, before the starting function executes
Neotimer serDelay = Neotimer(1000); // For serial print interval
LiquidCrystal_I2C lcd(0x27, 16, 2); // Create a new LiquidCrystal_I2C display object with the correct I2C address and display size
// Define the pins
const int currentPin = A0; // Information about current
const int voltagePin = A2; // Information about voltage
const int motorPin = 2; // Motor running pin (vibration sensor), HIGH = motor running, TEST purpose LOW
const int pwmPin = 9; // PWM output pin
const int relayPin = 4; // Shutdown relay control pin
const int rpmPin = 11; // RPM Hall Sensor input pin, sensor type: 3144
const int starterPin = 3; // Starter relay control pinn
// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00; // Factor to convert ADC reading to voltage
// Define the points for current calculation / the line equation
float x1 = 0.500; // volts
float y1 = 0; // amps
float x2 = 4.005; // volts
float y2 = 150; // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1; // Variable to shift the whole current level
float sensVfactor = 20.00 / 4.9248; // 4.9248 volts = 20 volts, factor to convert high voltage to 0-5 V
//float current; // Store current value, actual value
int current; // For current testing, serial input
//float sensVoltage; // Store sensed voltage, actual value
int sensVoltage = 13; // For voltage testing, serial input
const int N = 25; // Number of current readings to average
const int Y = 25; // Number of sensed voltage readings to average
int readings[N]; // Array to store the current readings
int readingsV[Y]; // Array to store the sensed voltage readings
// PWM
int pwmValues[] = { 24, 41, 58, 77 }; // PWM duty cycle steps (ramp up), 77 = ~30 %, you can add steps, if needed
int currentPwmStep = 0;
// Motor state, starting and shutting down
int motorStatus; // 0=waiting, for low voltage 1=starting, 2=started, 3=ramping up pwm, 4=running, 5=stopping, 6=system or engine malfuntion, stopped
int startTry; // 0=not tried to start yet, 1=first try done, 2=second, 3=third, 4=fourth, 5=fifth
int startInterval; // 0=not waiting after start attempt, 1=waiting after start attempt
float startVoltage = 11.9; // Volts, under what voltage the starting function will execute
float shutCurrent = 5; // Amperes, below what charging current to execute the shutdown function
float upVoltage = 15; // Volts, max allowed voltage
float rpmTH = 300; // Revolutions per minute, rpm threshold greater than this to stop cranking (assume motor is started rpms over the threshold)
float rpmRun = 1800; // Revolutions per minute, the rpm greater than this is accounted as motor normal running
//RPM Calculation
int rpm = 0; //unsigned long rpm = 0; // Variable to store rpm value
unsigned long duration; // Sensor pulse in duration
// int lcdStep; //0=current display, 1=voltage display, not used at the time
void setup() {
Serial.begin(250000); // Start the serial communication
#ifdef DEBUG_MAIN
Serial.println("Setup...");
#endif
Wire.begin();
// Check if the LCD is connected
Wire.beginTransmission(0x27);
if (Wire.endTransmission() == 0) {
// LCD is connected, proceed with initialization
delay(50);
lcd.begin(16, 2);
lcd.backlight();
lcd.clear();
} else {
// LCD is not connected, continue without initializing the LCD
#ifdef DEBUG_MAIN
Serial.println("Ei LCD:ta. Ohitus.");
#endif
}
// Change timers on pins to change PWM freq to 122 Hz
// Pins D9 and D10 - 122 Hz
TCCR1A = 0b00000001; // 8bit
TCCR1B = 0b00000100; // x256 phase correct
// Make pins output/input
pinMode(currentPin, INPUT); // Information on charging current
pinMode(voltagePin, INPUT); // Information on voltage, for real use, delete _PULLUP
pinMode(motorPin, INPUT_PULLUP); // Vibration sensor in, for motor running detect, for real use, delete _PULLUP (it is for test purpose, pullup resistor)
pinMode(pwmPin, OUTPUT); // Alternator PWM output
pinMode(relayPin, OUTPUT); // Ignition relay pin
pinMode(rpmPin, INPUT_PULLUP); // RPM sensing pin
pinMode(starterPin, OUTPUT); // Engine starter relay pin
// Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
analogWrite(pwmPin, 255);
#ifdef DEBUG_MAIN
Serial.println("Setup ok.");
#endif
}
void motorCrankState() { // Detection of undervoltage to trigger motor cranking function
if (sensVoltage < startVoltage) { // If motorStatus is WAITING and sensed voltage is less than start voltage, trigger cranking function
#ifdef DEBUG_MAIN
Serial.println("Jannitekynnys kaynnistykseen!");
#endif
if (!voltageWait.started()) { // Start the voltageWait timer only, if it has not been started yet
voltageWait.start(); // Start the voltageWait timer if it hasn't started yet
}
if (voltageWait.done()) { // Wait for voltageWait to be done before moving to the cranking of the engine
motorStatus = STARTING;
digitalWrite(relayPin, HIGH); // Switch ignition relay on
voltageWait.stop();
voltageWait.reset(); // Reset timer
}
}
}
void crank() { // Engine starting function
if (((startTry >= 0) && (startTry <= 4)) && (startInterval == 0)) { // If conditions are met, start executing
if (rpm <= rpmTH) { // If motor runs slower than the threshold, switch starter relay on
digitalWrite(starterPin, HIGH);
if (!crankTime.started()) {
crankTime.start(); // Start the crankTime timer if it hasn't started yet
}
if (crankTime.done()) { // If motor did not start during the crankTime, stop starting
digitalWrite(starterPin, LOW); // Switch starter relay off
crankTime.stop();
crankTime.reset(); // Reset timer
startTry += 1; // Add one attempt
startInterval = 1; // Start waiting time function after starting attempt
}
}
} else if (rpm > rpmTH) { // If motor runs faster than the threshold, switch starter relay off
digitalWrite(starterPin, LOW); // Switch starter pin off
startTry = 0;
motorStatus = STARTED;
crankTime.stop();
crankTime.reset(); // Reset timer
}
}
void Waiter() { // Wait after starting attempt
if (((startTry >= 0) && (startTry <= 4)) && (startInterval == 1)) { // If conditions are met, start executing
if (!crankWait.started()) {
crankWait.start(); // Start the crankWait timer if it hasn't started yet
}
if (crankWait.done()) { // If timer is done
startInterval = 0; // revert to state 0 (waiting time after start attempt ready)
crankWait.stop();
crankWait.reset(); // reset timer
}
}
}
void startFail() { // If engine did not start put system status to state 5 (malfunction)
if (startTry == 5) {
motorStatus = FAIL;
digitalWrite(starterPin, LOW); // Starter relay off
digitalWrite(relayPin, LOW); // Ignition switch relay off
#ifdef DEBUG_MAIN
Serial.println("Kaynnistysvirhe!");
#endif
lcd.setCursor(0, 0); // On lcd print "Engine start failed"
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistys ");
lcd.setCursor(0, 1);
lcd.print("ep");
lcd.print((char)0xe1);
lcd.print("onnistui ");
}
}
void overvoltage() { // If voltage is over max voltage put motor status to FAIL (malfuntion) and shut down the ignition relay
if (sensVoltage >= upVoltage) {
motorStatus = FAIL;
digitalWrite(relayPin, LOW);
#ifdef DEBUG_MAIN
Serial.println("Ylijannite!");
#endif
lcd.setCursor(0, 0); // On lcd print "Overvoltage"
lcd.print("Ylij");
lcd.print((char)0xe1);
lcd.print("nnite ");
lcd.setCursor(0, 1);
lcd.print(" ");
}
}
void motorRunning() { // Engine running detection
if ((rpm > rpmRun) || (digitalRead(motorPin == HIGH))) { // If engine runs faster than rpmRun value (revolution per minute) assume motor is running normally
#ifdef DEBUG_MAIN
Serial.println("Kayntitieto!");
#endif
if (!motorTime.started()) {
motorTime.start(); // Start the motorTime timer if it hasn't started yet
}
if (motorTime.done()) { // Wait for motorTime to be done before moving to ramping up PWM
motorStatus = RAMP_UP;
motorTime.stop(); // Stop the timer
motorTime.reset(); // Reset the timer
#ifdef DEBUG_MAIN
Serial.println("Kay.");
#endif
}
}
}
void rampUp() { // Ramping up PWM
//Ramp pwm up
if (stepTime.repeat()) {
analogWrite(pwmPin, pwmValues[currentPwmStep]);
currentPwmStep++;
#ifdef DEBUG_MAIN
Serial.println("Ramp up...");
#endif
if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) { //Checking the pwm step count
motorStatus = RUNNING; // Motor running on normal charging state
stepTime.stop();
stepTime.reset(); // Reset the timer
}
}
}
void shutDown() { // Engine shutdown, execute relay
// If the charging current drops to 0 to shutCurrent and charging voltage is under upVoltage and motor is running
// start the shutdown function and turn off the relay
if ((current >= 0) && (current < shutCurrent) && (sensVoltage < upVoltage)) {
// if (digitalRead(motorPin) == HIGH) { // Vibration sensor
digitalWrite(relayPin, LOW); // Switch relay off
analogWrite(pwmPin, 15); // Duty Cycle to 5 % before running down engine
if (!shutTime.started()) {
shutTime.start();
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Stopped Duty Cycle at 100 %, alternator electromagnet off
lcd.setCursor(0, 0);
lcd.print("Sammutus "); // Print on lcd "Shutdown"
lcd.setCursor(0, 1);
lcd.print(" ");
motorStatus = WAITING; // Motor has run, battery is full, go back to waiting voltage
shutTime.stop(); // Reset the timer
shutTime.reset(); // Reset the timer
#ifdef DEBUG_MAIN
Serial.println("Sammutettu.");
#endif
}
}
}
//}
void lcdDisplay() { // Show values on lcd only when
if (motorStatus == RUNNING) {
lcd.setCursor(0, 0);
lcd.print("Virta: ");
lcd.setCursor(0, 1);
lcd.print((float)current);
lcd.print(" ");
lcd.setCursor(5, 1);
lcd.print(" A ");
lcd.setCursor(8, 0);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite:");
lcd.setCursor(8, 1);
lcd.print((float)sensVoltage);
lcd.print(" ");
lcd.setCursor(13, 1);
lcd.print(" V ");
#ifdef DEBUG_MAIN
Serial.println("Virta LCD.");
#endif
}
if (motorStatus == WAITING || motorStatus == STARTING) {
lcd.setCursor(0, 0); // On lcd print "Waiting"
lcd.print("Odotetaan... ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print((float)sensVoltage);
lcd.print(" V");
}
}
void loop() {
// Calculate current from sensor reading
// Calculate the charging current from the average and display it on the LCD screen.
// Take N readings and store them in the array
// for (int i = 0; i < N; i++) {
// readings[i] = analogRead(currentPin);
// delay(1); //Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sum = 0;
// for (int i = 0; i < N; i++) {
// sum += readings[i];
// }
// float average = sum / N;
// float voltage = average * voltageFactor; // Convert ADC reading to voltage
// current = (m * voltage + b) * currentCal; // Convert voltage to current using the linear equation, correct with current calibration value if needed
// Calculate high voltage from voltage divider input
// Calculate the charging voltage from the average and display it on the LCD screen.
// Take Y readings and store them in the array
// for (int j = 0; j < Y; j++) {
// readingsV[j] = analogRead(voltagePin);
// delay(1); // Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sumV = 0;
// for (int j = 0; j < Y; j++) {
// sumV += readingsV[j];
// }
// float averageV = sumV / Y;
// float voltageV = averageV * voltageFactor; // Convert ADC reading to voltage
// sensVoltage = voltageV * sensVfactor; // Convert voltage to real voltage
// RPM Calculation from Hall Sensor input
// {
// duration = pulseIn(rpmPin, FALLING, 500000); // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
// rpm = 60000.0 / duration * 1000; // See above
// }
// Handling the motor status
switch (motorStatus) {
case WAITING:
motorCrankState();
lcdDisplay();
startFail();
overvoltage();
break;
case STARTING:
crank();
Waiter();
lcdDisplay();
startFail();
overvoltage();
break;
case STARTED:
motorRunning();
startFail();
overvoltage();
break;
case RAMP_UP:
rampUp();
lcdDisplay();
startFail();
overvoltage();
break;
case RUNNING:
startFail();
overvoltage();
break;
}
//Serial key input test code, write to various variables
#ifdef DEBUG_STATUS
if (Serial.available() > 0) {
char input = Serial.read();
switch (input) {
case '1':
rpm = 0;
break;
case '2':
rpm = 500;
break;
case '3':
rpm = 2000;
break;
case 'a':
current = 2;
break;
case 'b':
current = 20;
break;
case 'c':
current = 80;
break;
case 'z':
sensVoltage = 11;
break;
case 'x':
sensVoltage = 14;
break;
case 'y':
sensVoltage = 16;
break;
default:
Serial.println("Invalid input.");
return;
}
}
#endif
//Debug
#ifdef DEBUG_STATUS
Serial.print("Jannite: ");
Serial.print((float)sensVoltage);
Serial.println();
Serial.print("Virta: ");
Serial.print((float)current);
Serial.println();
Serial.print("Tila: ");
Serial.print(motorStatus);
Serial.println();
Serial.print("Start tila: ");
Serial.print(startTry);
Serial.println();
Serial.print("Odotus: ");
Serial.print(startInterval);
Serial.println();
Serial.print("RPM: ");
Serial.print(rpm);
Serial.println();
#endif
}- Liittynyt
- 10.07.2017
- Viestejä
- 838
Kiinanpojan tekoälyyn pyöräytin koodin ja käskin kirjoitella uusiksi nuo funktiot, ja nyt simulaation mukaan on ainakin toiminnallisesti jokseenkin toimiva koodi. Onkohan tilojen hallinta nyt niin, ettei esim. starttaus ala heti, kun moottorin nopeus laskee? Ainakin se teki tuon switch-case jutu erillä tavalla, huomasin omasta sähhellyksestäni, että logiikkani petti ainakin siinä, että funktiot olivat ehkä väärissä paikoissa. Uuteen tekoälykoodiin täytyy lisätä vielä vikatilat.
C++:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>
// System status variables
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5
#define STOPPING 6
// Pin definitions
const int currentPin = A0;
const int voltagePin = A2;
const int motorPin = 2;
const int pwmPin = 9;
const int relayPin = 4;
const int rpmPin = 11;
const int starterPin = 3;
// Timers
Neotimer motorTime = Neotimer(10000); // 10 seconds for startup detection
Neotimer stepTime = Neotimer(1000); // 1 second for PWM step interval
Neotimer shutTime = Neotimer(15000); // 15 seconds for engine shutdown
Neotimer crankTime = Neotimer(4000); // 4 seconds for cranking
Neotimer crankWait = Neotimer(5000); // 5 seconds wait after failed crank
Neotimer voltageWait = Neotimer(2000); // 2 seconds wait for undervoltage
// LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Variables
int motorStatus = WAITING;
int startTry = 0;
int startInterval = 0;
int currentPwmStep = 0;
int pwmValues[] = { 24, 41, 58, 77 }; // PWM steps
// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00; // Factor to convert ADC reading to voltage
// Define the points for current calculation / the line equation
float x1 = 0.500; // volts
float y1 = 0; // amps
float x2 = 4.005; // volts
float y2 = 150; // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1; // Variable to shift the whole current level
float sensVfactor = 20.00 / 4.9248; // 4.9248 volts = 20 volts, factor to convert high voltage to 0-5 V
const int N = 25; // Number of current readings to average
const int Y = 25; // Number of sensed voltage readings to average
int readings[N]; // Array to store the current readings
int readingsV[Y]; // Array to store the sensed voltage readings
float sensVoltage = 12.0; // Example voltage
float current = 0.0; // Example current
//RPM Calculation
int rpm = 0; //unsigned long rpm = 0;
unsigned long duration; // Sensor pulse in duration
void setup() {
Serial.begin(250000);
// Change timers on pins to change PWM freq to 122 Hz
// Pins D9 and D10 - 122 Hz
TCCR1A = 0b00000001; // 8bit
TCCR1B = 0b00000100; // x256 phase correct
// Initialize I2C and check if LCD is connected
Wire.begin();
Wire.beginTransmission(0x27);
if (Wire.endTransmission() == 0) {
// LCD is connected, proceed with initialization
lcd.begin(16, 2);
lcd.backlight();
lcd.clear();
} else {
// LCD is not connected, continue without initializing the LCD
Serial.println("LCD not connected. Skipping.");
}
// Pin modes
pinMode(currentPin, INPUT);
pinMode(voltagePin, INPUT);
pinMode(motorPin, INPUT_PULLUP);
pinMode(pwmPin, OUTPUT);
pinMode(relayPin, OUTPUT);
pinMode(rpmPin, INPUT_PULLUP);
pinMode(starterPin, OUTPUT);
analogWrite(pwmPin, 255); // Start with PWM off
}
void motorCrankState() {
if (sensVoltage < 11.9 && motorStatus == WAITING) {
if (!voltageWait.started()) {
voltageWait.start();
}
if (voltageWait.done()) {
motorStatus = STARTING;
digitalWrite(relayPin, HIGH);
voltageWait.stop();
voltageWait.reset();
}
}
}
void crank() {
if (startTry < 5 && startInterval == 0) {
if (rpm <= 300) {
digitalWrite(starterPin, HIGH);
if (!crankTime.started()) {
crankTime.start();
}
if (crankTime.done()) {
digitalWrite(starterPin, LOW);
crankTime.stop();
crankTime.reset();
startTry++;
startInterval = 1;
}
} else if (rpm > 300) {
digitalWrite(starterPin, LOW);
startTry = 0;
motorStatus = STARTED;
crankTime.stop();
crankTime.reset();
}
}
}
void Waiter() {
if (startInterval == 1) {
if (!crankWait.started()) {
crankWait.start();
}
if (crankWait.done()) {
startInterval = 0;
crankWait.stop();
crankWait.reset();
}
}
}
void motorRunning() {
if ((rpm > 1800 || digitalRead(motorPin) == HIGH) && motorStatus == STARTED) {
if (!motorTime.started()) {
motorTime.start();
}
if (motorTime.done()) {
motorStatus = RAMP_UP;
motorTime.stop();
motorTime.reset();
}
}
}
void rampUp() {
if (stepTime.repeat()) {
analogWrite(pwmPin, pwmValues[currentPwmStep]);
currentPwmStep++;
if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {
motorStatus = RUNNING;
stepTime.stop();
stepTime.reset();
}
}
}
void shutDown() {
if (current < 5 && sensVoltage < 15 && motorStatus == RUNNING) {
digitalWrite(relayPin, LOW); // Turn off the ignition relay
analogWrite(pwmPin, 15); // Set PWM to 5% (reduce alternator load)
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
motorStatus = WAITING; // Revert to WAITING state
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
// Clear LCD and display shutdown message
lcd.setCursor(0, 0);
lcd.print("Shutdown ");
lcd.setCursor(0, 1);
lcd.print(" ");
}
}
}
void lcdDisplay() {
if (motorStatus == RUNNING) {
lcd.setCursor(0, 0);
lcd.print("Current: ");
lcd.print(current);
lcd.print(" A");
lcd.setCursor(0, 1);
lcd.print("Voltage: ");
lcd.print(sensVoltage);
lcd.print(" V");
} else if (motorStatus == WAITING || motorStatus == STARTING) {
lcd.setCursor(0, 0);
lcd.print("Waiting...");
lcd.setCursor(0, 1);
lcd.print("Voltage: ");
lcd.print(sensVoltage);
lcd.print(" V");
}
}
void loop() {
// Calculate current from sensor reading
// Calculate the charging current from the average and display it on the LCD screen.
// Take N readings and store them in the array
// for (int i = 0; i < N; i++) {
// readings[i] = analogRead(currentPin);
// delay(1); //Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sum = 0;
// for (int i = 0; i < N; i++) {
// sum += readings[i];
// }
// float average = sum / N;
// float voltage = average * voltageFactor; // Convert ADC reading to voltage
// current = (m * voltage + b) * currentCal; // Convert voltage to current using the linear equation, correct with current calibration value if needed
// Calculate high voltage from voltage divider input
// Calculate the charging voltage from the average and display it on the LCD screen.
// Take Y readings and store them in the array
// for (int j = 0; j < Y; j++) {
// readingsV[j] = analogRead(voltagePin);
// delay(1); // Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sumV = 0;
// for (int j = 0; j < Y; j++) {
// sumV += readingsV[j];
// }
// float averageV = sumV / Y;
// float voltageV = averageV * voltageFactor; // Convert ADC reading to voltage
// sensVoltage = voltageV * sensVfactor; // Convert voltage to real voltage
// RPM Calculation from Hall Sensor input
// {
// duration = pulseIn(rpmPin, FALLING, 500000); // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
// rpm = 60000.0 / duration * 1000; // See above
// }
// Simulate sensor readings via Serial input
if (Serial.available() > 0) {
char input = Serial.read();
switch (input) {
case '1':
rpm = 0;
break;
case '2':
rpm = 500;
break;
case '3':
rpm = 2000;
break;
case 'a':
current = 2;
break;
case 'b':
current = 20;
break;
case 'c':
current = 80;
break;
case 'z':
sensVoltage = 11;
break;
case 'x':
sensVoltage = 14;
break;
case 'y':
sensVoltage = 16;
break;
default:
Serial.println("Invalid input.");
return;
}
}
// Handle motor status
switch (motorStatus) {
case WAITING:
motorCrankState();
lcdDisplay();
break;
case STARTING:
crank();
Waiter();
lcdDisplay();
break;
case STARTED:
motorRunning();
break;
case RAMP_UP:
rampUp();
lcdDisplay();
break;
case RUNNING:
shutDown();
lcdDisplay();
break;
}
// Debug output
Serial.print("Voltage: ");
Serial.print(sensVoltage);
Serial.print(" V, Current: ");
Serial.print(current);
Serial.print(" A, RPM: ");
Serial.print(rpm);
Serial.print(", Status: ");
Serial.println(motorStatus);
}Tähän ei voi auttaa ellet laita sitä koko virheilmoitusta mukaan.
Yleisempi ongelma on se että yrittää itse määrittää jotain joka on jo olemassa.
No ainakin lcdDisplay() kuuluu oikeastaan tuon switch-case ulkopuolelle, siis tilasta riippumatta päivitetään näyttö. Ja siellä funktiossa onkin jo oma tarkastus mitä missäkin tilassa näytetään niin voi kutsua joka kierroksella.
Sanoisin että crank() ja waiter() kannattaa yhdistää.
shutdown() ei tee mitään jos jännite on > 15, se taitaa olla turha ehto tuolla jos jännite > 15 tulee johonkin virhetarkastukseen tilojen ulkopuolelle.
Parempi ehkä tehdä sellainen "sammuta moottori"- funktio jota voit kutsua tuolta shutdown()/ "ollaan ajossa, pitää sammuttaa koska akku täynnä" ja myös "traaginen virhe, sammuta moottori". Samat jutut pitää kuitenkin suurimmaksi osaksi tehdä molemmissa tapauksissa.
Tarkasta sitten myös kommentoidusta osasta jännitteen ja virran mittaukset, ne m, b, x1, x2, y1, y2 laskennat on ihan turhia... Tarvitset molemmille vain mittauksen ja arvon skaalauksen oikealle alueelle.
"Onkohan tilojen hallinta nyt niin, ettei esim. starttaus ala heti, kun moottorin nopeus laskee"
-> ainakaan pikakatsauksella ei vaikuta siltä koska crank() kutsutaan vain starting- tilassa. Tietysti jos startin aikana kierrokset laskevat niin sitten kyllä.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@ississ, jännite- ja virtamittauksiin ei ole ehty muutoksia. Tekoäly poisti ne kokonaan, mutta liitin takaisin ne. On kyllä tiedossa, kuten aiemminkin olet maininnut, ettei tuollainen virran ja jännitteen laskenta ole ihan optimaalisin ratkaisu. 
Yritin kyllä saada toimimaan sen map() -funktiolla tms. vastaavalla ja se ei harmi kyllä onnistunut. Tämä hieman tosiaankin varmaan turhan järeä systeemi kuitenkin on toiminut. Esim. tuo Pololun anturihan on 0 A ~ 0,5 V ja 150 A ~ 4 V.
Yritin kyllä saada toimimaan sen map() -funktiolla tms. vastaavalla ja se ei harmi kyllä onnistunut. Tämä hieman tosiaankin varmaan turhan järeä systeemi kuitenkin on toiminut. Esim. tuo Pololun anturihan on 0 A ~ 0,5 V ja 150 A ~ 4 V.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
Huhhuh, pakko laittaa koodi tänne, kun olen tehnyt siihen muutoksia. Pelkään, etten vain tee sille kohta "meisselihalvausta". 
Muutoksia:
-FAIL tilalle käyttöä, esim. ylijännite ja epäonnistunut käynnistys, mutta myös nyt kierroluvun tarkastelu. Lisäsin myös samalla tyylillä värinäanturin tarkastelun, mutta voi olla, että koko anturi jätetään pois, koska kierroslukuanturi tulee olemaan keskeinen tätä systeemiä käynnistyksen vuoksi.
-lcd:tä päivitetty
-käynnistysfunktiossa (crank()) puuttui ajastimen sammutus ja nollaus, mikäli jännite heilahtelee ylös. Tämä on hyvin todennäköinen tilanne. Hyvin näytti pelevaan simulaattorissa, vaikka tuossa nyt tulee tuo else -ehto, mutta käsittääkseni tuo switch-case -kombinaatio ehkäisee tuon ajamista koko ajan.
Ja seuraavana, jos koodi vielä toimii, tulisi testata vielä fyysisesti skoopilla PWM sekä releet. Releet pitää käskyttää niin (HIGH/LOW), että sytytysvirtarele ei johda, kun sille ei anneta käskyä ja starttireleen ei myöskään johda, ku sitä ei käskytetä. Toki releestä voi vaihtaa nuo kummin päin vaan. Pitää vaan varmistua, ettei myöskään koodissa ole mitään ristiriitojen releiden ohjauksessa niin, että rele voisi jäädä väärään asentoon. Siltä se ei Arduino simulaattorin mukaan näytä, mikä on hyvä asia.
Muutoksia:
-FAIL tilalle käyttöä, esim. ylijännite ja epäonnistunut käynnistys, mutta myös nyt kierroluvun tarkastelu. Lisäsin myös samalla tyylillä värinäanturin tarkastelun, mutta voi olla, että koko anturi jätetään pois, koska kierroslukuanturi tulee olemaan keskeinen tätä systeemiä käynnistyksen vuoksi.
-lcd:tä päivitetty
-käynnistysfunktiossa (crank()) puuttui ajastimen sammutus ja nollaus, mikäli jännite heilahtelee ylös. Tämä on hyvin todennäköinen tilanne. Hyvin näytti pelevaan simulaattorissa, vaikka tuossa nyt tulee tuo else -ehto, mutta käsittääkseni tuo switch-case -kombinaatio ehkäisee tuon ajamista koko ajan.
Ja seuraavana, jos koodi vielä toimii, tulisi testata vielä fyysisesti skoopilla PWM sekä releet. Releet pitää käskyttää niin (HIGH/LOW), että sytytysvirtarele ei johda, kun sille ei anneta käskyä ja starttireleen ei myöskään johda, ku sitä ei käskytetä. Toki releestä voi vaihtaa nuo kummin päin vaan. Pitää vaan varmistua, ettei myöskään koodissa ole mitään ristiriitojen releiden ohjauksessa niin, että rele voisi jäädä väärään asentoon. Siltä se ei Arduino simulaattorin mukaan näytä, mikä on hyvä asia.
C++:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>
// System status variables
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5
#define STOPPING 6
// Pin definitions
const int currentPin = A0;
const int voltagePin = A2;
const int motorPin = 2;
const int pwmPin = 9;
const int relayPin = 4;
const int rpmPin = 11;
const int starterPin = 3;
// Timers
Neotimer motorTime = Neotimer(10000); // 10 seconds for startup detection
Neotimer stepTime = Neotimer(1000); // 1 second for PWM step interval
Neotimer shutTime = Neotimer(15000); // 15 seconds for engine shutdown
Neotimer crankTime = Neotimer(4000); // 4 seconds for cranking
Neotimer crankWait = Neotimer(5000); // 5 seconds wait after failed crank
Neotimer voltageWait = Neotimer(10000); // 10 seconds wait for undervoltage
Neotimer sensorTime = Neotimer(5000); // 5 seconds check time for vibration sensor condition on RUNNNING status
// LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Variables
int motorStatus = WAITING;
int startTry = 0;
int startInterval = 0; // Waiting time on after start attempt
int currentPwmStep = 0;
int pwmValues[] = { 32, 64, 96, 128 }; // PWM steps
// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00; // Factor to convert ADC reading to voltage
// Define the points for current calculation / the line equation
float x1 = 0.500; // volts
float y1 = 0; // amps
float x2 = 4.005; // volts
float y2 = 150; // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1; // Variable to shift the whole current level
float sensVfactor = 20.00 / 4.9248; // 4.9248 volts = 20 volts, factor to convert high voltage to 0-5 V
const int N = 25; // Number of current readings to average
const int Y = 25; // Number of sensed voltage readings to average
int readings[N]; // Array to store the current readings
int readingsV[Y]; // Array to store the sensed voltage readings
float sensVoltage = 12.0; // Example voltage
float current = 0.0; // Example current
//RPM Calculation
int rpm = 0; //unsigned long rpm = 0;
unsigned long duration; // Sensor pulse in duration
void setup() {
Serial.begin(250000);
// Change timers on pins to change PWM freq to 122 Hz
// Pins D9 and D10 - 122 Hz
TCCR1A = 0b00000001; // 8bit
TCCR1B = 0b00000100; // x256 phase correct
// Initialize I2C and check if LCD is connected
Wire.begin();
Wire.beginTransmission(0x27);
if (Wire.endTransmission() == 0) {
// LCD is connected, proceed with initialization
lcd.begin(16, 2);
lcd.backlight();
lcd.clear();
} else {
// LCD is not connected, continue without initializing the LCD
Serial.println("LCD not connected. Skipping.");
}
// Pin modes
pinMode(currentPin, INPUT);
pinMode(voltagePin, INPUT);
pinMode(motorPin, INPUT_PULLUP);
pinMode(pwmPin, OUTPUT);
pinMode(relayPin, OUTPUT);
pinMode(rpmPin, INPUT_PULLUP);
pinMode(starterPin, OUTPUT);
analogWrite(pwmPin, 255); // Start with PWM off
}
void motorCrankState() {
if (sensVoltage < 11.9 && motorStatus == WAITING) {
if (!voltageWait.started()) {
voltageWait.start();
}
if (voltageWait.done()) {
motorStatus = STARTING;
digitalWrite(relayPin, HIGH);
voltageWait.stop();
voltageWait.reset();
}
} else {
voltageWait.stop();
voltageWait.reset();
}
}
void crank() {
if (startTry < 5 && startInterval == 0) {
if (rpm <= 300) {
digitalWrite(starterPin, HIGH);
if (!crankTime.started()) {
crankTime.start();
}
if (crankTime.done()) {
digitalWrite(starterPin, LOW);
crankTime.stop();
crankTime.reset();
startTry++;
startInterval = 1;
}
} else if (rpm > 300) {
digitalWrite(starterPin, LOW);
startTry = 0;
motorStatus = STARTED;
crankTime.stop();
crankTime.reset();
}
}
}
void Waiter() {
if (startInterval == 1) {
if (!crankWait.started()) {
crankWait.start();
}
if (crankWait.done()) {
startInterval = 0;
crankWait.stop();
crankWait.reset();
}
}
}
void motorRunning() {
if ((rpm > 1800 || digitalRead(motorPin) == HIGH) && motorStatus == STARTED) {
if (!motorTime.started()) {
motorTime.start();
}
if (motorTime.done()) {
motorStatus = RAMP_UP;
motorTime.stop();
motorTime.reset();
}
}
}
void rampUp() {
if (stepTime.repeat()) {
analogWrite(pwmPin, pwmValues[currentPwmStep]);
currentPwmStep++;
if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {
motorStatus = RUNNING;
stepTime.stop();
stepTime.reset();
}
}
}
void shutDown() {
if (current < 5 && motorStatus == RUNNING) {
digitalWrite(relayPin, LOW); // Turn off the ignition relay
analogWrite(pwmPin, 15); // Set PWM to 5% (reduce alternator load)
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
motorStatus = WAITING; // Revert to WAITING state
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
}
}
void failState() { // Handle failed start attempts, overvoltage etc.
if (startTry == 5) { // Failed start
motorStatus = FAIL;
digitalWrite(starterPin, LOW); // Starter relay off
digitalWrite(relayPin, LOW); // Ignition switch relay off
lcd.setCursor(0, 0); // On lcd print "Engine start failed"
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistys ");
lcd.setCursor(0, 1);
lcd.print("ep");
lcd.print((char)0xe1);
lcd.print("onnistui ");
} else if (sensVoltage >= 15) { // Overvoltage
motorStatus = FAIL;
digitalWrite(relayPin, LOW);
lcd.setCursor(0, 0); // On lcd print "Overvoltage"
lcd.print("Ylij");
lcd.print((char)0xe1);
lcd.print("nnite ");
lcd.setCursor(0, 1);
lcd.print(" ");
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
} else if ((rpm <= 900 || rpm >= 3700) && motorStatus == RUNNING) { // RPM sensor
motorStatus = FAIL;
digitalWrite(relayPin, LOW);
lcd.setCursor(0, 0); // On lcd print "Faulty rpm"
lcd.print("Kierrosluku ");
lcd.setCursor(0, 1);
lcd.print("virheellinen ");
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
// } else if (motorStatus == RUNNING) { // Vibration sensor
// if (digitalRead(motorPin) == LOW) {
// if (!sensorTime.started()) {
// sensorTime.start(); // Start the sensor blackout timer
// }
// if (sensorTime.done()) {
// motorStatus = FAIL;
// analogWrite(pwmPin, 255);
// lcd.setCursor(0, 0); // On lcd print "Faulty vibration signal"
// lcd.print("Virheellinen");
// lcd.setCursor(0, 1);
// lcd.print("V");
// lcd.print((char)0xe1);
// lcd.print("rin");
// lcd.print((char)0xe1);
// lcd.print("signaali");
// lcd.print(" ");
// sensorTime.stop();
// sensorTime.reset();
// }
// } else { // If signal reverts to normal during the time, stop timer
// sensorTime.stop();
// sensorTime.reset();
}
}
//}
void lcdDisplay() {
if (motorStatus == RUNNING) {
lcd.setCursor(0, 0);
lcd.print("Virta: ");
lcd.print(current);
lcd.print(" A ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
} else if (motorStatus == WAITING || motorStatus == STARTING) {
lcd.setCursor(0, 0);
lcd.print("Odottaa... ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
}
}
void loop() {
// Calculate current from sensor reading
// Calculate the charging current from the average and display it on the LCD screen.
// Take N readings and store them in the array
// for (int i = 0; i < N; i++) {
// readings[i] = analogRead(currentPin);
// delay(1); //Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sum = 0;
// for (int i = 0; i < N; i++) {
// sum += readings[i];
// }
// float average = sum / N;
// float voltage = average * voltageFactor; // Convert ADC reading to voltage
// current = (m * voltage + b) * currentCal; // Convert voltage to current using the linear equation, correct with current calibration value if needed
// Calculate high voltage from voltage divider input
// Calculate the charging voltage from the average and display it on the LCD screen.
// Take Y readings and store them in the array
// for (int j = 0; j < Y; j++) {
// readingsV[j] = analogRead(voltagePin);
// delay(1); // Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sumV = 0;
// for (int j = 0; j < Y; j++) {
// sumV += readingsV[j];
// }
// float averageV = sumV / Y;
// float voltageV = averageV * voltageFactor; // Convert ADC reading to voltage
// sensVoltage = voltageV * sensVfactor; // Convert voltage to real voltage
// RPM Calculation from Hall Sensor input
// {
// duration = pulseIn(rpmPin, FALLING, 500000); // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
// rpm = 60000.0 / duration * 1000; // See above
// }
// Simulate sensor readings via Serial input
if (Serial.available() > 0) {
char input = Serial.read();
switch (input) {
case '1':
rpm = 0;
break;
case '2':
rpm = 500;
break;
case '3':
rpm = 2000;
break;
case 'a':
current = 2;
break;
case 'b':
current = 20;
break;
case 'c':
current = 80;
break;
case 'z':
sensVoltage = 11;
break;
case 'x':
sensVoltage = 14;
break;
case 'y':
sensVoltage = 16;
break;
default:
Serial.println("Invalid input.");
return;
}
}
// Handle motor status
switch (motorStatus) {
case WAITING:
motorCrankState();
break;
case STARTING:
crank();
Waiter();
break;
case STARTED:
motorRunning();
break;
case RAMP_UP:
rampUp();
break;
case RUNNING:
shutDown();
break;
}
lcdDisplay();
failState();
// Debug output
Serial.print("Voltage: ");
Serial.print(sensVoltage);
Serial.print(" V, Current: ");
Serial.print(current);
Serial.print(" A, RPM: ");
Serial.print(rpm);
Serial.print(", Status: ");
Serial.println(motorStatus);
}
Viimeksi muokattu:
Huhhuh, pakko laittaa koodi tänne, kun olen tehnyt siihen muutoksia. Pelkään, etten vain tee sille kohta "meisselihalvausta".
Muutoksia:
-FAIL tilalle käyttöä, esim. ylijännite ja epäonnistunut käynnistys, mutta myös nyt kierroluvun tarkastelu. Lisäsin myös samalla tyylillä värinäanturin tarkastelun, mutta voi olla, että koko anturi jätetään pois, koska kierroslukuanturi tulee olemaan keskeinen tätä systeemiä käynnistyksen vuoksi.
-lcd:tä päivitetty
-käynnistysfunktiossa (crank()) puuttui ajastimen sammutus ja nollaus, mikäli jännite heilahtelee ylös. Tämä on hyvin todennäköinen tilanne. Hyvin näytti pelevaan simulaattorissa, vaikka tuossa nyt tulee tuo else -ehto, mutta käsittääkseni tuo switch-case -kombinaatio ehkäisee tuon ajamista koko ajan.
Ja seuraavana, jos koodi vielä toimii, tulisi testata vielä fyysisesti skoopilla PWM sekä releet. Releet pitää käskyttää niin (HIGH/LOW), että sytytysvirtarele ei johda, kun sille ei anneta käskyä ja starttireleen ei myöskään johda, ku sitä ei käskytetä. Toki releestä voi vaihtaa nuo kummin päin vaan. Pitää vaan varmistua, ettei myöskään koodissa ole mitään ristiriitojen releiden ohjauksessa niin, että rele voisi jäädä väärään asentoon. Siltä se ei Arduino simulaattorin mukaan näytä, mikä on hyvä asia.
switch-case on loogisesti sama kuin if () else if () else if () jne.
Releet pitää kytkeä niin että käynnistettäessä ne ovat siinä tilassa jossa pitää ollakin ilman että käännetään setup- funktiossa "oletustilaan".
Eli todennäköisesti sammutusrele pitää moottorin sammuneena ja käynnistysrele on irti. Näin tehden moottori sammuu jos arduinolta lähtee sähköt joka vastaa tietysti virrat laitetaan päälle tilannetta.
Ja muista että releessä on kytkentäviive, yleisesti joku 100-200ms on turvallinen oletus mutta riippuu releestä.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
Testailin koodia nyt kortin kanssa, vielä releet on testaamatta ja muuten koko hössäkkä 12 voltin virtalähteellä. Toivotaan, ettei tule mitään yllätyksiä enää, mutta hyvältä näyttää.
PWM näytti skoopilla toimivan täysin oikein, joskin kerran onnistuin tekemään niin, ettei PWM lähtenyt nousemaan. En saanut toistettua sitä, mutta johtui varmaan liian äkäisistä komennoista, eikä käytännön toteutuksessa voi esiintyä esim. kierrosten hyppäämistä nollasta 500:een r/min millisekunneissa ja koodissahan on ylijännitesuojakin.
Tein vähän pienimuotoisia muutoksia taas, esim. lcd on nyt keskitetty täysin omaan funktioonsa. On ne vaan käteviä nuo #define -makrot tässäkin, mutta onko niiden käytöllä jotain miinuspuolia?
PWM näytti skoopilla toimivan täysin oikein, joskin kerran onnistuin tekemään niin, ettei PWM lähtenyt nousemaan. En saanut toistettua sitä, mutta johtui varmaan liian äkäisistä komennoista, eikä käytännön toteutuksessa voi esiintyä esim. kierrosten hyppäämistä nollasta 500:een r/min millisekunneissa ja koodissahan on ylijännitesuojakin.
Tein vähän pienimuotoisia muutoksia taas, esim. lcd on nyt keskitetty täysin omaan funktioonsa. On ne vaan käteviä nuo #define -makrot tässäkin, mutta onko niiden käytöllä jotain miinuspuolia?
C++:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>
// System status variables
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5
// Fail state LCD display
#define FAILED_START 1
#define OVERVOLTAGE 2
#define FAILED_RPM 3
#define FAILED_VIBSENSOR 4
// Pin definitions
const int currentPin = A0;
const int voltagePin = A2;
const int motorPin = 2;
const int pwmPin = 9;
const int relayPin = 4;
const int rpmPin = 11;
const int starterPin = 3;
// Timers
Neotimer motorTime = Neotimer(10000); // 10 seconds for startup detection
Neotimer stepTime = Neotimer(1000); // 1 second for PWM step interval
Neotimer shutTime = Neotimer(15000); // 15 seconds for engine shutdown
Neotimer crankTime = Neotimer(4000); // 4 seconds for cranking
Neotimer crankWait = Neotimer(5000); // 5 seconds wait after failed crank
Neotimer voltageWait = Neotimer(10000); // 10 seconds wait for undervoltage
Neotimer sensorTime = Neotimer(5000); // 5 seconds check time for vibration sensor condition on RUNNNING status
// LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Variables
int motorStatus = WAITING;
int startTry = 0;
int startInterval = 0; // Waiting time on after start attempt
int currentPwmStep = 0;
int pwmValues[] = { 15, 53, 91, 129 }; // PWM steps
int lcdFail = 0; // LCD fail state display
// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00; // Factor to convert ADC reading to voltage
// Define the points for current calculation / the line equation
float x1 = 0.500; // volts
float y1 = 0; // amps
float x2 = 4.005; // volts
float y2 = 150; // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1; // Variable to shift the whole current level
float sensVfactor = 20.00 / 4.9248; // 4.9248 volts = 20 volts, factor to convert high voltage to 0-5 V
const int N = 25; // Number of current readings to average
const int Y = 25; // Number of sensed voltage readings to average
int readings[N]; // Array to store the current readings
int readingsV[Y]; // Array to store the sensed voltage readings
float sensVoltage = 12.0; // Example voltage
float current = 0.0; // Example current
//RPM Calculation
int rpm = 0; //unsigned long rpm = 0;
unsigned long duration; // Sensor pulse in duration
void setup() {
Serial.begin(250000);
// Change timers on pins to change PWM freq to 122 Hz
// Pins D9 and D10 - 122 Hz
TCCR1A = 0b00000001; // 8bit
TCCR1B = 0b00000100; // x256 phase correct
// Initialize I2C and check if LCD is connected
Wire.begin();
Wire.beginTransmission(0x27);
if (Wire.endTransmission() == 0) {
// LCD is connected, proceed with initialization
lcd.begin(16, 2);
lcd.backlight();
lcd.clear();
} else {
// LCD is not connected, continue without initializing the LCD
Serial.println("LCD not connected. Skipping.");
}
// Pin modes
pinMode(currentPin, INPUT);
pinMode(voltagePin, INPUT);
pinMode(motorPin, INPUT_PULLUP);
pinMode(pwmPin, OUTPUT);
pinMode(relayPin, OUTPUT);
pinMode(rpmPin, INPUT_PULLUP);
pinMode(starterPin, OUTPUT);
analogWrite(pwmPin, 255); // Start with PWM off
}
void motorCrankState() {
if (sensVoltage < 11.9 && motorStatus == WAITING) {
if (!voltageWait.started()) {
voltageWait.start();
}
if (voltageWait.done()) {
motorStatus = STARTING;
digitalWrite(relayPin, HIGH); // Relay on
voltageWait.stop();
voltageWait.reset();
}
} else {
voltageWait.stop();
voltageWait.reset();
}
}
void crank() {
if (startTry < 5 && startInterval == 0) {
if (rpm <= 300) { // If motor runs slower than this, switch starter relay on
digitalWrite(starterPin, HIGH);
if (!crankTime.started()) {
crankTime.start();
}
if (crankTime.done()) { // If max cranking time finished without succeeding start, switch starter relay off
digitalWrite(starterPin, LOW);
crankTime.stop();
crankTime.reset();
startTry++;
startInterval = 1;
}
} else if (rpm > 300) { // If motor runs faster than this, switch starter relay off
digitalWrite(starterPin, LOW);
startTry = 0;
motorStatus = STARTED;
crankTime.stop();
crankTime.reset();
}
}
}
void Waiter() {
if (startInterval == 1) {
if (!crankWait.started()) {
crankWait.start();
}
if (crankWait.done()) {
startInterval = 0;
crankWait.stop();
crankWait.reset();
}
}
}
void motorRunning() {
if ((rpm > 1800 || digitalRead(motorPin) == HIGH) && motorStatus == STARTED) {
if (!motorTime.started()) {
motorTime.start();
}
if (motorTime.done()) {
motorStatus = RAMP_UP;
motorTime.stop();
motorTime.reset();
}
}
}
void rampUp() {
if (stepTime.repeat()) {
analogWrite(pwmPin, pwmValues[currentPwmStep]);
currentPwmStep++;
if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {
motorStatus = RUNNING;
stepTime.stop();
stepTime.reset();
}
}
}
void shutDown() {
if (current < 5 && motorStatus == RUNNING) {
digitalWrite(relayPin, LOW); // Turn off the ignition relay
analogWrite(pwmPin, 15); // Set PWM to 5% (reduce alternator load)
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
motorStatus = WAITING; // Revert to WAITING state
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
}
}
void failState() { // Handle failed start attempts, overvoltage etc.
if (startTry == 5) { // Failed start
motorStatus = FAIL;
digitalWrite(starterPin, LOW); // Starter relay off
digitalWrite(relayPin, LOW); // Ignition switch relay off
lcdFail = FAILED_START;
} else if (sensVoltage >= 15) { // Overvoltage
motorStatus = FAIL;
digitalWrite(relayPin, LOW); // Ignition relay off
lcdFail = OVERVOLTAGE;
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
} else if ((rpm <= 900 || rpm >= 3700) && motorStatus == RUNNING) { // RPM sensor
motorStatus = FAIL;
digitalWrite(relayPin, LOW); // Ignition relay off
lcdFail = FAILED_RPM;
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
// } else if (motorStatus == RUNNING) { // Vibration sensor
// if (digitalRead(motorPin) == LOW) {
// if (!sensorTime.started()) {
// sensorTime.start(); // Start the sensor blackout timer
// }
// if (sensorTime.done()) {
// motorStatus = FAIL;
// analogWrite(pwmPin, 15);
// lcd.setCursor(0, 0); // On lcd print "Faulty vibration signal"
// lcd.print("Virheellinen");
// lcd.setCursor(0, 1);
// lcd.print("V");
// lcd.print((char)0xe1);
// lcd.print("rin");
// lcd.print((char)0xe1);
// lcd.print("signaali");
// lcd.print(" ");
// sensorTime.stop();
// sensorTime.reset();
// }
// } else { // If signal reverts to normal during the time, stop timer
// sensorTime.stop();
// sensorTime.reset();
}
}
//}
void lcdDisplay() {
if (motorStatus == RUNNING || motorStatus == RAMP_UP) {
lcd.setCursor(0, 0);
lcd.print("Virta: ");
lcd.print(current);
lcd.print(" A ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
} else if (motorStatus == WAITING) {
lcd.setCursor(0, 0);
lcd.print("Odottaa... ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
} else if (motorStatus == STARTING || motorStatus == STARTED) {
lcd.setCursor(0, 0);
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistet");
lcd.print((char)0xe1);
lcd.print((char)0xe1);
lcd.print("n");
lcd.setCursor(0, 1);
lcd.print("................");
} else if (lcdFail == FAILED_START) {
lcd.setCursor(0, 0); // On lcd print "Engine start failed"
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistys ");
lcd.setCursor(0, 1);
lcd.print("ep");
lcd.print((char)0xe1);
lcd.print("onnistui ");
} else if (lcdFail == OVERVOLTAGE) {
lcd.setCursor(0, 0); // On lcd print "Overvoltage"
lcd.print("Ylij");
lcd.print((char)0xe1);
lcd.print("nnite ");
lcd.setCursor(0, 1);
lcd.print(" ");
} else if (lcdFail == FAILED_RPM) {
lcd.setCursor(0, 0); // On lcd print "Faulty rpm"
lcd.print("Kierrosluku ");
lcd.setCursor(0, 1);
lcd.print("virheellinen ");
}
}
void loop() {
// Calculate current from sensor reading
// Calculate the charging current from the average and display it on the LCD screen.
// Take N readings and store them in the array
// for (int i = 0; i < N; i++) {
// readings[i] = analogRead(currentPin);
// delay(1); //Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sum = 0;
// for (int i = 0; i < N; i++) {
// sum += readings[i];
// }
// float average = sum / N;
// float voltage = average * voltageFactor; // Convert ADC reading to voltage
// current = (m * voltage + b) * currentCal; // Convert voltage to current using the linear equation, correct with current calibration value if needed
// Calculate high voltage from voltage divider input
// Calculate the charging voltage from the average and display it on the LCD screen.
// Take Y readings and store them in the array
// for (int j = 0; j < Y; j++) {
// readingsV[j] = analogRead(voltagePin);
// delay(1); // Wait for a millisecond between readings
// }
// Calculate the average of the N readings
// float sumV = 0;
// for (int j = 0; j < Y; j++) {
// sumV += readingsV[j];
// }
// float averageV = sumV / Y;
// float voltageV = averageV * voltageFactor; // Convert ADC reading to voltage
// sensVoltage = voltageV * sensVfactor; // Convert voltage to real voltage
// RPM Calculation from Hall Sensor input
// {
// duration = pulseIn(rpmPin, FALLING, 500000); // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
// rpm = 60000.0 / duration * 1000; // See above
// }
// Simulate sensor readings via Serial input
if (Serial.available() > 0) {
char input = Serial.read();
switch (input) {
case '1':
rpm = 0;
break;
case '2':
rpm = 500;
break;
case '3':
rpm = 2000;
break;
case 'a':
current = 2;
break;
case 'b':
current = 20;
break;
case 'c':
current = 80;
break;
case 'z':
sensVoltage = 11;
break;
case 'x':
sensVoltage = 14;
break;
case 'y':
sensVoltage = 16;
break;
default:
Serial.println("Invalid input.");
return;
}
}
// Handle motor status
switch (motorStatus) {
case WAITING:
motorCrankState();
break;
case STARTING:
crank();
Waiter();
break;
case STARTED:
motorRunning();
break;
case RAMP_UP:
rampUp();
break;
case RUNNING:
shutDown();
break;
}
lcdDisplay();
failState();
// Debug output
Serial.print("Voltage: ");
Serial.print(sensVoltage);
Serial.print(" V, Current: ");
Serial.print(current);
Serial.print(" A, RPM: ");
Serial.print(rpm);
Serial.print(", Status: ");
Serial.print(motorStatus);
Serial.print(", Start try: ");
Serial.print(startTry);
Serial.print(", Start wait: ");
Serial.println(startInterval);
}
Viimeksi muokattu:
Hyvä että lähtee toimimaan.
Tässä miinuksia ei juuri ole.
Tietysti pitää keksiä aina sellaiset arvot joita ei ole käytetty muualla eli voi käydä niin että jossakin kirjastossa on jo määritettynä vaikka OK ja FAIL niin niitä ei sitten voi yliajaa. Kääntäjän pitäisi kyllä herjata jos on päällekkäisiä.
Ja tietysti jos tekee merkkijonoja tai monimutkaisempia juttuja niin voi joutua tyypittämään erikseen jne.
Itse ehkä käyttäisin samaa motorStatus- muuttujaa myös tuolla näytössä kaikille tiloille tai näytölle kokonaan omat tilat eikä kahta sekaisin.
Voit myös tehdä näin:
C++:
switch(muuttuja) {
case ARVO1:
// tehdään jotain
break;
case ARVO2:
case ARVO3:
// tehdään muuta
break;
default:
// "else"
break;
}If- rakenteena tuo olisi
C++:
if (muuttuja == ARVO1) {
// tehdään jotain
} else if ( (muuttuja == ARVO2) || (muuttuja == ARVO3)) {
// tehdään muuta
} else {
// "else"
}= jos ei ole break- määritystä niin switch juoksee case- kohtia läpi kunnes loppuu tai tulee break.
Yksi vaihtoehto on myös pilkkoa tuosta lcdDisplay:stä jokainen if-haara omaksi funktiokseen tyyliin lcdPrintStarting(), lcdPrintWaiting() jne. Niitä sitten kutsuttaisiin loopin switch casesta. Lyhyet funktiot on yleisesti helpompia hahmottaa ja debugata.
Näistä kohdista voisi ottaa tuon status-vertailun pois kokonaan.
Se on aina true, koska funktiota kutsutaan loopista vain silloin kun tila on oikea. Koodista tulee helppolukuisempaa, kun tuollaiset turhat ottaa pois.
Ja nuo pitkät kommentoidut koodinpätkät voisi myös ottaa tuolta pois, niin olisi helpompaa lueskella koodia, kun funktion mahtuu ruudulle kerralla.
Näistä kohdista voisi ottaa tuon status-vertailun pois kokonaan.
C:
if ((rpm > 1800 || digitalRead(motorPin) == HIGH) && motorStatus == STARTED)Ja nuo pitkät kommentoidut koodinpätkät voisi myös ottaa tuolta pois, niin olisi helpompaa lueskella koodia, kun funktion mahtuu ruudulle kerralla.
Viimeksi muokattu:
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@TemeV , minullekin jotenkin selkeämpi erilliset funktiot lukea eri asioille. Tässä tapauksessa tuota ei ehkä nyt ihan vielä aleta muokkaamaan siltä osin, nyt varmaankin pitää katsoa eteenpäin tuota rautapuolta!
Itse mietin myös, onko nuo motorStatus -vertailut switch-casen ansiosta tarpeellisia niiltä osin, kun ne on mainittuna siellä switch-casessa, näillä tiedoilla ilmeisesti ei tarvitse juuri esim. tuossa mainitsemassasi kohdassa tuota motorStatus == STARTED. Sama ilmeisesti koskee kaikkia niitä funktioita, jotka on mainittu switch-casessa ja niissä on vain toimintoja, joiden yhteinen ehto on tuo motorStatus.
Kommentoitu osuus on virran, jännitteen ja kierroslukuun laskentakoodi. On vain tuossa kommentoituna, koska testissä niitä ei tarvita. Otetaan käyttöön, kun käytetään todellisia antureita.
Itse mietin myös, onko nuo motorStatus -vertailut switch-casen ansiosta tarpeellisia niiltä osin, kun ne on mainittuna siellä switch-casessa, näillä tiedoilla ilmeisesti ei tarvitse juuri esim. tuossa mainitsemassasi kohdassa tuota motorStatus == STARTED. Sama ilmeisesti koskee kaikkia niitä funktioita, jotka on mainittu switch-casessa ja niissä on vain toimintoja, joiden yhteinen ehto on tuo motorStatus.
Kommentoitu osuus on virran, jännitteen ja kierroslukuun laskentakoodi. On vain tuossa kommentoituna, koska testissä niitä ei tarvita. Otetaan käyttöön, kun käytetään todellisia antureita.
Jos on switch-case (tai if lauseet) joista kutsutaan funktioita vain tietyssä tilassa niin silloin funktiossa ei tarvitse enää tarkastaa tilaa.
Tai jos haluaa olla varma ettei itse mokaa ja käytä funktiota väärässä paikassa niin alkuun voi laittaa ehdon tyyliin if (tila != SE_JOKA_PITÄISI_OLLA) return; (eli poistutaan heti paikalta jos tila oli väärä).
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No niin! Ekoja testejä raudalla, toki ei vielä laturin kanssa, mutta muuten. Koko systeemi toimii raudan osalta hyvin vaikka kytkettynä tietokoneeseen yhtaikaa.
Virranmittauksen saa varmaan kohdilleen ihan vaan kalibroimalla, mutta jännitteenmittauksessa on jotain häikkää, kun näyttää vain kaksi volttia. Oikea jännite olisi pitänyt olla vähän alle 12 V.
Pitää yrittää tutkia kytkentää voiko vastus olla väärin tai joku muu ongelma.
EDIT: Ja tarkisin jännitteenjakajan laskurilla ja Arduinon pinnille tulevan jännitteen 11,2 voltilla ja sehän oli noin 2,8 volttia, eli täsmälleen oikein. Tämän iso helpotus, koska vika on vain koodillinen. Huh huh!
Eli jännite kun on 11,22 volttia niin Arduinolle tulee 2,76 volttia. Se kääntyisi muotoon 20 / 4,9197, mutta tuloksena on vain hieman yli 2 volttia? Aiemmin tuo koodi kyllä laski tuon jännitteen ihan oikein.
EDIT 2: PWM näyttää myös toimivan ainakin suurimmalta osin oikein "korkeajännitteellä", piiri toimii, koodia pitää varmaan muokata. Onnistuin saamaan PWM jäämään ylhäälle vaikka vikatilan olisi pitänyt se shutTimen jälkeen ajaa maksimiin.
Lisäksi huomaan, että releiden toiminta aiheuttaa melkoisia piikkejä pulssilähtöön kuten kuvasta näkyy.
Virranmittauksen saa varmaan kohdilleen ihan vaan kalibroimalla, mutta jännitteenmittauksessa on jotain häikkää, kun näyttää vain kaksi volttia. Oikea jännite olisi pitänyt olla vähän alle 12 V.
Pitää yrittää tutkia kytkentää voiko vastus olla väärin tai joku muu ongelma.
EDIT: Ja tarkisin jännitteenjakajan laskurilla ja Arduinon pinnille tulevan jännitteen 11,2 voltilla ja sehän oli noin 2,8 volttia, eli täsmälleen oikein. Tämän iso helpotus, koska vika on vain koodillinen. Huh huh!
Eli jännite kun on 11,22 volttia niin Arduinolle tulee 2,76 volttia. Se kääntyisi muotoon 20 / 4,9197, mutta tuloksena on vain hieman yli 2 volttia? Aiemmin tuo koodi kyllä laski tuon jännitteen ihan oikein.
EDIT 2: PWM näyttää myös toimivan ainakin suurimmalta osin oikein "korkeajännitteellä", piiri toimii, koodia pitää varmaan muokata. Onnistuin saamaan PWM jäämään ylhäälle vaikka vikatilan olisi pitänyt se shutTimen jälkeen ajaa maksimiin.
Lisäksi huomaan, että releiden toiminta aiheuttaa melkoisia piikkejä pulssilähtöön kuten kuvasta näkyy.
Viimeksi muokattu:
No niin! Ekoja testejä raudalla, toki ei vielä laturin kanssa, mutta muuten.
Virranmittauksen saa varmaan kohdilleen ihan vaan kalibroimalla, mutta jännitteenmittauksessa on jotain häikkää, kun näyttää vain kaksi volttia. Oikea jännite olisi pitänyt olla vähän alle 12 V.
Pitää yrittää tutkia kytkentää voiko vastus olla väärin tai joku muu ongelma.
EDIT: Ja tarkisin jännitteenjakajan laskurilla ja Arduinon pinnille tulevan jännitteen 11,2 voltilla ja sehän oli noin 2,8 volttia, eli täsmälleen oikein. Tämän iso helpotus, koska vika on vain koodillinen. Huh huh!
Eli jännite kun on 11,22 volttia niin Arduinolle tulee 2,76 volttia. Se kääntyisi muotoon 20 / 4,9197, mutta tuloksena on vain hieman yli 2 volttia? Aiemmin tuo koodi kyllä laski tuon jännitteen ihan oikein.
Onko koodissa tuo 20 / 4.9197 ?
Ja jos et laittanut desimaaleja niin se saattaa oikeasti ollakin 20 / 5... kääntäjä kun arvailee datatyyppejä vakioiden perusteella ja yleensä ottaa ensimmäisestä.
eli jos tuota käyttää kertoimena niin oikein olisi:
float kerroin = 20.0 / 4.9197;
Ja kannattaa nyt laittaa tähän vielä se koodikin jolla nuo mitataan ja lasketaan, muuten ei voi kuin arvata.
Jos mukana on vielä ne x1, yms huuhaa- laskennat niin varmaan onkin pielessä. Pois vaan kaikki turha niin saa helpommin oikein.
Virran mittauksessa voi varmaan tehdä niin että käynnistettäessä mittaa ensin virran muutamaan kertaan jolloin pitäisi saada ns. 0- arvo. Se tallennetaan muuttujaan ja oikeassa mittauksessa 0-arvo vähennetään ensimmäiseksi ja sen jälkeen vaan kerrotaan mitattu arvo kertoimella kuntoon. Tämä sillä oletuksella että alussa virta on oikeasti 0 kun latausta ei ole (eikä kulutusta laturin kautta).
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@ississ , olin turhan hätäinen! 
Problemo oli, kun koodiin oli jäänyt A2 pinni jännitteen tulolle, kun piti olla A3. Ja alkoi toimia muutaman sadasosavolttien erolla yleismittariin. Se oli sitten siinä.
Pieniä fiksauksia varmaankin tarvitaan vielä koodiin sinne tänne, mutta ei nyt ihan heti.
Tässä vielä nämä kuvat uudestaan kerkesin ed. viestiin jo laittaa näitä. Ehkä vähän huolestuttaa tuo säkkärä releiden toimiessa. Jos laturi käynnistyykin lataaman korkealla pulssitaajuudella? Ehkä ei ole niin herkkä.
Problemo oli, kun koodiin oli jäänyt A2 pinni jännitteen tulolle, kun piti olla A3. Ja alkoi toimia muutaman sadasosavolttien erolla yleismittariin. Se oli sitten siinä.
Pieniä fiksauksia varmaankin tarvitaan vielä koodiin sinne tänne, mutta ei nyt ihan heti.
Tässä vielä nämä kuvat uudestaan kerkesin ed. viestiin jo laittaa näitä. Ehkä vähän huolestuttaa tuo säkkärä releiden toimiessa. Jos laturi käynnistyykin lataaman korkealla pulssitaajuudella? Ehkä ei ole niin herkkä.
@ississ , olin turhan hätäinen!
Problemo oli, kun koodiin oli jäänyt A2 pinni jännitteen tulolle, kun piti olla A3. Ja alkoi toimia muutaman sadasosavolttien erolla yleismittariin. Se oli sitten siinä.
Pieniä fiksauksia varmaankin tarvitaan vielä koodiin sinne tänne, mutta ei nyt ihan heti.
Tässä vielä nämä kuvat uudestaan kerkesin ed. viestiin jo laittaa näitä. Ehkä vähän huolestuttaa tuo säkkärä releiden toimiessa. Jos laturi käynnistyykin lataaman korkealla pulssitaajuudella? Ehkä ei ole niin herkkä.
Tuo väärän tulon käyttäminen selittää myös, hyvä että löytyi.
Silti ottaisin koodista pois ne epämääräiset laskennat (ja jos on edelleen 2 peräkkäistä for- looppia niin ne voisi yhdistää).
Huolestuttavuus riippuu mistä tuo on mitattu.
Jos relemoduuleissa ei ole suojadiodeja niin lisää sellaiset. Releen vedosta/päästöstä tulee aina piikki, sen suuruus riippuu releen kelasta, syöttöjohdinten pituudesta, relettä ohjaavan transistorin/fetin nopeudesta, jännitteestä jne.
Mä oon ollu siinä uskossa jos microcontrollereilla ajetaan releitä aina pitäisi olla diodi suojaamassa lähtöä kun aina kun releeltä katkeaa virta magneettikentän romahtaessa tulee jännite piikki yleensä kyllä valmiissa relemoduuleissa on diodi suojana.
Jännästi valittu kytkentä... jos releen kela on 12V niin tuo 12V zener on turha. Ja vaikka se siinä olisikin niin suojadiodi (se toinen) pitäisi olla suoraan kelan rinnalla.
Tai niin se on ollut kaikissa tähän mennessä vastaan tulleissa.
Huomasithan virheen tuossa hall- lauseessa?
Sisäinen pullup on ylösveto, ei alas.
Jos anturi tarvitsee ylösvedon niin kannattaa laittaa erillinen.
Datalehti todennäköisesti kertoo onko sen arvolle suosituksia ja myös sen paljonko se anturin ajuri kestää eli siitä saa minimiarvon.
Anturin käyttöjännitteeseen voi laittaa konkan anturin lähelle jos johdot ovat pitkät.
Diodi kuuluisi joo suoraan kelan rinnalle. Tuo zeneri tekee nyt vain sen, että kelan jännite hyppää jännitteseen vdd+12V+diodin kynnys sen sijaan että olisi vain sen vdd+diodin kynnys. Eli todennäköisesti pahentaa säteilyä mikä siitä kelasta kytkentähetkellä tulee.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@ississ ja @TemeV , no niin, hyviä tietoja. Eli jos tulee probleemaa niin joutunee tuon kortin puukottamaan joten kuten saadakseen kytkentäpisteen diodille, ellei onnistuu suoraan lähtöihin, mikäli diodista olisi apua. Jotenkin sitä uskoisi, että valmismoduuleissa olisi näitä ajateltu, vielä kun nämä olivat kalliimpia ja robotiikkaprojekteihin ajateltu, joissa varmasti on PWM-säätöjä. Enpä osaa sanoa, miten lataussäädin reagoi tämmöisiin, meneekö peräti nollaan asti nuo pahimmat piikit. Aika huolestuttavaa, jos toimii noin, että tuossakin esimerkkikuvassa on pulssinleveys n. 90 % joka tekisi pahaa jälkeä, jos lataussäädin sitä tottelisi. Mutta toisaaltahan systeemi pukkaa koko ajan sitä oikeaa pulssia, ja nuo säkkärät esiintyvät vain releiden toimiessa, joten luulisi lopulta niide hyppyjen jäävän olemattomiksi lopputulokseen?
Mutta eihän tuo tietenkään hyvä ole, varsinkin kun tuli ilmi vasta tässä vaiheessa. Jälkiviisaana, hyvä olisi ollut irrallaan testata relettä, tai jotain.
Mutta eihän tuo tietenkään hyvä ole, varsinkin kun tuli ilmi vasta tässä vaiheessa. Jälkiviisaana, hyvä olisi ollut irrallaan testata relettä, tai jotain.
Kyllä tuo zeneri on ihan mahdollinen ja joissain tapauksissa järkeväkin kytkennässä. Pelkkä diodi hidastaa releen päästämistä ja lisää todennäköisyyttä kärkien tarttumisen kiinni. Releen näkökulmasta parasta olisi jos diodia ei olisi ollenkaan, mutta se taas ei ole oikein hyvä muulle elektroniikalle. Tuo zener+diodi on kompromissi näiden väliltä.
Mutta tuolle zenerille on kyllä harvoin oikeasti tarvetta ja pelkkä diodi on tosiaan häiriöiden kannalta parempi vaihtoehto.
Tuossa pdf:ssä TE:n näkemystä asiaan: https://www.te.com/commerce/Documen...v&DocNm=13C3264_AppNote&DocType=CS&DocLang=EN
En ihan kuvasta hahmottanut että mitä tuossa edes mitattiin ja miten skooppi on kytketty. Ei välttämättä ole ollenkaan todellinen häiriö, vaan voi olla kytkeytynyt vain niihin mittauskaapeleihin.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@TemeV , joo eli skooppi oli kytketty kuten lopullisessa systeemissä tulee olemaan, eli 12 V:n piiriin. Käynnistymisessä laturin säätimelle menee puhdas jännite (PWM 100 %), joka pitää laturin sähkömagneetin poissa päältä. Lataussäätimessä on muisti, joka nollautuu aina, kun koko järjestelmä kytketään pois päältä. Tämä mahdollistaa käynnistämisen ilman sähkömagneetin vastusta ja kun moottori on pysähtynyt, voidaan PWM ajaa taas puhtaaksi, jolloin sähkömagneetti menee pois päältä. Fordin lataussäätimen ominaisuuksia.
Kun systeemi käynnistetään (virrat päälle), ajetaan laturille 100 %. Vaikka nyt laturi pyörisi täysillä, laturi ei lataa. Tämä vaatii sen, että PWM muuttuu 100 %:sta. Mutta laturin muistin ansiosta, nyt jos sille onkin ajettu vaikkapa 5 % ja sitten taas 100 %, menee laturi täysille. Siis latausjännite säätyy 16 volttiin. Ymmärsiköhän tästä Fordin laturin sielunelämää edes jonkin verran? Koin, että pitää tähän väliin vähän selittää tätä, kun seuraava ajatus tuli mieleheeni.
Eli näen tuossa aika suurenkin riskin loppujen lopuksi ylijännitteelle. Toki ylijännitekoodi suojaisi siltä, mutta eihän se tulisi toimimaan, jos ohjelma menisi vikatilaan. Eli jos 100 %:n jälkeen nyt tulee noita säkkäröitä kun starttirele irrottaa, käy pulssi sattumalta esim. 70 %:ssa. Tämä vastaa jo aika korkeaa jännitettä, mutta punchline tulee siinä, kun säätimelle syötetään puhdasta jännitettä aina RAMP_UP tilaan saakka. Tämä hetki käynnistymisen ja RAMP_UP:n välillä on riskaabeli. Voisi olla mahdollista, että latausjännite nousisi 16 volttiin.
Onkohan diodi pakko laittaa jo ennakoivasti? Tuskin se niin kauheaa olisi, jos juotos relemoduulin juotoksiin onnistuu?
Kun systeemi käynnistetään (virrat päälle), ajetaan laturille 100 %. Vaikka nyt laturi pyörisi täysillä, laturi ei lataa. Tämä vaatii sen, että PWM muuttuu 100 %:sta. Mutta laturin muistin ansiosta, nyt jos sille onkin ajettu vaikkapa 5 % ja sitten taas 100 %, menee laturi täysille. Siis latausjännite säätyy 16 volttiin. Ymmärsiköhän tästä Fordin laturin sielunelämää edes jonkin verran? Koin, että pitää tähän väliin vähän selittää tätä, kun seuraava ajatus tuli mieleheeni.
Eli näen tuossa aika suurenkin riskin loppujen lopuksi ylijännitteelle. Toki ylijännitekoodi suojaisi siltä, mutta eihän se tulisi toimimaan, jos ohjelma menisi vikatilaan. Eli jos 100 %:n jälkeen nyt tulee noita säkkäröitä kun starttirele irrottaa, käy pulssi sattumalta esim. 70 %:ssa. Tämä vastaa jo aika korkeaa jännitettä, mutta punchline tulee siinä, kun säätimelle syötetään puhdasta jännitettä aina RAMP_UP tilaan saakka. Tämä hetki käynnistymisen ja RAMP_UP:n välillä on riskaabeli. Voisi olla mahdollista, että latausjännite nousisi 16 volttiin.
Onkohan diodi pakko laittaa jo ennakoivasti? Tuskin se niin kauheaa olisi, jos juotos relemoduulin juotoksiin onnistuu?
siis mun mielestä se piikki ei tule sinne kuorma puolelle vaan siihen vetokäämiin tietty voihan se räpsy skoopissa näkyä mutten uskoisi että se laturi sitä pwm signaaliksi luulee kun auto muutenkin aika häiriöistä aluetta siellä konehuoneessa. periaatteessa sitten viallinen tulppa tahi tulpan johto räpsisi sitä lataussäädintä suuntaan jos toiseenkin. ainakin itse olen ollut siinä luulossa että jos relettä ajaa microcontrollerilla niin ilman suoja diodia se microcontrolleri on äkkiä entinen kun releen irrottasessa sinne pinniin tulee mahdollisesti monen sadan voltin jännite piikki.
Sen Arduinon jännitemittauksissa yms saattaa näkyä häiriöitä releiden kytkemisestä. Jos niin käy, niin sitä voi sitten suodattaa. En kanssa usko että se laturi siitä häiriintyisi. Kuvittelisin sen olevan suhteellisen matalaimpedanssinen inputti, joten ei se ihan pienestä pitäisi häiriintyä.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No joo, eiköhän se relehomma järjesty.
Tossa olisi tuo RPM-anturiksi ajateltu hall-sensori ja datasheetiltä esimerkkikytkentä, jos oikein osaan datalehtiä selata.
Eli toista kiloa vastus plussan ja signaalin väliin ja 4,7 nF:n konkat maan molemmin puolin?
Tossa olisi tuo RPM-anturiksi ajateltu hall-sensori ja datasheetiltä esimerkkikytkentä, jos oikein osaan datalehtiä selata.
Eli toista kiloa vastus plussan ja signaalin väliin ja 4,7 nF:n konkat maan molemmin puolin?
Tuon te dokkarin mukaan näyttäisi olevan 12V rele ja 24V zener, tuossa moduulissa 12V zener viittaa varmaan siihen että on valittu jännitekestoltaan turhan pieni kytkinfetti. En jaksanut tarkastaa datalehdestä...
Oliko tuosta kokonaisuudesta piirretty kaaviota jossa on mukana myö laturin ja releiden kytkennät ?
Helpottaisi kovasti.
Lähinnä se mistä laturin syöttö tulee ja sen myötä pwm nollaus.
Ja piste josta mittasit skoopilla...
Eipä se diodi paha ole laittaa, juottaa vaan levyn alapuolelle suoraan releen nastoihin. Kokeilisin ensin noin kun se nyt on, tietysti mittapiste pitäisi tietää ensin.
No joo, eiköhän se relehomma järjesty.
Tossa olisi tuo RPM-anturiksi ajateltu hall-sensori ja datasheetiltä esimerkkikytkentä, jos oikein osaan datalehtiä selata.
Eli toista kiloa vastus plussan ja signaalin väliin ja 4,7 nF:n konkat maan molemmin puolin?
Tuota kytkentää kannattaa käyttää koska sellainen on annettu.
Vcc- linjaan voi laittaa rauhassa isommankin, signalissa isompi hidastaa nousunopeutta eli yleensä ei hyvä.
Laskemalla vastuksella ja konkalla tietysti selviää onko vaikutusta sillä taajuudella joka tarvitaan.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No niin, elossa ollaan edelleen, kahden viikon jälkeenkin!
Tässä ei ole saatu hökötystä vielä kasaan, kun ei nämä edes päivittäin etene. Mutta olisi kysymys tuosta ryypystä vielä.
Minkälaisiahan nuo lämpökytkimet on? Vanhoissa autoissa automaattiryyppy toimii niillä. Onkohan nuo on-off vai lineaarisia?
Jos olisi on-off, voisiko noihin kytkeä jonkun riittävän voimakkaan solenoidin?
Ihanteellisinta olisi toki, jos tämä vakiokaasari säilyisi, ja sen ryyppyä käytettäisiin. Ryyppyvipu on kohtuullisen jäykkä. Lähinnä säätöjen osalta ei haluaisi ehkä kaasaria vaihtaa. Amerikanmaalta saa postikuluineen alle neljään kymppiin bolt-on automaatiryypyllisen kaasarin, mutta periaatteessa siinä ei välttämättä säädöt ole kohdallaan.
Esim. tällainen
Tuossa olisi "solenoidi", jossa varmaan teho riittäisi vetämään ryyppyä, mutta ei saa olla päällä yli 10 sekuntia. Eli pitäisi olla välissä joku 2-3 sekunnin viivekatkaisin, joka nollautuu aina viiveen jälkeen.
Haussa siis taas tietenkin mahdollisimman bolt-on tyyppinen ratkaisu. Jos kovin paljon tulisi lisätyötä, voisi pistää tuon kaasarin sittenkin tilaukseen.
Tässä ei ole saatu hökötystä vielä kasaan, kun ei nämä edes päivittäin etene. Mutta olisi kysymys tuosta ryypystä vielä.
Minkälaisiahan nuo lämpökytkimet on? Vanhoissa autoissa automaattiryyppy toimii niillä. Onkohan nuo on-off vai lineaarisia?
Jos olisi on-off, voisiko noihin kytkeä jonkun riittävän voimakkaan solenoidin?
Ihanteellisinta olisi toki, jos tämä vakiokaasari säilyisi, ja sen ryyppyä käytettäisiin. Ryyppyvipu on kohtuullisen jäykkä. Lähinnä säätöjen osalta ei haluaisi ehkä kaasaria vaihtaa. Amerikanmaalta saa postikuluineen alle neljään kymppiin bolt-on automaatiryypyllisen kaasarin, mutta periaatteessa siinä ei välttämättä säädöt ole kohdallaan.
Esim. tällainen
Tuossa olisi "solenoidi", jossa varmaan teho riittäisi vetämään ryyppyä, mutta ei saa olla päällä yli 10 sekuntia. Eli pitäisi olla välissä joku 2-3 sekunnin viivekatkaisin, joka nollautuu aina viiveen jälkeen.
Keskuslukitusmoottori pistoolimalli 12V kaksijohtoinen slave
Keskuslukitusmoottori keskuslukituksen ovimoottori pistoolimalli 12V kaksijohtoinen slave. Keskuslukitusjärjestelmissä käytettävä moottori (servo), "pistooli" tyyppinen yleismalli. Kaksijohtoinen slave. Voimakas. Veto / työntöpituus max.
www.spelektroniikka.fi
Haussa siis taas tietenkin mahdollisimman bolt-on tyyppinen ratkaisu. Jos kovin paljon tulisi lisätyötä, voisi pistää tuon kaasarin sittenkin tilaukseen.
Viimeksi muokattu:
No niin, elossa ollaan edelleen, kahden viikon jälkeenkin!
Tässä ei ole saatu hökötystä vielä kasaan, kun ei nämä edes päivittäin etene. Mutta olisi kysymys tuosta ryypystä vielä.
Minkälaisiahan nuo lämpökytkimet on? Vanhoissa autoissa automaattiryyppy toimii niillä. Onkohan nuo on-off vai lineaarisia?
Ainoa oma kokemus on -90 luvulta Opel Ascona, sen automaattiryypyn toimilaite oli kaksoismettalliliuskasta tehty kellonjousi jonka vierestä kulki jäähdytysneste. Eli lähempänä lineaaria kuin on-off. Muistaakseni samassa purkissa oli myös vastuslankajousi eli ehkä siinä oli jo jokin joka mittasi jotain ja sääti myös ryyppyä... ei muista enää.
Jos koko on riittävä ja 2- toiminen niin voi sellaisenkin laittaa. Tai 2 erillistä.
Ihanteellisinta olisi toki, jos tämä vakiokaasari säilyisi, ja sen ryyppyä käytettäisiin. Ryyppyvipu on kohtuullisen jäykkä. Lähinnä säätöjen osalta ei haluaisi ehkä kaasaria vaihtaa. Amerikanmaalta saa postikuluineen alle neljään kymppiin bolt-on automaatiryypyllisen kaasarin, mutta periaatteessa siinä ei välttämättä säädöt ole kohdallaan.
Esim. tällainen
Tuossa olisi "solenoidi", jossa varmaan teho riittäisi vetämään ryyppyä, mutta ei saa olla päällä yli 10 sekuntia. Eli pitäisi olla välissä joku 2-3 sekunnin viivekatkaisin, joka nollautuu aina viiveen jälkeen.
Keskuslukitusmoottori pistoolimalli 12V kaksijohtoinen slave
Keskuslukitusmoottori keskuslukituksen ovimoottori pistoolimalli 12V kaksijohtoinen slave. Keskuslukitusjärjestelmissä käytettävä moottori (servo), "pistooli" tyyppinen yleismalli. Kaksijohtoinen slave. Voimakas. Veto / työntöpituus max.www.spelektroniikka.fi
Haussa siis taas tietenkin mahdollisimman bolt-on tyyppinen ratkaisu. Jos kovin paljon tulisi lisätyötä, voisi pistää tuon kaasarin sittenkin tilaukseen.
Kokeile ottaa vivut irti, silloin läpän pitäisi kyllä liikkua aika helposti. Jos ei niin akselilla voi olla joku jousi/vastaava tyyppinen hidastin jonka todennäköisesti voi purkaa pois.
Ja mittaa paljonko voimaa pitää olla, ei kannata arvata.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@ississ , joo purin sen vivustonkin pois, niin se jäykkyys oli siinä itse ryyppyläpässä. Siinä varmaan on joku kitkahommeli. Eihän tuommoinen läppä normisti mitenkään jäykkä ole, vaan sen pitäisi olla ihan löysä lörpäke. Mutta saa nähdä, löytyisi kyllä tuo arduinon mikroservo, joka varmasti jaksaisi käyttää tuollaista kevyesti liikkuvaa läppää. On siinä lisähaasteena esim. roiskeveden kestävyys (vesisade) jne... Toki joku kotelo kohtuu helppo vääntää jostain pellistä tms. mutta servo saattaa kestää roiskevettä jo sellaisenaankin. Lisäksi onhan siinä jotain moottorin/ilmanputsarin katteita jo suojana jonkin verran.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No joo, tilasin sen kaasarin, tulee sitten kun tulee tuolta Amerikanmaalta.
Mutta nyt suunnitellaan tuota hall-anturin kiinnitystä. Tarkoitus olisi valaa komponentit ja reikälevy putken pätkän sisälle. Niin mitä ainetta siinä kannattaa käyttää, kuumaliimaa vai jotain silikonia? Kuumaliimassa tulee se ongelma, ettei se ehkä se levity tasaisesti koko putkeen jäähtyessään matkalla, että silikonin varmaan saisi paremmin?
Tiedän, että on olemassa spesiaalisti just tähän suunnattuja silikoneja, mutta ei täällä ole mitään erikoisliikkeitä ja aika hurjan hintaista oli pieni määrä ainetta esim. Triopakilla. Käykö joku normi UV:n kestävä silikoni hommaan?
Mutta nyt suunnitellaan tuota hall-anturin kiinnitystä. Tarkoitus olisi valaa komponentit ja reikälevy putken pätkän sisälle. Niin mitä ainetta siinä kannattaa käyttää, kuumaliimaa vai jotain silikonia? Kuumaliimassa tulee se ongelma, ettei se ehkä se levity tasaisesti koko putkeen jäähtyessään matkalla, että silikonin varmaan saisi paremmin?
Tiedän, että on olemassa spesiaalisti just tähän suunnattuja silikoneja, mutta ei täällä ole mitään erikoisliikkeitä ja aika hurjan hintaista oli pieni määrä ainetta esim. Triopakilla. Käykö joku normi UV:n kestävä silikoni hommaan?
Viimeksi muokattu:
Kuumaliima ja epoksit on turhan kovia jos pitää kestää vettä.
Silikoni tiivistää parhaiten.
- Liittynyt
- 10.07.2017
- Viestejä
- 838
@ississ , ahaa, ehdit vastata juuri kun mie ehdin muokata viestiäni!
Nyt en ihan kässää, mikä ongelma muuten olisi esim. kuumaliimassa? Käsittääkseni sehän on periaatteessa sama kuin kuin osat olisi jonkun "oikean" muovin sisään valettuja? Epoksissa pelkään, että se laajenee jähmettyessään, ja saattaisi ehkä väännellä jotain komponentteja. Voin olla ihan väärässäkin.
EDIT: Jos kiinanpojan tekoälyyn on luottaminen, tällainen jokin oksiimipohjainen silari kävisi: Permatex RTV-silikoni kirkas 80ml | Motonet Oy
Eli ettei vapauta happoja kovettuessaan, se kai se tässä on?
Nyt en ihan kässää, mikä ongelma muuten olisi esim. kuumaliimassa? Käsittääkseni sehän on periaatteessa sama kuin kuin osat olisi jonkun "oikean" muovin sisään valettuja? Epoksissa pelkään, että se laajenee jähmettyessään, ja saattaisi ehkä väännellä jotain komponentteja. Voin olla ihan väärässäkin.
EDIT: Jos kiinanpojan tekoälyyn on luottaminen, tällainen jokin oksiimipohjainen silari kävisi: Permatex RTV-silikoni kirkas 80ml | Motonet Oy
Eli ettei vapauta happoja kovettuessaan, se kai se tässä on?
Viimeksi muokattu:
Lähinnä kai noissa kovissa liimoissa tulee ongelma, jos sauma pyrkii elämään, niin se ei pysy vesitiiviinä. Silikoni sietää sen elämisen.
Epoksia käytetään kyllä elektroniikassa paljon, mutta on siinä omat haasteensa. Ihan nätisti se siihen ympärille asettuu kovettuessaan, mutta lämpölaajentuminen repii sitä epoksin sisällä olevaa elektroniikkaa, jos lämpötila vaihtelee nopeasti. Silikoni kun on joustavaa niin lienee armollisempaa tässäkin asiassa, mutta omia kokemuksia ei sen käytöstä juuri ole.
Epoksia käytetään kyllä elektroniikassa paljon, mutta on siinä omat haasteensa. Ihan nätisti se siihen ympärille asettuu kovettuessaan, mutta lämpölaajentuminen repii sitä epoksin sisällä olevaa elektroniikkaa, jos lämpötila vaihtelee nopeasti. Silikoni kun on joustavaa niin lienee armollisempaa tässäkin asiassa, mutta omia kokemuksia ei sen käytöstä juuri ole.
Jos pitää oikeasti kestää vettä niin ei saa olla kova vaan hyvinkin joustava, siis silikoni/pehmeä kumi/sikaflex jne.@ississ , ahaa, ehdit vastata juuri kun mie ehdin muokata viestiäni!
Nyt en ihan kässää, mikä ongelma muuten olisi esim. kuumaliimassa? Käsittääkseni sehän on periaatteessa sama kuin kuin osat olisi jonkun "oikean" muovin sisään valettuja? Epoksissa pelkään, että se laajenee jähmettyessään, ja saattaisi ehkä väännellä jotain komponentteja. Voin olla ihan väärässäkin.
EDIT: Jos kiinanpojan tekoälyyn on luottaminen, tällainen jokin oksiimipohjainen silari kävisi: Permatex RTV-silikoni kirkas 80ml | Motonet Oy
Eli ettei vapauta happoja kovettuessaan, se kai se tässä on?
Kuumaliima on muuten hyvä mutta sen kanssa ei saa johtoja tiiviiksi (arvaa mistä tiedän
).Jos paikka on sellainen että pitää kestää vain ilman kosteutta niin ei ole kovin tarkkaa.
Silikonia olen itsekin tuontyyppisissä jutuissa käyttänyt. Kaikenlaisia kuumaliimoja sun muita liimojakin on tullut kokeiltua kun ei ole ollut silikonia juuri käden ulottuvilla mutta kuten ississ mainitsikin, ainakaan kuumaliimalla ei kovin tiivistä saa kun se ei oikein tartu yhtä hyvin esim johtimien pintaan.
Itse olen yleensä laittanut ensin kutistesukan anturin ja johtojen päälle ja sen jälkeen silikonilla johonkin putkeen ja hyvä on tullut.
Niin, ja kun kuumaliimasta puhuttiin niin sitä voi sulattaa ja valaa kuumailmapuhaltimen avullakin, saa näennäisesti tiiviitä valuja tehtyä mutta juurikin johtimien kohdalta (tai tiettyjen muiden materiaalien kanssa) ei tule tiivistä ja vesi juoksee kapillaari-ilmiön avustamana johtoa pitkin. Joihinkin tukirakennetäyttöihin tuo menetelmä kyllä sopii.
Ja voihan se alkuunsa jopa pitääkin vettä, mutta ei tarvi montaa lämpösykliä kun kuumaaliima repeää irti. Epoksikaan ei taita johdossa pitää, mutta jos on ip67 liitin, jonka runko jää sinne valun sisään, niin siitä kaiketi tulee ihan tiivis. (Kunhan kaikki tiivisteet on oikein paikoillaan, ne on yllättävän helppoa laittaa väärin)
- Liittynyt
- 10.07.2017
- Viestejä
- 838
No niin, homma on tosiaan edelleen elossa sekä etenee todella hitaasti ja epävakaasti. Pääasia, että etenee!
Nyt tässä kohtasin ongelman, olen varmaan ihan tolvana, kun en äkkää. En siis saa tuossa simulaattorissa toimimaan yksikertaista painonappia. Tarkoituksena on siis lisätä, kortille tehtyjä lisäpinnejä hyödyntäen, mahdollisuus ohittaa pelkästään jännitetarkkailulla suoritettava käynnistysproseduuri ja sitä myöten aloittaa lataaminen pelkästään hyödyntämällä palautuvaa katkaisinta esim. 2 sekuntia painettuna.
Pinnien määrittelyn pitäisi olla oikein, samoin simussa kytketty oikeaan pinniin. Toiminta on se, että käynnistyssykli käynnistyy heti ajastimen tullessa maaliin, oli kytkin kytkettynä tai ei. Koodi siis toteutuu kytkimen osalta jatkuvasti. Toiminta vaikuttaa siltä, että sisään tulee jatkuvasti tieto siitä, että kytkin on painettuna. Koodi on raakakoodi, mutta en nyt tajua, että tuossa kohdassa olisi jotain ongelmia.
Tässä on simulaattorin osoite, jolla voi halutessaan pelleillä: Charge controller - Wokwi ESP32, STM32, Arduino Simulator
Tässä vielä koko koodi:
Nyt tässä kohtasin ongelman, olen varmaan ihan tolvana, kun en äkkää. En siis saa tuossa simulaattorissa toimimaan yksikertaista painonappia. Tarkoituksena on siis lisätä, kortille tehtyjä lisäpinnejä hyödyntäen, mahdollisuus ohittaa pelkästään jännitetarkkailulla suoritettava käynnistysproseduuri ja sitä myöten aloittaa lataaminen pelkästään hyödyntämällä palautuvaa katkaisinta esim. 2 sekuntia painettuna.
Pinnien määrittelyn pitäisi olla oikein, samoin simussa kytketty oikeaan pinniin. Toiminta on se, että käynnistyssykli käynnistyy heti ajastimen tullessa maaliin, oli kytkin kytkettynä tai ei. Koodi siis toteutuu kytkimen osalta jatkuvasti. Toiminta vaikuttaa siltä, että sisään tulee jatkuvasti tieto siitä, että kytkin on painettuna. Koodi on raakakoodi, mutta en nyt tajua, että tuossa kohdassa olisi jotain ongelmia.
Tässä on simulaattorin osoite, jolla voi halutessaan pelleillä: Charge controller - Wokwi ESP32, STM32, Arduino Simulator
Tässä vielä koko koodi:
C++:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>
// System status variables
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5
// Fail state LCD display
#define FAILED_START 1
#define OVERVOLTAGE 2
#define FAILED_RPM 3
#define FAILED_VIBSENSOR 4
// Pin definitions
const int currentPin = A0;
const int voltagePin = A3;
const int motorPin = 2;
const int pwmPin = 9;
const int relayPin = 4;
const int rpmPin = 11;
const int overPin = 12;
const int starterPin = 3;
// Timers
Neotimer motorTime = Neotimer(10000); // 10 seconds for startup detection
Neotimer stepTime = Neotimer(1000); // 1 second for PWM step interval
Neotimer shutTime = Neotimer(15000); // 15 seconds for engine shutdown
Neotimer crankTime = Neotimer(4000); // 4 seconds for cranking
Neotimer crankWait = Neotimer(5000); // 5 seconds wait after failed crank
Neotimer voltageWait = Neotimer(10000); // 10 seconds wait for undervoltage
Neotimer sensorTime = Neotimer(5000); // 5 seconds check time for vibration sensor condition on RUNNNING status
Neotimer buttonTime = Neotimer(2000); // 2 seconds charging button timer, bypass voltage waiting
// LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Variables
int motorStatus = WAITING;
int startTry = 0;
int startInterval = 0; // Waiting time on after start attempt
int currentPwmStep = 0;
int pwmValues[] = { 15, 53, 91, 129 }; // PWM steps
int lcdFail = 0; // LCD fail state display
// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00; // Factor to convert ADC reading to voltage
// Define the points for current calculation / the line equation
float x1 = 0.500; // volts
float y1 = 0; // amps
float x2 = 4.300; // volts
float y2 = 150; // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1; // Variable to shift the whole current level
float sensVfactor = 20.00 / 4.9197; // 4.9197 volts = 20 volts, factor to convert high voltage to 0-5 V
const int N = 25; // Number of current readings to average
const int Y = 25; // Number of sensed voltage readings to average
int readings[N]; // Array to store the current readings
int readingsV[Y]; // Array to store the sensed voltage readings
float sensVoltage = 12.0; // Example voltage
float current = 0.0; // Example current
//RPM Calculation
unsigned long rpm = 0; // int rpm = 0;
unsigned long duration; // Sensor pulse in duration
void setup() {
Serial.begin(250000);
// Change timers on pins to change PWM freq to 122 Hz
// Pins D9 and D10 - 122 Hz
TCCR1A = 0b00000001; // 8bit
TCCR1B = 0b00000100; // x256 phase correct
// Initialize I2C and check if LCD is connected
Wire.begin();
Wire.beginTransmission(0x27);
if (Wire.endTransmission() == 0) {
// LCD is connected, proceed with initialization
lcd.begin(16, 2);
lcd.backlight();
lcd.clear();
} else {
// LCD is not connected, continue without initializing the LCD
Serial.println("LCD not connected. Skipping.");
}
// Pin modes
pinMode(currentPin, INPUT);
pinMode(voltagePin, INPUT);
pinMode(motorPin, INPUT_PULLUP);
pinMode(pwmPin, OUTPUT);
pinMode(relayPin, OUTPUT);
pinMode(rpmPin, INPUT_PULLUP);
pinMode(overPin, INPUT_PULLUP);
pinMode(starterPin, OUTPUT);
analogWrite(pwmPin, 255); // Start with PWM off
}
void startCharge() { // Start charging without to wait lower voltage, bypass voltage time
if (digitalRead(overPin == LOW)) {
if (!buttonTime.started()) {
buttonTime.start();
}
if (buttonTime.done()) {
motorStatus = STARTING;
digitalWrite(relayPin, HIGH); // Relay on
buttonTime.stop();
buttonTime.reset();
}
} else {
buttonTime.stop();
buttonTime.reset();
}
}
void motorCrankState() {
if (sensVoltage < 1.9) {
if (!voltageWait.started()) {
voltageWait.start();
}
if (voltageWait.done()) {
motorStatus = STARTING;
digitalWrite(relayPin, HIGH); // Relay on
voltageWait.stop();
voltageWait.reset();
}
} else {
voltageWait.stop();
voltageWait.reset();
}
}
void crank() {
if (startTry < 5 && startInterval == 0) {
if (rpm <= 300) { // If motor runs slower than this, switch starter relay on
digitalWrite(starterPin, HIGH);
if (!crankTime.started()) {
crankTime.start();
}
if (crankTime.done()) { // If max cranking time finished without succeeding start, switch starter relay off
digitalWrite(starterPin, LOW);
crankTime.stop();
crankTime.reset();
startTry++;
startInterval = 1;
}
} else if (rpm > 300) { // If motor runs faster than this, switch starter relay off
digitalWrite(starterPin, LOW);
startTry = 0;
motorStatus = STARTED;
crankTime.stop();
crankTime.reset();
}
}
}
void Waiter() {
if (startInterval == 1) {
if (!crankWait.started()) {
crankWait.start();
}
if (crankWait.done()) {
startInterval = 0;
crankWait.stop();
crankWait.reset();
}
}
}
void motorRunning() {
if (rpm > 1800 || digitalRead(motorPin) == HIGH) {
if (!motorTime.started()) {
motorTime.start();
}
if (motorTime.done()) {
motorStatus = RAMP_UP;
motorTime.stop();
motorTime.reset();
}
}
}
void rampUp() {
if (stepTime.repeat()) {
analogWrite(pwmPin, pwmValues[currentPwmStep]);
currentPwmStep++;
if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {
motorStatus = RUNNING;
stepTime.stop();
stepTime.reset();
}
}
}
void shutDown() {
if (current < 5) {
digitalWrite(relayPin, LOW); // Turn off the ignition relay
analogWrite(pwmPin, 15); // Set PWM to 5% (reduce alternator load)
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
motorStatus = WAITING; // Revert to WAITING state
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
}
}
void failState() { // Handle failed start attempts, overvoltage etc.
if (startTry == 5) { // Failed start
motorStatus = FAIL;
digitalWrite(starterPin, LOW); // Starter relay off
digitalWrite(relayPin, LOW); // Ignition switch relay off
lcdFail = FAILED_START;
} else if (sensVoltage >= 15) { // Overvoltage
motorStatus = FAIL;
digitalWrite(relayPin, LOW); // Ignition relay off
lcdFail = OVERVOLTAGE;
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
} else if ((rpm <= 900 || rpm >= 3700) && motorStatus == RUNNING) { // RPM sensor
motorStatus = FAIL;
digitalWrite(relayPin, LOW); // Ignition relay off
lcdFail = FAILED_RPM;
if (!shutTime.started()) {
shutTime.start(); // Start the shutdown timer
}
if (shutTime.done()) {
analogWrite(pwmPin, 255); // Set PWM to 100% (alternator electromagnet off)
shutTime.stop(); // Stop the timer
shutTime.reset(); // Reset the timer
}
// } else if (motorStatus == RUNNING) { // Vibration sensor
// if (digitalRead(motorPin) == LOW) {
// if (!sensorTime.started()) {
// sensorTime.start(); // Start the sensor blackout timer
// }
// if (sensorTime.done()) {
// motorStatus = FAIL;
// analogWrite(pwmPin, 15);
// lcd.setCursor(0, 0); // On lcd print "Faulty vibration signal"
// lcd.print("Virheellinen");
// lcd.setCursor(0, 1);
// lcd.print("V");
// lcd.print((char)0xe1);
// lcd.print("rin");
// lcd.print((char)0xe1);
// lcd.print("signaali");
// lcd.print(" ");
// sensorTime.stop();
// sensorTime.reset();
// }
// } else { // If signal reverts to normal during the time, stop timer
// sensorTime.stop();
// sensorTime.reset();
}
}
//}
void lcdDisplay() {
if (motorStatus == RUNNING || motorStatus == RAMP_UP) {
lcd.setCursor(0, 0);
lcd.print("Virta: ");
lcd.print(current);
lcd.print(" A ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
} else if (motorStatus == WAITING) {
lcd.setCursor(0, 0);
lcd.print("Odottaa... ");
lcd.setCursor(0, 1);
lcd.print("J");
lcd.print((char)0xe1);
lcd.print("nnite: ");
lcd.print(sensVoltage);
lcd.print(" V ");
} else if (motorStatus == STARTING || motorStatus == STARTED) {
lcd.setCursor(0, 0);
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistet");
lcd.print((char)0xe1);
lcd.print((char)0xe1);
lcd.print("n");
lcd.setCursor(0, 1);
lcd.print("................");
} else if (lcdFail == FAILED_START) {
lcd.setCursor(0, 0); // On lcd print "Engine start failed"
lcd.print("K");
lcd.print((char)0xe1);
lcd.print("ynnistys ");
lcd.setCursor(0, 1);
lcd.print("ep");
lcd.print((char)0xe1);
lcd.print("onnistui ");
} else if (lcdFail == OVERVOLTAGE) {
lcd.setCursor(0, 0); // On lcd print "Overvoltage"
lcd.print("Ylij");
lcd.print((char)0xe1);
lcd.print("nnite ");
lcd.setCursor(0, 1);
lcd.print(" ");
} else if (lcdFail == FAILED_RPM) {
lcd.setCursor(0, 0); // On lcd print "Faulty rpm"
lcd.print("Kierrosluku ");
lcd.setCursor(0, 1);
lcd.print("virheellinen ");
}
}
void loop() {
// Calculate current from sensor reading
// Calculate the charging current from the average
// Take N readings and store them in the array
for (int i = 0; i < N; i++) {
readings[i] = analogRead(currentPin);
delay(1); //Wait for a millisecond between readings
}
// Calculate the average of the N readings
float sum = 0;
for (int i = 0; i < N; i++) {
sum += readings[i];
}
float average = sum / N;
float voltage = average * voltageFactor; // Convert ADC reading to voltage
current = (m * voltage + b) * currentCal; // Convert voltage to current using the linear equation, correct with current calibration value if needed
// Calculate high voltage from voltage divider input
// Calculate the charging voltage from the average
// Take Y readings and store them in the array
for (int j = 0; j < Y; j++) {
readingsV[j] = analogRead(voltagePin);
delay(1); // Wait for a millisecond between readings
}
// Calculate the average of the N readings
float sumV = 0;
for (int j = 0; j < Y; j++) {
sumV += readingsV[j];
}
float averageV = sumV / Y;
float voltageV = averageV * voltageFactor; // Convert ADC reading to voltage
sensVoltage = voltageV * sensVfactor; // Convert voltage to real voltage
// RPM Calculation from Hall Sensor input
// {
// duration = pulseIn(rpmPin, FALLING, 500000); // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
// rpm = 60000.0 / duration * 1000; // See above
// }
// Simulate sensor readings via Serial input
if (Serial.available() > 0) {
char input = Serial.read();
switch (input) {
case '1':
rpm = 0;
break;
case '2':
rpm = 500;
break;
case '3':
rpm = 2000;
break;
case 'a':
current = 2;
break;
case 'b':
current = 20;
break;
case 'c':
current = 80;
break;
case 'z':
sensVoltage = 11;
break;
case 'x':
sensVoltage = 14;
break;
case 'y':
sensVoltage = 16;
break;
default:
Serial.println("Invalid input.");
return;
}
}
// Handle motor status
switch (motorStatus) {
case WAITING:
motorCrankState();
startCharge();
break;
case STARTING:
crank();
Waiter();
break;
case STARTED:
motorRunning();
break;
case RAMP_UP:
rampUp();
break;
case RUNNING:
shutDown();
break;
}
lcdDisplay();
failState();
// Debug output
Serial.print("Voltage: ");
Serial.print(sensVoltage);
Serial.print(" V, Current: ");
Serial.print(current);
Serial.print(" A, RPM: ");
Serial.print(rpm);
Serial.print(", Status: ");
Serial.print(motorStatus);
Serial.print(", Start try: ");
Serial.print(startTry);
Serial.print(", Start wait: ");
Serial.println(startInterval);
}Uutiset
-
NVIDIAn edullisemman pään GeForce RTX 50 -näytönohjaimet vuotojen kohteina
11.3.2025 01:43
-
AMD ilmoitti Ryzen 9 9900X3D:n ja 9950X3D:n myynnin alkavan 12. maaliskuuta
11.3.2025 00:29
-
Uusi artikkeli: Testissä Samsung Galaxy S25 sekä S25+
7.3.2025 18:07
-
Live: io-techin Tekniikkapodcast (10/2025)
7.3.2025 11:49
-
Qualcomm julkaisi ennätysnopeuksiin venyvän X85 5G -modeemin
7.3.2025 02:52
Uusimmat viestit
-
-
-
-
Keskustelua pakkoruotsista, eräs esimerkki suomalaisesta politiikasta- Viimeisin: LovelyWhore
-
