Arduino DIY projekti

[AndrisBB]

Kāds iepriekš ieminējās ka būtu lietderīgi izveidot Arduino (u.c.) sadaļu, kurā biedri varētu padalīties ar saviem bezjēdzīgajiem projektiem. Ja admini to izdarītu būtu lieliski.

 

Šodien aiz neko darīt iesāku spēlēties ar Lora moduļiem, lai paskatītos cik tālu pilsētas vidē Lora darbojas. Tākā pašam sava gateway pagaidām nav, tad doma ir nolikt mājā vienu moduli un tad uztaisīt otru, kuram būtu gps, tad staigāt pa pilsētu un sūtīt koordinātas uz pirmo.

Kā moduļus izmantoju LoPy moduļus, kuri pa lielam ir ESP32 uz kura uzlikts MicroPython + Semtech SX1272 Lora radio.

 

Saliku savu "hi-tec" mobilo staciju un uzrakstiju nelielu skriptu. Datus pārsūta, bet slinkums šodien iet staigāt pa pilsētu, jāatliek uz nākamnedēļu, plus jāuztaisa kautkādu weblapu ar karti kur atzīmēt koordinātas.

 

 

Datu sūtītājs

 

import time
import _thread
import os
import socket
import struct
from network import LoRa
from machine import UART

class Queue():
    def __init__(self, size):
        self.size = size
        self.lock = _thread.allocate_lock()
        self.data = list()

    def push(self, item):
        with self.lock:
            if len(self.data) < self.size:
                self.data.append(item)

    def len(self):
        with self.lock:
            return len(self.data)

    def pop(self):
        with self.lock:
            if len(self.data) > 0:
                return self.data.pop(0)

        return None

class Application():
    def __init__(self):
        self.gpsMessages = Queue(128)

    
    def start(self):
        _thread.start_new_thread(self.thread_gps, ())
        _thread.start_new_thread(self.thread_lora, ())

    def thread_gps(self):
        print("Starting gps thread")
        uart = UART(1, baudrate=9600)

        while True:
            while uart.any():
                data = uart.readline()
                code = data[0:6]

                if (code == b"$GNGGA") or (code == b"$GNGLL"):
                    print(data)
                    self.gpsMessages.push(data)
    
            time.sleep(1)

    
    def thread_lora(self):
        print("Starting lora thread")
        _LORA_PKG_FORMAT = "BB%ds"
        _DEVICE_ID = 0x01

        lora = LoRa(mode=LoRa.LORA, tx_iq=True)
        lora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
        lora_sock.setblocking(False)

        while True:
            while self.gpsMessages.len() > 0:
                msg = self.gpsMessages.pop()
                if msg is not None:
                    print("Sending message ...")
                    pkg = struct.pack(_LORA_PKG_FORMAT % len(msg), _DEVICE_ID, len(msg), msg)

                    try:
                        lora_sock.send(pkg)
                        print("Message sent")
                    except OSError:
                        print("Failed to send")
            
            time.sleep(1)



def main():
    app = Application()
    app.start()

main()

un saņēmējs

from network import LoRa
import socket
import time
import binascii
import struct

_LORA_PKG_FORMAT = "!BB%ds"

lora = LoRa(mode=LoRa.LORA, rx_iq=True)
lora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
lora_sock.setblocking(False)

print("start lora server ....")

while (True):
	recv_pkg = lora_sock.recv(512)
	if (len(recv_pkg) > 2):
		recv_pkg_len = recv_pkg[1]

		device_id, pkg_len, msg = struct.unpack(_LORA_PKG_FORMAT % recv_pkg_len, recv_pkg)
		print('Device: %d - Pkg: %s' % (device_id, msg))

 

Labots Aprīlis 2, 2017 - AndrisBB

[JDat]

LoRa ir moderni un interesanti. Mani interesē gan attālums, gan pēdējās suliņas izpiešana no ētera. Tāpat antenu konstrukcija sarežģitos apstākļos (mazas, bet strādā un nerada ziepes GPS uztvērējam utml).

 

