The next small thing!

Jood · 14. November 2020

Leider sind die fehlenden Teile für meinen Triple X-Pander immer noch nicht gekommen,

daher musste ich mich anderweitig beschäftigen.

Resultat, die ersten Prototypen des Tiny Reset Rev.1a sind nicht nur fertig geworden, sie

funktionieren sogar, obwohl hier ein alter Sack Dinge lötet die er kaum noch sehen kann!

Der Tiny Reset Rev.1a macht genau das was der Name vermuten lässt, Restore wird

überwacht, und abhängig davon ein Reset ausgelöst.

Zusätzlich wird noch ein WS2812b LED-Stripe angesteuert, im Moment aber noch ohne

Farbwechsel oder ähnliche Spielereien.

In erster Linie ist die Entwicklung für meine C64 (meist mit Superkernal)

Funktionen:

- LED-Stripe (könnte auch blau leuchten)

- 3 Sec. Druck auf Restore löst einen Reset aus.

- Doppel-Tap auf Restore ruft das Superkernal auf (Doppel-Reset)

Im Bild Rev.1a, die Platine passt gut in 250407/250425/250466/250469, bei meinem

Ultimate muss ich noch schauen.

Und im einbauten Zustand, die Platine wird einfach auf den Tastatur-Header gesteckt,

die Zastatur dann auf die Platine.

Zusätzlich ist noch ein Anschluss für die Board-LED vorhanden, dieser kann wahlweise

auch von hinten bestückt werden (passt besser bei 250407/250425/250466), oder

von vorne (250469), beim Ultimate werde ich den Anschluss wohl fehlen lassen.

Und eingebaut in ein 250469, der LED-Header diesmal auf der anderen Seite.

Platzprobleme gibt es lediglich bei C64 mit Blechabdeckungen, ich überlege noch ob ich

das was anpasse.

Mfg Jood

Oh verdammt...

Das Ganze sollte in "heute so gebastelt", kann bitte ein MOD verschieben ?

Danke

Jood · 14. November 2020

So...

Hab den Tiny Reset nun auch in mein Assy 250466 eingebaut, sieht richtig gut aus.

Hier ohne LED-Stripe (in der Software ist es trotzdem noch drin).

Mfg Jood

Jood · 15. November 2020

Einen hab ich noch...

Zu guter letzt habe ich noch einen Tiny-Reset in meinen U64e einbaut, auch hier passt die Platine wunderbar.

Weil ein U64e keinen Superkernal hat ist die Funktion (Double-Tap) geändert und die Farbumschaltung damit

realisiert.

Also 3 Sec. Restore = RESET, Double-Tap auf Restore ändert die Farbe der LED-Stripe. Ich hab da im Moment

Lime, DarkSkyBlue, Rot und AUS drauf, die jeweils letzte Einstellung wird im EEProm gespeichert.

Natürlich wären hier auch Effekte wie Lauflicht möglich:

https://www.tweaking4all.com/h…druino-led-strip-effects/

Aber mir ist das zu unruhig!

Rechts am Tastatur-Header, die schwarze Platine passt gut zum U64e-Board,

zum fotografieren ist Schwarz auf Schwarz natürlich eher ungünstig!

Jood · 21. November 2020

Eine wichtige Lieferung für meine Neues Projekt: Dual-Port Weiche ist immer noch nicht gekommen, also habe ich Zeit für andere Dinge.

Unter anderem habe ich die Firmware für dieses Projekt überarbeitet, an der grundlegenden Funktion ändert sich aber nichts.

Die Firmware gibt es in 2 Versionen:

1. Ausgelegt für den C64 (getestet mit 250407/250425/250466/250469) mit Superkernal

- Langer Druck auf (3. Sekunden) löst einen Reset aus

- Doppel-Tab auf Reset ruft das Superkernal auf, hier wird einfach ein Doppel-reset ausgelöst.

- Zusätzlich liegt auf dem Header noch ein LED-Stripe WS2812b mit 21 LED's, der einfach nur Grün (CRGB::Lime) leuchtet, die Stromaufnahme ist auf ca. 90mA begrenzt (gemesssen).

C