Citādi... Nav īpaši ar ko padalīties. Tuvākajā laikā paredzēts patestēt skarbos apstākļos savus arduino. ja pasākums notiks, tad padalīšos gan ar kodu (kaut gan Gitubā tāpat var atrast), gan ar rezultātiem.

[JDat]

Vai kāds ir krāmējies ar RFM69HW moduļiem. Cik tālu velk? Kādas antenas esat lietojuši? Vai izmantojāt pilnu jaudu (+20 dBm)?

[WildGun]

Incanti!! Daži izmanto antenu vilkšanai un citādām izdarībām Arduino. Ja kas, man tādas domas nebija...........

[JDat]

Arduino? Nu jā, RFM69 manā gadījumā būs kopā ar arduino, nevis pitonu vai raspberiju svara un enerģijas budžeta dēļ. Tomēr te vairāk ir stāsts par lotpšanu (nav svarīgi vai arduino vai RPi). Stāsts ir par to ka man ik pa laikam noraijas raidīšana. Mēģinu saprast vai tās ir barošanas vai raidītāja un sliktas antenas problēmas. Tāpēc arī prasu. Galu galā projekts ir pietiekoši amizants un interesants. Jā kāds grib iesaistīties, tad cēturtdien iekš MakeRiga st\ast\išu sīkāk. Varbūt ka atradīsies arī kāds domubiedrs no zābakforuma.

[Usins]

rfm69hw raidīja

uz auto jumta bija parastais

antena - abiem 1/4 viļņa garuma stieple no cat5 vada.

 

pilsētas vidē caur 9stāvu namiem kādi max 300m laikam tvēra. 

 

kautkur ir kartē atzīmēts pārklājums. Tā kā es pilnīgs iesācējs, nebrīnos, ka citi bija publiskojuši ievērojami labākus rezultātus.

 

rfm no lemonas, vajadzētu būt labiem

 

 

[binary]

Pirms 6 minūtēm , rodrigez teica:

antena - abiem 1/4 viļņa garuma stieple no cat5 vada.

Tā starp citu, var pamēģināt to 1/4 vilni pareizināt ar 0.95.

[Usins]

69hw stāvēja kreisajā sarkanajā punktā.

 

jauda bija max, ja pareizi atceros, viņš vēl tagad tieši tāds stāv. ā, raidošais bija uz breadboard sasprausts, laikam būs nojaukc.

[JDat]

Rodrogez! Kā Tu noteici ka jauda bija max? Kura bibliokā tika izmantota lai palaistu max jaudā. Muguras smadzenes saka ka tur ir nianses. "Strunts par tām kartēm. Jautājums: vai ir izmēģināts raidīt nepārtraukti. To pašu OOK vai FSK, nevis ik pa laikam nosūtīt datu paciņas. Es te cīnos ar RTTY lietām nepārtrauktā raidīšanas režīmā. Izskatās ka tur kaut kas pēc laiciņa sagurst, jo raidītājs pārstāj raidīt un palīdz "power circle". Moduļa rebōot caur !RST pinu vēl neesmu mēģinājis. Man vajag lai vismaz stundu raida bez saguršanas. Pagaidām izlīdzos ar datasheet lasīšanu reģistru manipulāciju "no rokas", jo gatavās bibliotēkas "biški" pieklibo.

[Usins]

Tā arī nesapratu, kā piespiest viņu uztvert visu, kas "gaisā", entuziasms uz laiku noplaka. Mērķis bija wireless mbus paketes lasīt. 

Ar analogo oscilloscopu gar kājām bakstoties varēja manīt, ka tās paketes rf daļa uztver, bet ārā dabūt nemācēju.

[JDat]

Vai tik nav tā ka mēģināji izmantot arī iebūvēto digitālo daļu ar FIFO utml drisnām, kurām vajag ievērot šādas un tādas protokola nianses... Preambula, sync length utml. Es pagaidām aprobežojos ar RFM raidīšans režīmu un uztveru caur SDR uz datora vai mobīlās trubas.

[Usins]

Tas bija 2016. gada 22. martā - neatceros, bet varu paskatīties.

Noteikti izmantoju primitīvākās populārākās bibliotēkas, 

 

izmantotie skeči .ino ir saglabājušies.

 

kārties. augšā gan nekārās noteikti strādāja ilgāk par 1h.

 

 

[JDat]

Ja nav grūti, tad, varbūt, pameklē.

 

Man pat ir aizdomas, ka esmu nokurinājis PA1 TX daļu ar nesalāgotu antenu.

[Usins]

no telefona nevaru pārliecināties, bet izskatās pēc šiem. 

Struct_receive.ino

Struct_send.ino

[JDat]

Liels paldies! Pēc brīža paskatīšos. Rīt kārtējie testi un vakarā pastāstīšu par niansēm.

[Usins]

Tuvākas dienās labprāt uzmetīšu aci. Jāsaņemās un jāturpina.

 

EDIT brīdinu, šie ir no dripboxa pievienoti no tālruņa, neatverot nepārluecunities vai vispār ir īstie.

 

Labots Aprīlis 4, 2017 - rodrigez

[JDat]

Varbūt pastāsti sīkā. Pastāv no nulles atšķirīga iespēja ka varu palīdzēt.

[Usins]

rīt nosūtītu pm.

 

 

[Usins]

Labdien!

 

salipināju ārēju hidrostatu (tā laikam saucas mitruma līmeņa uzturētājs) gaisa mitrinātājām kuram iebūvētais miris (kamēr sagādāšu detaļu)

 

Uz Arduino Nano 5V atmega 168

displejs LCD 16x2 ar i2c plati

 

un nezkādēļ  divām šādām bibliotēkām

 

#include <LCD.h>
#include <LiquidCrystal_I2C.h>

 

Tur vēl šis tas lieks varētu būt. 

Viss bija labi, kamēr neievajadzējās iespēju izslēgt displeja apgaismojumu. Protams izraut džamperi vai vispār to atvienot nedrīkst. Vajadzēja to paveikt ar uz strīpdēļa jau iepiekš atrodamās spiedpogas uz D3. 

 

Interupts nostrādā, palaiž funkciju "apgaismojums". Bet ja šajā funkcijā iekļauju darbības ar displeja apgaismoju arduino pakarās smagi, (reset pat jāpatur biku)

iebūvēto led uz D13 slēgā ok. Pagaidām apgāju, ka interrupt funkcijā viņš tikai nomaina mainīgā "gaisma" vērtību un pēc tam parastajā loop jau aktualizē pagaismoju pēc šī mainīgā. T.i. no citām funkcijām apgaismojums vadās, bet šajā interrupta funkcijā karās. 

 

No bibliotēkām neko nesaprotu, kā mērķakis copy pastte un priecājos ja strādā. Tur zemāk jau kodā Backlight pin 3 rinda ko nozīmē? Fiziski D3 pin nemainās HIGH/LOW atkarībā no backlight stāvokļa.

 

Ir aizdomas, ka viņš tik un tā izmanto do D3 pinu uz kura man poga uzlodēta. Neskatoties uz i2c.

 

Uz citiem piniem pagaidām nemēģināju. Laikam vajadzēja ar to sākt. Gulēt gribējās tomēr. 

 

lai posts krāsaināks pieliku bildīti no fritzing. Tur būvējas tāda ~ univerāla rotaļu plate, tādēļ nevajag mēģināt saparst kāpēc tur ir šis un tas. 

PS piedošanu par sūdkodu. 

 

 

[code]
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#include "cactus_io_SHT31.h"

#define I2C_ADDR    0x3F // <<----- Add your address here.  Find it from I2C Scanner
#define BACKLIGHT_PIN     3
#define En_pin  2
#define Rw_pin  1
#define Rs_pin  0
#define D4_pin  4
#define D5_pin  5
#define D6_pin  6
#define D7_pin  7


cactus_io_SHT31 sht31;

LiquidCrystal_I2C  lcd(I2C_ADDR, En_pin, Rw_pin, Rs_pin, D4_pin, D5_pin, D6_pin, D7_pin);
float mitrums = 0.00;
float temp = 0.0;
float mitrumsi = 0.00;
int tempi = 0;
int val = 0;
int sethum = 50;
int hum_read = 50;
int hum_read_old = 50;
int laiks1 = 0;
int laiks2 = 0;
int kops_izmainam = 0;
volatile boolean gaisma = true;
const byte interruptPin = 3;
const byte ledPin = 13;