#include <FastLED.h> //https://github.com/FastLED/FastLED
#include <ClickButton.h> //https://github.com/marcobrianza/ClickButton
//Constants
#define NUM_LEDS 21 //Const (Number of LED's)
#define DISABLE_LED 20 //Const (switch off last LED)
#define DATA_PIN PB0 //LED-Stripe (Pin 5 - MOSI)
#define RESERVE1 PB1 //Reserve (Pin 6 - MISO)
#define RESET_OUT PB2 //Reset to C64 (Pin 7 - SCK)
#define POWER_LED PB3 //Power LED C64 (Pin 2)
#define RESTORE_PIN PB4 //Restore von C64 (Pin 3)
#define WAIT_TIME 100 //Const Delay for Reset
#define BRIGHTNESS 80 //led brightness (limit power to 90 mA)
CRGB leds[NUM_LEDS]; //LED-Stripe, number of LED's
CRGB ledColor = CRGB::Lime; //LED-Stripe, current Color (RGB)
ClickButton Restore(RESTORE_PIN, LOW); //Restore Button
void setup() {
pinMode(RESET_OUT, INPUT); //Input without pullup, emulate open collector
pinMode(RESTORE_PIN, INPUT); //Input without pullup, Restore from C64
pinMode(POWER_LED, OUTPUT); //Output, Power LED for C64
digitalWrite(POWER_LED, LOW); //Power LED an
Restore.debounceTime = 35; //Debounce timer in ms
Restore.multiclickTime = 250; //Time limit for multi clicks
Restore.longClickTime = 3000; //time until "held-down clicks" register
FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
FastLED.setBrightness(BRIGHTNESS); //Set led brightness (save power)
FadeIn(ledColor);
}
void wait(uint32_t period) {
uint32_t time_now = millis();
while(millis() < time_now + period){
//wait approx. [period] ms
}
}
void ShowColor(byte r, byte g, byte b){
for (int i = 0; i < NUM_LEDS; i++) {
//switch of LED, center light on C64
if (i != DISABLE_LED) {
leds[i] = CRGB(g, r, b);
} else leds[i] = CRGB::Black;
}
FastLED.show();
}
void FadeIn(CRGB color){
float r, g, b;
for(int k = 0; k < 256; k=k+1) {
r = (k/256.0)*color.red;
g = (k/256.0)*color.green;
b = (k/256.0)*color.blue;
ShowColor(r, g, b);
}
}
void FadeOut(CRGB color){
float r, g, b;
for(int k = 255; k >= 0; k=k-2) {
r = (k/256.0)*color.red;
g = (k/256.0)*color.green;
b = (k/256.0)*color.blue;
ShowColor(r, g, b);
}
}
void loop() {
Restore.Update();
switch (Restore.clicks) {
case 2: //doubleClick
for (int i=0; i <= 1; i++) {
pinMode(RESET_OUT, OUTPUT);
wait(WAIT_TIME);
pinMode(RESET_OUT, INPUT);
wait(WAIT_TIME);
}
break;
case -1: //longpress
pinMode(RESET_OUT, OUTPUT);
while (!digitalRead(RESTORE_PIN)) {
digitalWrite(POWER_LED, !digitalRead(POWER_LED));
wait(WAIT_TIME);
}
digitalWrite(POWER_LED, LOW);
pinMode(RESET_OUT, INPUT);
Restore.clicks = 0;
wait(WAIT_TIME);
break;
default:
break;
}
}

Alles anzeigen

2. Eine Version für mein Ultimate 64e, welches in einem transparenten PixelWizard Gehäuse sitzt.

- Langer Druck auf (3. Sekunden) löst einen Reset aus

- da im Ultimate kein Superkernal sitzt habe den Doppel-Tab mit eine Farbumschaltung für den LED-Stripe belegt.

C