#include <stdio.h>
#include <DS1302.h>

const int kCePin = 5; // Chip Enable
const int kIoPin = 6; // Input/Output
const int kSclkPin = 7; // Serial Clock
// Create a DS1302 object.
DS1302 rtc(kCePin, kIoPin, kSclkPin);
String dayAsString(const Time::Day day) {
  switch (day) {
    case Time::kSunday: return "Sunday";
    case Time::kMonday: return "Monday";
    case Time::kTuesday: return "Tuesday";
    case Time::kWednesday: return "Wednesday";
    case Time::kThursday: return "Thursday";
    case Time::kFriday: return "Friday";
    case Time::kSaturday: return "Saturday";
  }
  return "(unknown day)";
}


void setup()
{
  pinMode(2, OUTPUT);
  pinMode(3, INPUT);
  pinMode(ledPin, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(interruptPin), apgaismojums, RISING);
  digitalWrite(2, HIGH);
  Wire.begin();
  lcd.begin (16, 2); //  <<----- My LCD was 16x2


  // Switch on the backlight
  lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home (); // go home
  int val = 0;



  Serial.begin(9600);
}

void loop()
{
  if (gaisma == false)  lcd.setBacklight(LOW);
  if (gaisma == true) lcd.setBacklight(HIGH);
  mitrums = sht31.getHumidity();
  // temp = sht31.getTemperature_C();
  //  mitrumsi = ( mitrums + 0.5 ) * 100;
  //  mitrums = mitrumsi / 100;
  val = analogRead(A1);
  hum_read = ( val - 50 ) / 9.7;
  hum_read = hum_read / 2;
  hum_read = hum_read * 2;
  if ( hum_read != sethum ) iestatisana();
  if (mitrums < sethum) digitalWrite(2, LOW);
  if (mitrums > sethum + 1) digitalWrite(2, HIGH);
  lcd.clear();
  lcd.setCursor ( 0, 0);
  lcd.print(" izmerits: "); lcd.print(mitrums, 0); lcd.print(" % ");
  lcd.setCursor ( 0, 1);
  lcd.print("iestatits: "); lcd.print(sethum, 1); lcd.print(" %");
  delay(500);
}

void iestatisana()
{
  lcd.clear();
  lcd.print ("  iestatisana");
  kops_izmainam = 0;
  while (kops_izmainam < 3000)
  {
    lcd.setCursor (0, 1);
    lcd.print("                ");
    val = analogRead(A1);
    hum_read = ( val - 50 ) / 9.7;
    hum_read = hum_read / 2;
    hum_read = hum_read * 2;
    if (hum_read != hum_read_old) laiks1 = millis();
    sethum = hum_read;
    hum_read_old = hum_read;
    kops_izmainam = millis() - laiks1;
    lcd.setCursor (7, 1);
    lcd.print (hum_read, 1);
    delay(100);
  }
}