#include <EEPROM.h>
#include <FastLED.h> //https://github.com/FastLED/FastLED
#include <ClickButton.h> //https://github.com/marcobrianza/ClickButton
//Constants
#define NUM_LEDS 21 //Const (Number of LED's)
#define DISABLE_LED 0 //Const (switch off last LED)
#define DATA_PIN 0 //LED-Stripe (PB0, Pin 5 - MOSI)
#define RESERVE1 1 //Reserve (PB1, Pin 6 - MISO)
#define RESET_OUT 2 //Reset to C64 (PB2, Pin 7 - SCK)
#define POWER_LED 3 //Power LED C64 (PB3, Pin 2)
#define RESTORE_PIN 4 //Restore von C64 (PB4, Pin 3)
#define WAIT_TIME 100 //Const Delay for Reset
#define BRIGHTNESS 100 //led brightness, save Power
#define EEPROM_ADDR 0 //Memory - Configuration.
byte ledIndex = 0;
CRGB leds[NUM_LEDS]; //LED-Stripe, number of LED's
CRGB ledColor = CRGB::Lime; //Current LED Color
ClickButton Restore(RESTORE_PIN, LOW); //Restore Button
void setup() {
pinMode(RESET_OUT, INPUT); //Input without pullup, emulate open collector
pinMode(RESTORE_PIN, INPUT); //Input without pullup, Restore from C64
pinMode(POWER_LED, OUTPUT); //Output, Power LED for C64
digitalWrite(POWER_LED, LOW); //Power LED an
Restore.debounceTime = 35; //Debounce timer in ms
Restore.multiclickTime = 250; //Time limit for multi clicks
Restore.longClickTime = 3000; //time until "held-down clicks" register
FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
FastLED.setBrightness(BRIGHTNESS); //Set led brightness (save power)
SetColor(EEPROM.read(EEPROM_ADDR));
FadeIn(ledColor);
}
void wait(uint32_t period) {
uint32_t time_now = millis();
while(millis() < time_now + period){
//wait approx. [period] ms
}
}
void SetColor(byte index){
if ((index >= 0) && (index <= 4)){
ledIndex = index;
} else ledIndex = 0;
EEPROM.update(EEPROM_ADDR, ledIndex);
switch (ledIndex){
case 0:
ledColor = CRGB::Lime;
FadeIn(ledColor);
break;
case 1:
ledColor = CRGB::Red;
FadeIn(ledColor);
break;
case 2:
ledColor = CRGB::DeepSkyBlue;
FadeIn(ledColor);
break;
case 3:
ledColor = CRGB::Yellow;
FadeIn(ledColor);
break;
case 4:
ledColor = CRGB::Black;
break;
}
}
void ShowColor(byte r, byte g, byte b){
for (int i = 0; i < NUM_LEDS; i++) {
//switch of LED, center light on C64
if (i != DISABLE_LED) {
leds[i] = CRGB(g, r, b);
} else leds[i] = CRGB::Black;
}
FastLED.show();
}
void FadeIn(CRGB color){
float r, g, b;
for(int k = 0; k < 256; k=k+1) {
r = (k/256.0)*color.red;
g = (k/256.0)*color.green;
b = (k/256.0)*color.blue;
ShowColor(r, g, b);
}
}
void FadeOut(CRGB color){
float r, g, b;
for(int k = 255; k >= 0; k=k-2) {
r = (k/256.0)*color.red;
g = (k/256.0)*color.green;
b = (k/256.0)*color.blue;
ShowColor(r, g, b);
}
}
void loop() {
Restore.Update();
switch (Restore.clicks) {
case 2: //doubleClick
Restore.clicks = 0;
FadeOut(ledColor);
SetColor(ledIndex+1);
break;
case -1: //longpress
Restore.clicks = 0;
pinMode(RESET_OUT, OUTPUT);
while (!digitalRead(RESTORE_PIN)) {
digitalWrite(POWER_LED, !digitalRead(POWER_LED));
wait(WAIT_TIME);
}
digitalWrite(POWER_LED, LOW);
pinMode(RESET_OUT, INPUT);
wait(WAIT_TIME);
break;
default:
break;
}
}

Alles anzeigen

Falls Interesse besteht packe ich das Projekt (KiCAD) auch noch hier rein.

Mfg Jood

-micky · 21. November 2020

Ja, interesse besteht. Nur wo bekomme ich eine Platine her?

Micky

Jood · 21. November 2020

Ich hatte ja bereits erwähnt das das Ding neben der Reset/Superkernal-Funktion, noch eine LED-Stripe steuern kann.

Was haltet ihr davon (rechts im Bild übrigens mein Ultimate 64e) ?