void apgaismojums()
{
  if (gaisma)
  {
    gaisma = false;
    digitalWrite(13, LOW);
  } else
  {
    gaisma = true;
    digitalWrite(13, HIGH);
  }
  //Serial.print("nostradaja ");Serial.println(gaisma,1);
  //  if (gaisma == true)
  //  {
  //    lcd.setBacklight(LOW);
  //   gaisma = false;
  //  }
  //  else if (gaisma == false)
  //  {
  //    lcd.setBacklight(HIGH);
  //   gaisma = true;

[/code]

 

Labots Aprīlis 23, 2019 - Usins
asdf

[AndrisBB]

Pirms 22 minūtēm , Usins teica:

T.i. no citām funkcijām apgaismojums vadās, bet šajā interrupta funkcijā karās. 

Diezgan logjiski ka nokaras, ja tu interrupta handleri piemeram megjini printet. Nezinu, ko tur dara atmega 168, bet pie'lauju domu ka disablo interruptus pirms nonak tava handleri  pectam ar diseiblotiem interruptiem ir gruti kko izpirntet, nedomaju ka Serial.println seez "busy loopaa" bet izmanto interruptus, kuri tava gadijuma ir diseibloti

 

Vairak nevienu jautajumu no tava posta neizdevas izlobit

Labots Aprīlis 23, 2019 - AndrisBB

[AndrisBB]

Isuma mans padoms tads:

Nedari neko tadu, kas aiznjem laiku interruptu handleros, jo MCU parsledzas un interrupt modi un visdrizak diseiblo visus interuptus, lai neiztraucetu to, kuru tu tagad apstrada.

Tapec optimala gadijuma tu pavadi tur cik vien maz laika iespejams, piemeram tikai lai izmainitu mainigo, ta lai MCU atri var parslegties startp modem un nepazudetu citus interruptus.

 

Otrs padoms:

Ja tas interrupts rodas no pogas nospieshanas, tad pievieno "debounce", savadak nav iesp'ejams nospiest pogu neizraisot kadus 2 - 5 interruptus.

Pamekle piemerus "push button debouncing"

Labots Aprīlis 23, 2019 - AndrisBB

[Usins]

 

Jautajums bija - vai i2c lcd displejs var konfliktēt ar d3 interruptu?

 

Debounce ir izveidots ar kondensatoru un pāris rezistoriem.  Strādā apmierinoši. Kādi max 2-3 pogas nospiedieni sekundē iespejami. Pogai ok. Ideali pareizo shēmu ar hw signāla apstradi pagaidām neņēmos tik dēĺ pogas taisīt. 

Serial.print interrupt funkcijā stradāja ok.

[AndrisBB]

Nezinu, kas tur ir. Paskaties tajā LCD biblotekā. Nedomāju ka tur ir daudz koda.

[binary]

Nezinu, kā izpaužas tā interuptu disablēšana un kāpēc gan tā būtu vajadzīga, bet pazaudēt kādu interuptu gan nav problēma.

 

Ja atmiņa neviļ (pakliedziet, ja tomēr viļ, bet ne pārāk skaļi), tad kaut kādā interuptu reģistrā glabājas flagi, kas norāda, kurš interupts ir nostrādājis. Tad nu mcu var skatīties tajā reģistrā un izpildīt nostrādājušo interuptu handlerus. Neatceros, kurā brīdī flags tiek dzēsts - pirms vai pēc handlera izpildes. Ja brīdī, kad nostrādā interupts, flags jau ir "ieslēgts", tad jaunais interupts "pazūd".

 

Piekrītu viedoklim, ka no interupta handlera jālien ārā pēc iespējas ātrāk (ja nav vēlmes cītīgi rēķināt, cik daudz laika var atļauties pavadīt konkrētā handlerī, bet nu tā ir "augstākā pilotāža"). Variants ar "gaisma" mainīgā mainīšanu interupta handlerī ir pat ļoti ok.

[Usins]

Paldies! Iemācijos atvērt biblioteku, ar notepad++. 

Ir progress, turpmāk mācēšu skatities pieejamās komandas. 

Par pārējo savā bernudārza līmenī gudrāks ipaši netiku. EDIT: paliku gan. Sapratu, ka interrupt funkciju max īsu un bez komunikācijām būs veidot. 

 

1. Tad iekārta kas pievienota ar i2c var aizņemt šķietami brīvos arduino pin? 

1a. ā laikam i2c vispār nav nemaz jāstrādā interrupta funkcijā

2. To varētu saprast pēc bibliotēkas satura ja es mācētu?

3. Spriežot ka savādāk tas interrupts strādā, vienkārši sūtīt no viņa displejam komandas  pa i2c ir rupja kļūda, un es drīkstētu pieņemt to kā faktu bez izpratnes un to ņemt vērā turpmāk?

 

Labots Aprīlis 24, 2019 - Usins

[AndrisBB]

pirms 4 stundām , binary teica:

Ja atmiņa neviļ (pakliedziet, ja tomēr viļ, bet ne pārāk skaļi), tad kaut kādā interuptu reģistrā glabājas flagi, kas norāda, kurš interupts ir nostrādājis. Tad nu mcu var skatīties tajā reģistrā un izpildīt nostrādājušo interuptu handlerus. Neatceros, kurā brīdī flags tiek dzēsts - pirms vai pēc handlera izpildes. Ja brīdī, kad nostrādā interupts, flags jau ir "ieslēgts", tad jaunais interupts "pazūd".

Uz atmegas pa "defaulto", tad kad notiek interrupts processors izsledz visus interuptus globali un iesledz vinjus atpakal, kad ISR process tiek pabeigts, tapec kamer tiek apstradats interrupts, tikmer citi vinju neiztrauces. Savadak piemeram ir uz ARM, kur interrupti var but "nested" - interupts var interruptot interruptu, atkariba no prioritatem (kuras var konfiguret).

Tapec piemeram nav iespejams izmantot I2C (visdrizak izmanto interruptus) ieks ISR. Teoretiski var manuali enablot interruptus interrupt handleri, bet ta nav ta labaka ideja, jo I2C atkal diseiblos vinjus pie pirma interrupta.

Tapec ari notiek "dead lock", ja no ISR megjina ko darit ar I2C - interupti ir diseibloti, bet funkcija, kas raksta uz I2C, gaida uz kautkadu interruptu.

Ja laika kamer procesors apstrada ISR notiek cits interrupts, tad flags tiks "atzimets" un kad processors atgriezisies no ISR tas redzes flagu un izpildis nakomo interrupt handleri un nodzesis to flagu. Ja nenotiek vairaki identiski interrupti, kamer processors apstrada tadu pashu, tad interrupti pazudis.

 

Reti sanak stradat ar Atmegu, parsvara ar ARM, tapec varu kautkur kljudities. Bet Atmega ir ljoti primitivs izstradajums salidzinot ar ARM, tapec isti daudz jau tur nav ko zinat. 

[Jurkins]

Pag, tā uz ātro... Tev backlite_pin = 3 un interruptpin = 3?  Tas "pin 3" arī shēmā iet gan uz LCD gan uz pogu?

 

Kāpēc displejam vajag D1, D2, D3, D4, Rwpin un Rspin, ja šis ir pa i2c pieslēgts?

Labots Aprīlis 24, 2019 - Jurkins

[Usins]

@Jurkins fiziski nē. LCD ir i2c  uz A4 un A5 piniem.

šo rindu nozīmi nepārzinu:

 

#define BACKLIGHT_PIN     3
#define En_pin  2
#define Rw_pin  1
#define Rs_pin  0
#define D4_pin  4
#define D5_pin  5
#define D6_pin  6
#define D7_pin  7

LiquidCrystal_I2C  lcd(I2C_ADDR, En_pin, Rw_pin, Rs_pin, D4_pin, D5_pin, D6_pin, D7_pin);

lcd fiziskie pini aiz i2c pārveidotāja?

[Jurkins]

Nu nezinu...

LiquidCrystal_I2C  lcd(I2C_ADDR, En_pin, Rw_pin, Rs_pin, D4_pin, D5_pin, D6_pin, D7_pin);

Šo es nesaprotu. Šī rinda ir jābūt konstruktors, kas izveido LiquidCrystal_I2c klases objektu un šim ir trīs parametri  - i2c adrese, displeja kolonu skaits un displeja rindu skaits.  Pasen neesmu slēdzis displejus pie i2c, bet kaut kā tā atceros.

 

Tas "nesaprotamas" rindas ir vajadzīgas, ja šo displeju slēdz klāt "tradicionāli" izmantojot 7 arduino/atmegas pinus.

 

Kas notiek aiz i2c pārveidotāja jau arduino nemaz nezina.

 

Karoče, man šķiet, ka vispirmām kārtām Tev tur kaut kā ir par daudz. Tagad nav laika iedziļināties, no galvas neatceros īsti, bet ... tai liquid...h biblenei to parasto lcd.h nemaz nevajadzēja.

Labots Aprīlis 24, 2019 - Jurkins

[AndrisBB]

Kas tev ta par aizvesturisku biblioteku? Officialaja versija tur nekadu citu pinu nav, tik I2C adrese, kolonas un rindas. https://github.com/johnrickman/LiquidCrystal_I2C/blob/master/LiquidCrystal_I2C.h

 

Izmet to kas tev tur ir un lieto to kas ieks repo. Tur ir ari piemeri ieks Examples.

 

[binary]

2019.04.24. , 11:02, AndrisBB teica:

Uz atmegas pa "defaulto", tad kad notiek interrupts processors izsledz visus interuptus globali un iesledz vinjus atpakal, kad ISR process tiek pabeigts, tapec kamer tiek apstradats interrupts, tikmer citi vinju neiztrauces. Savadak piemeram ir uz ARM, kur interrupti var but "nested" - interupts var interruptot interruptu, atkariba no prioritatem (kuras var konfiguret).

Jā, tik tiešām uz atmegas interrupti tiek izslēgti, kad notiek interrupts. Nezināju (sen atmegas nav bakstītas).

When an interrupt occurs, the Global Interrupt Enable I-bit is cleared and all interrupts are disabled.

Par to "savādāk ir uz ARM, kur interrupti var būt "nested"" - no atmegas specenes (uzreiz pēc iepriekš citētā teikuma):

The user software can write logic one to the I-bit to enable nested interrupts. All enabled interrupts can then interrupt the currentinterrupt routine.

[AndrisBB]

Ganjau ka arī uz atmegas ir visādas fīčas, bet noteikti ka ne tik plašas kā uz ARM.

Vispār jābrīnās kā vēl tās ATMegas ir dzīvas, jo performances, enerģijas patēriņa un cenas ziņā ir daudz vārgākas par konkurentiem. Pa lielas taspats attiecas uz PIC, bet tie parasti patīk elektroniķiem. 

[AndrisBB]

Sāku taisīt kārtējo miini projektu, šoreiz Lego motoru un sensoru driveri priekš BBC Microbit. Lai sīkie var būvēt kautkādus robotus izmantojot Lego un kodu rakstot Python vai JavaScript, kurš nu viņiem labāk patīk.

Pagaidām vēl gaidu visādus sīkumus no Ķīnas, bet PCB jau atnāca un izdrukāju pirmo kastītes variantu.

 

Taisot kastīti nonācu pie secinājuma ka varu uztaisīt vēl mazliet mazāku un mazliet interesantāk būtu ja Microbits spraustos no aukšpuses, kā vecajāk spēļu konsolēs kārtridži.

Kad atnāks pārējās detaļas, tad jāpabeidz būs firmware un jāpārtais laikam PCB uz mazāku. Ja motoru konektorus sabīda mazliet tuvāk tad var ietaupīt kautkādus 8mm katrā virzienā.

 

 

 

[AndrisBB]

Paturpinot mazliet tēmo nolēmu pārtaisīt platīti tā ka:

 

* MicroBits sprauzas no augšas pa vidu

* Pieliku vēl 4 socketus, kur vēlāk varēs piespraust visādus sensorus

* Nomainiju DC Barrel Jack uz JST contaktu

* Noņēmu kristālus, jo integrētajam cristālam vajadzētu būt OK un nekādu baigo Clocka precizitāti man nevajag.

* Uztaisiju PCB mazliet mazāku (66x66 mm), jo iepriekš bij problēma ka viss kopējais kastītes izmērs sanāk pāra skaitļa izmēra pēc Lego caurumiem, bet visi Lego elementi ir nepāra, tapēc grūti integrēt kaukādā Lego dizainā

 

PCB taisu ar KiCad, cerams atkal kautkur nenolohojos un kautko neaizmirsu savienot.

 

Kopējā ideja nemainas.

Programma tiek rakstīta priekš MicroBit kas komunicē ar STM32 pa I2C busu. STM32 kontrolē motorus, nolasa pozīciju utt, plus turpmāk arī nolasīs sensorus. Motoru driveri ir tb6612fng. Vairāk tur īpaši nekā interesanta nav. 

 

Tagad atkal jāgaida kāda nedēļa kamēr atlidos no Ķīnas. Parasti pasūtu no PCBWay.com, 5 platītes maksā 4 USD. Sūtīšanas ar DHL 20 USB, ja gribas gaidīt tad var arī ar Chaina post pa 7 USD, bet tad 4 nedēļas jāgaida.

 

Brīvdienas beigušās, rīt atpakaļ pie darba.

 

 

Labots Janvāris 1, 2020 - AndrisBB

[Usins]

Lai nepiedrazotu adancēto @Jurkins un @AndrisBB tēmu, atzīmēšos, ka 

 

STM32F103C8T6 ar arduino bootloader, izdevās sekojot instrukcijām ar usb vadu, ko ierakstīt (blink). Nav onboard leda. brutālam digitalwrite high low bez delay periods 1,5us kas ir 4,6x ātrāk par UNO laikam 9x par nano/mikro būs. Pagaidām priecājos, kamēr nemēģināšu ko pieslēgt...

 

īsti nesaprotu ar ko šis Arduino compatable atšķiras no STM32F103C8T6 "parasta" izņemot to ka arduino bootloader ielādēts? 

 

Vēl nepatīkami samulsina paziņojums par atmiņas aizpildījumu...

 

UNO ieraksto šo BLINK kodu: 

Sketch uses 734 bytes (2%) of program storage space. Maximum is 32256 bytes.
Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Maximum is 2048 bytes.

 

Savukārt STM tādu pašu BLINK:

 

Sketch uses 15448 bytes (62%) of program storage space. Maximum is 24576 bytes.
Global variables use 3128 bytes (30%) of dynamic memory, leaving 7112 bytes for local variables. Maximum is 10240 bytes.

 

priekš šitā!  

void setup() {
  // initialize digital pin PB1 as an output.
  pinMode(PB1, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(PB1, HIGH);   // turn the LED on (HIGH is the voltage level)
    digitalWrite(PB1, LOW);    // turn the LED off by making the voltage LOW
  }

 

[AndrisBB]

Pirms 3 minūtēm , Usins teica:

Nav onboard leda. brutālam digitalwrite high low bez delay periods 1,5us

Interesanti. Japamegina bus cik atrs ir bez Arduino layera. Pliks STM HAL, vai pat bez HAL.

 

Pirms 4 minūtēm , Usins teica:

īsti nesaprotu ar ko šis Arduino compatable atšķiras no STM32F103C8T6 "parasta" izņemot to ka arduino bootloader ielādēts? 

 

Ta drosi vien ari ir.

 

Pirms 11 minūtēm , Usins teica:

Sketch uses 15448 bytes (62%) of program storage space. Maximum is 24576 bytes

Nu te ir divas interesantas dalas.

* Tas ka tavs blinky aiznjem 15kb. Vari ar objdump apskatit .bin vai .elf failu (vai ko vins tur izveido) kas tieshi tur ir salinkots vinja.

* Tas ka no 64k pari palikushi pari tikai 24k. Tadad bootloader aiznjem lielako dalju atminjas. Max ticams ari ka vinji izmanto speciali rezerveto atminju prieks bootloadera (Cortex ficha), bet tapat ka Arduino tur bootloaderu uz main flasha.

[Usins]

labots: 

 

ā, izvēloties ne "fake" rāda ka 64k atmiņas, nu labi. 

 

Sketch uses 15448 bytes (23%) of program storage space. Maximum is 65536 bytes.
Global variables use 3128 bytes (15%) of dynamic memory, leaving 17352 bytes for local variables. Maximum is 20480 bytes.

 

tās pāris rindas pārtpušas par 15kb ir diezgan traki. Asambleri mācīties negribu, bet šitais arī nav normāli. Intereresanti kad būs ar ko garāku. 

[AndrisBB]

Apskatot outputu no mana video otra topika var redzet ka kods ar HAL biblioteku aiznjem 5.5KB. Izklausas ticami, ka ar visu Arduino layeri varetu but 15k.

Interesanti cik butu bez STM HAL (Kautgan Arduino izmanto vinju apaksha), vai ar LL HAL.

[Klusu]

Pirms 15 minūtēm , Usins teica:

mācīties negribu

Tad raksti C. (STM32 bez Arduino)

[Jurkins]

Kad es pirmo reizi ieslēdzu arduino, man bija liels pārsteigums arī par tiem 734 baitiem dēļ "blinka".