Könnte neben der einfachen Beleuchtung noch mit in den Tiny Reset!

Mfg Jood

Jood · 28. November 2020

Kleine Video gemacht, Qualität ist nicht so gut, aber man sieht was.

[Externes Medium: https://youtu.be/YYRA7nGCU94]

Mfg Jood

VomitOnLino · 28. November 2020

Ja, da bin ich auf jeden Fall interessiert.

Habe zwar einen Reset-taster (ohne Bohren) angeloetet aber das ist nochmal ein ganzes Stueck eleganter.

Wizards71 · 29. November 2020

habe auch Interesse!

Jood · 29. November 2020

Ich habe die Platine des Tiny Reset nochmal ein wenig überarbeitet und die Anschlüsse für den

LED-Stripe und Reset extra herausgeführt.

Mich hat gestört das ich jedesmal wenn ich Änderungen an der Software vornehmen wollte.

ich ständig die LED-Stripe und Reset abiehen musste um den ISP-Programmer aufzustecken

Gerade mal bei JCLPCB geschaut, Platinen sind fertig, mal schauen wie lange nun die Lieferung

dauert.

An der Firmware habe ich auch noch gearbeitet, der Triple-Tab im Video gefiel mir nicht wirklich.

Ich hab das nun so geändert das nach dem 3 Sek. Reset Restore einfach gehalten wird, dann

wird im Sekundentakt durch die verschiedenen Effekte gegangen.

Sobald Restore losgelassen wird bleibt der aktuelle Effekt, und wird auch beim Kaltstart aktiv.

Mfg Jood

Rendering direkt von JCLPCB (Screenshot)

Shadow-aSc · 29. November 2020

..also jetzt hab ich auch Interesse - ich brauch auch gleich 2 Platinen!

ch1ller · 29. November 2020

Ich würd auch eine nehmen

Jood · 5. Dezember 2020

Moin,

ich habe die ruhigen Stunden am Samstag Morgen (bevor die Hunde wachwerden) genutzt

um den ersten Tiny Reset Rev.1b zu löten.

Das Ganze lässt sich schlecht fotografieren, daher auch noch ein KiCAD-Rendering

Die kleine Adapterplatine passt auch wunderbar in mein Assy 240469.

In mein Assy 250466 passt der Tiny Reset Rev.1b leider nicht, links befindet sich ein ganzes

Rudel Dioden (neben dem Tastaturhalter) diese stören beim Einbau.

Bei meinem Ultimate 64e muss ich noch probieren, da sollte aber genug Platz sein.

Trotz dieses kleinen Fehlschlags bin ich insgesamt doch noch zufrieden, die Rev.1b eignet sich

hervoragend als Entwicklungsboard, durch den zusätzlichen Header für LED-Stripe und den

Reset muss ich nicht ständig umstecken wenn ich etwas ausprobieren möchte.

Also bleiben in meinem Assy 250425/250466 weiter die Rev.1a Platinen, das Ultimate 64e und

die Assy 250469 dann die Rev.1b.

Mfg Jood

Jood · 5. Dezember 2020

Hab mir zum ausprobieren so ein USB Microskop geholt, eher ein preiswertes Model.

Eigentlich weil ich zunehmend SMD verwende und meine Augen langsam nachlassen.

War e schlechte Idee, jetzt bekomme ich Angst vor meinen eigenen Lötstellen, hier

mal ein Beispiel: Tiny Reset Rev.1a

Zu meiner Verteidigung, das muss einer meiner ersten Versuche gewesen sein.

Mfg Jood

DeSegi · 5. Dezember 2020

Da habe ich mal wieder was übersehen!

Bitte auch 2 mal + Prototyp(en)!

Jood · 5. Dezember 2020

Zitat von DeSegi

Bitte auch 2 mal + Prototyp(en)!

... Keine Bauteile mehr ...

Mir sind die 20 poligen Header ausgegangen, später...

Der ist doch schon besser!

adtbm · 6. Dezember 2020

Ja, ich habe mir inzwischen auch angewöhnt für solche Lötarbieten nur noch das Mikroskop zu verwenden.

Es ist zwar etwas Umgewöhnung, geht aber nach etwas Übung sehr gut und ich komme mit den billigen China USB Mikroskopen eigentlich sehr gut klar.

Wenn ich arg kleinen Kram löten muss (Chips mit 0.25mm Beinabstand z.B.) dann löte ich erst ein paar Widerstände und wage mich dann an den Tüddelkram.

-micky · 6. Dezember 2020

Bei der 2-fach und 3-fach Weiche hätte man nun wirklich kein SMD gebraucht. Soo viel größer wären die mit normalen Bauteilen auch nicht gewesen.

Micky

Jood · 2. Mai 2021

So...

Auch wenn es auf wenig Resonanz trifft, Jood braucht Raum für seine Selbstverwirklichung!

Der Tiny Reset 84 Rev.1a wird als Adapter zwischen Tastatur und Board gesteckt.

Wie bereits unter Heute so gebastelt ... erwähnt habe ich weiter an meinem Tiny Reset gearbeitet.

Ich habe den ATTiny85 gegen einen ATTiny84 getauscht, damit gewinne ich zusätzliche freie I/O's,

die ich für eine (einfache) Tastaturüberwachung verwende.

In dieser Version erfolgt der Wechsel des Kernal's über die Tastaturkombinationen Restore-(F1..F7),

somit werden 4 Kernal's unterstützt.

Zusätzlich steht noch der bekannte Reset über 3 sek. Restore zur Verfügung.

Die Power-LED wird als Feedback verwendet, wird z.B. die Restore-Taste > 3 sek. gedrückt beginnt

die Power-LED schnell zu blinken.

Auch der Wechsel des Kernal's über Restore-(F1-F7) wird über das Blinken der Power-LED angezeigt.

Die Power-LED kann über PWM gedimmt werden , die neuen LED's sind leider heller als die Originalen.

Die RGB-LED wird in der aktuellen Software NICHT unterstützt, der Header braucht daher auch nicht

eingelötet werden, allerdings leuchten diese LED's planlos mit wenn sie verbaut sind.

Ich packe einfach mal die *.ino hier rein, wer mag kann rüberschauen, für Verbesserungsvorschläge

bin ich jederzeit offen.

C

//Tiny Reset 84 Rev.1a, Quad Kernalswitch for C64
//RGB-LED are NOT supported in ATTiny84 version
//press and hold RESTORE (3 sec.) performs a Reset
//RESTORE-F1 - Kernal 0 (e.g. Standard Kernal)
//RESTORE-F3 - Kernal 1 (e.g. Jiffy DOS)
//RESTORE-F5 - Kernal 2 (e.g. Dolphin DOS)
//RESTORE-F7 - Kernal 3 (e.g. Speed DOS)
#include <EEPROM.h>
#include <ClickButton.h> //https://github.com/marcobrianza/ClickButton
//Constants
#define RESET_OUT PA4 //Ext. Reset (SCK) - Emulate Open Collector
#define A13_KERNAL PA5 //A13 (MISO)
#define A14_KERNAL PA6 //A14 (MISO)
#define LED_GREEN PA7 //LED Grün
#define RESTORE_PIN 10 //C64 Restore
#define WAIT_TIME 100 //Delay for Reset
#define MEMORY 0 //Speicher - aktuelles Kernal
#define DUTYCYCLE 50 //LED Helligkeit in %
#define KERNALFLAG 80 //Flag for Kernalswitch (changed)
//Kernalswitch, Konstanten für Addressleitungen
const byte Switch[] = {B00000000, B00100000, B01000000, B01100000};
volatile byte Kernal = 0; //Current Kernal;
volatile boolean Toogle = false; //Toogle Flag für LED
ClickButton Restore(RESTORE_PIN, LOW); //Restore Button
void setup() {
PORTA = B00000000; //Port A, alle LED's u. Pullup's aus
DDRA = B11100000; //LED's - Output, Ext. Reset u. CIA (PB3..PB6) - Input
PORTB = B00000000; //Port B, alle Pullup's aus, //bis auf Restore (Testzwecke)
DDRB = B11111000; //Port B, CIA (Row PA7, PA0) - Input, Restore - Input
cli(); //Interrupts sperren
GIMSK |= (1 << PCIE1); // PORTB PinChange interrupt
PCMSK1 |= B00000110; // Rows: PB1(CIA PA0), PB2(CIA PA7)
//Timer 1 Setup, used for LED PWM
TCCR1A = 0; TCCR1B = 0; TCNT1 = 0; // Clear registers
OCR1A = 4; // 31,25 kHz (8000000/((4+1)*64))
TCCR1B |= (1 << WGM12); // CTC
TCCR1B |= (1 << CS11)|(1 << CS10); // Prescaler 64
TIMSK1 |= (1 << OCIE1A); // Output Compare Match A Interrupt Enable
sei(); //Interrupts freigeben;
Restore.debounceTime = 35; //Debounce timer in ms
Restore.multiclickTime = 250; //Time limit for multi clicks
Restore.longClickTime = 3000; //time until "held-down clicks" register
Kernal = EEPROM.read(MEMORY);
SetKernal(Kernal, false);
}
//wait ohne Delay. keine Ahnung ob das besser ist!
void wait(uint32_t period) {
uint32_t time_now = millis();
while(millis() < time_now + period){
//wait approx. [period] ms
}
}
//Kapselung für Schreibzugriff auf volatile Variable (Interrupt sperren)
void SetToogle(boolean Value) {
noInterrupts();
Toogle = Value;
interrupts();
}
//Setzen des neuen Kernal's, optionaler Reboot
void SetKernal(byte index, boolean reboot) {
noInterrupts();
if (reboot) {
pinMode(RESET_OUT, OUTPUT);
}
if ((index >= 0) && (index <= 3)){
Kernal = index;
} else Kernal = 0;
PORTA = Switch[Kernal];
interrupts();
}
//Soft-PWM für LED-Steuerung (Timer 1 Interupt)
ISR(TIMER1_COMPA_vect) {
static byte cnt = 0;
byte Brightness = 0;
Brightness = map(DUTYCYCLE, 0, 100, 0, 255);
cnt++;
if (cnt <= Brightness) {
digitalWrite(LED_GREEN, !Toogle);// & ((Kernal == 0)|(Kernal == 3)));
} else digitalWrite(LED_GREEN, LOW);
}
//C64 Tastaturabfrage, nur F-Tasten (PinnChange Interrupt);
ISR(PCINT1_vect) {
//Wenn Restore gedrückt und nicht bereits ein Reset läuft)
if (!digitalRead(RESTORE_PIN)){
switch (PINB & B00000110) {
case B00000100: //Row 0
switch (PINA & B00001111) {
case B00000111: //F1 gedrückt
Kernal = (0 | KERNALFLAG);
break;
case B00001011: //F3 gedrückt
Kernal = (1 | KERNALFLAG);
break;
case B00001101: //F5 gedrückt
Kernal = (2 | KERNALFLAG);
break;
case B00001110: //F7 gedrückt
Kernal = (3 | KERNALFLAG);
break;
}
break;
}
}
}
void loop() {
SetToogle(false);
static byte Backup = Kernal;
noInterrupts();
if (Kernal != Backup) {
Kernal &= ~(KERNALFLAG);
SetKernal(Kernal, true);
EEPROM.update(MEMORY, Kernal);
Backup = Kernal;
while (!digitalRead(RESTORE_PIN)) {
SetToogle(!Toogle);
wait(WAIT_TIME);
}
} else pinMode(RESET_OUT, INPUT);
interrupts();
Restore.Update();
switch (Restore.clicks) {
case -1: //Longpress (3000 ms)
Restore.clicks = 0;
pinMode(RESET_OUT, OUTPUT);
while (!digitalRead(RESTORE_PIN)) {
SetToogle(!Toogle);
wait(WAIT_TIME);
}
break;
}
}

Alles anzeigen

Mfg Jood

Asklia · 2. Mai 2021

Ich spende mMal etwas Anerkennung: Ich finde die Idee cool, das erspart das Anbohren und Verschandeln der Gehäuse! "Einfach aufstecken".

Allerdings nur für einen C64 mit einreihigem Tastaturanschluss. Ich frage mich schon, wie das Teil für einen SX64 aussehen könnte. Aber diese Zielgruppe ist ja nochmals kleiner